bin/default/librpc/gen_ndr/py_srvsvc.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_srvsvc.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_srvsvc_c.h"
  10
  11 #include "librpc/gen_ndr/misc.h"
  12 #include "librpc/gen_ndr/security.h"
  13 #include "librpc/gen_ndr/svcctl.h"
  14 staticforward PyTypeObject srvsvc_NetCharDevInfo0_Type;
  15 staticforward PyTypeObject srvsvc_NetCharDevCtr0_Type;
  16 staticforward PyTypeObject srvsvc_NetCharDevInfo1_Type;
  17 staticforward PyTypeObject srvsvc_NetCharDevCtr1_Type;
  18 staticforward PyTypeObject srvsvc_NetCharDevInfoCtr_Type;
  19 staticforward PyTypeObject srvsvc_NetCharDevQInfo0_Type;
  20 staticforward PyTypeObject srvsvc_NetCharDevQCtr0_Type;
  21 staticforward PyTypeObject srvsvc_NetCharDevQInfo1_Type;
  22 staticforward PyTypeObject srvsvc_NetCharDevQCtr1_Type;
  23 staticforward PyTypeObject srvsvc_NetCharDevQInfoCtr_Type;
  24 staticforward PyTypeObject srvsvc_NetConnInfo0_Type;
  25 staticforward PyTypeObject srvsvc_NetConnCtr0_Type;
  26 staticforward PyTypeObject srvsvc_NetConnInfo1_Type;
  27 staticforward PyTypeObject srvsvc_NetConnCtr1_Type;
  28 staticforward PyTypeObject srvsvc_NetConnInfoCtr_Type;
  29 staticforward PyTypeObject srvsvc_NetFileInfo2_Type;
  30 staticforward PyTypeObject srvsvc_NetFileCtr2_Type;
  31 staticforward PyTypeObject srvsvc_NetFileInfo3_Type;
  32 staticforward PyTypeObject srvsvc_NetFileCtr3_Type;
  33 staticforward PyTypeObject srvsvc_NetFileInfoCtr_Type;
  34 staticforward PyTypeObject srvsvc_NetSessInfo0_Type;
  35 staticforward PyTypeObject srvsvc_NetSessCtr0_Type;
  36 staticforward PyTypeObject srvsvc_NetSessInfo1_Type;
  37 staticforward PyTypeObject srvsvc_NetSessCtr1_Type;
  38 staticforward PyTypeObject srvsvc_NetSessInfo2_Type;
  39 staticforward PyTypeObject srvsvc_NetSessCtr2_Type;
  40 staticforward PyTypeObject srvsvc_NetSessInfo10_Type;
  41 staticforward PyTypeObject srvsvc_NetSessCtr10_Type;
  42 staticforward PyTypeObject srvsvc_NetSessInfo502_Type;
  43 staticforward PyTypeObject srvsvc_NetSessCtr502_Type;
  44 staticforward PyTypeObject srvsvc_NetSessInfoCtr_Type;
  45 staticforward PyTypeObject srvsvc_NetShareInfo0_Type;
  46 staticforward PyTypeObject srvsvc_NetShareCtr0_Type;
  47 staticforward PyTypeObject srvsvc_NetShareInfo1_Type;
  48 staticforward PyTypeObject srvsvc_NetShareCtr1_Type;
  49 staticforward PyTypeObject srvsvc_NetShareInfo2_Type;
  50 staticforward PyTypeObject srvsvc_NetShareCtr2_Type;
  51 staticforward PyTypeObject srvsvc_NetShareInfo501_Type;
  52 staticforward PyTypeObject srvsvc_NetShareCtr501_Type;
  53 staticforward PyTypeObject srvsvc_NetShareInfo502_Type;
  54 staticforward PyTypeObject srvsvc_NetShareCtr502_Type;
  55 staticforward PyTypeObject srvsvc_NetShareInfo1004_Type;
  56 staticforward PyTypeObject srvsvc_NetShareCtr1004_Type;
  57 staticforward PyTypeObject srvsvc_NetShareInfo1005_Type;
  58 staticforward PyTypeObject srvsvc_NetShareCtr1005_Type;
  59 staticforward PyTypeObject srvsvc_NetShareInfo1006_Type;
  60 staticforward PyTypeObject srvsvc_NetShareCtr1006_Type;
  61 staticforward PyTypeObject srvsvc_NetShareInfo1007_Type;
  62 staticforward PyTypeObject srvsvc_NetShareCtr1007_Type;
  63 staticforward PyTypeObject srvsvc_NetShareCtr1501_Type;
  64 staticforward PyTypeObject srvsvc_NetShareInfoCtr_Type;
  65 staticforward PyTypeObject srvsvc_NetSrvInfo100_Type;
  66 staticforward PyTypeObject srvsvc_NetSrvInfo101_Type;
  67 staticforward PyTypeObject srvsvc_NetSrvInfo102_Type;
  68 staticforward PyTypeObject srvsvc_NetSrvInfo402_Type;
  69 staticforward PyTypeObject srvsvc_NetSrvInfo403_Type;
  70 staticforward PyTypeObject srvsvc_NetSrvInfo502_Type;
  71 staticforward PyTypeObject srvsvc_NetSrvInfo503_Type;
  72 staticforward PyTypeObject srvsvc_NetSrvInfo599_Type;
  73 staticforward PyTypeObject srvsvc_NetSrvInfo1005_Type;
  74 staticforward PyTypeObject srvsvc_NetSrvInfo1010_Type;
  75 staticforward PyTypeObject srvsvc_NetSrvInfo1016_Type;
  76 staticforward PyTypeObject srvsvc_NetSrvInfo1017_Type;
  77 staticforward PyTypeObject srvsvc_NetSrvInfo1018_Type;
  78 staticforward PyTypeObject srvsvc_NetSrvInfo1107_Type;
  79 staticforward PyTypeObject srvsvc_NetSrvInfo1501_Type;
  80 staticforward PyTypeObject srvsvc_NetSrvInfo1502_Type;
  81 staticforward PyTypeObject srvsvc_NetSrvInfo1503_Type;
  82 staticforward PyTypeObject srvsvc_NetSrvInfo1506_Type;
  83 staticforward PyTypeObject srvsvc_NetSrvInfo1509_Type;
  84 staticforward PyTypeObject srvsvc_NetSrvInfo1510_Type;
  85 staticforward PyTypeObject srvsvc_NetSrvInfo1511_Type;
  86 staticforward PyTypeObject srvsvc_NetSrvInfo1512_Type;
  87 staticforward PyTypeObject srvsvc_NetSrvInfo1513_Type;
  88 staticforward PyTypeObject srvsvc_NetSrvInfo1514_Type;
  89 staticforward PyTypeObject srvsvc_NetSrvInfo1515_Type;
  90 staticforward PyTypeObject srvsvc_NetSrvInfo1516_Type;
  91 staticforward PyTypeObject srvsvc_NetSrvInfo1518_Type;
  92 staticforward PyTypeObject srvsvc_NetSrvInfo1520_Type;
  93 staticforward PyTypeObject srvsvc_NetSrvInfo1521_Type;
  94 staticforward PyTypeObject srvsvc_NetSrvInfo1522_Type;
  95 staticforward PyTypeObject srvsvc_NetSrvInfo1523_Type;
  96 staticforward PyTypeObject srvsvc_NetSrvInfo1524_Type;
  97 staticforward PyTypeObject srvsvc_NetSrvInfo1525_Type;
  98 staticforward PyTypeObject srvsvc_NetSrvInfo1528_Type;
  99 staticforward PyTypeObject srvsvc_NetSrvInfo1529_Type;
 100 staticforward PyTypeObject srvsvc_NetSrvInfo1530_Type;
 101 staticforward PyTypeObject srvsvc_NetSrvInfo1533_Type;
 102 staticforward PyTypeObject srvsvc_NetSrvInfo1534_Type;
 103 staticforward PyTypeObject srvsvc_NetSrvInfo1535_Type;
 104 staticforward PyTypeObject srvsvc_NetSrvInfo1536_Type;
 105 staticforward PyTypeObject srvsvc_NetSrvInfo1537_Type;
 106 staticforward PyTypeObject srvsvc_NetSrvInfo1538_Type;
 107 staticforward PyTypeObject srvsvc_NetSrvInfo1539_Type;
 108 staticforward PyTypeObject srvsvc_NetSrvInfo1540_Type;
 109 staticforward PyTypeObject srvsvc_NetSrvInfo1541_Type;
 110 staticforward PyTypeObject srvsvc_NetSrvInfo1542_Type;
 111 staticforward PyTypeObject srvsvc_NetSrvInfo1543_Type;
 112 staticforward PyTypeObject srvsvc_NetSrvInfo1544_Type;
 113 staticforward PyTypeObject srvsvc_NetSrvInfo1545_Type;
 114 staticforward PyTypeObject srvsvc_NetSrvInfo1546_Type;
 115 staticforward PyTypeObject srvsvc_NetSrvInfo1547_Type;
 116 staticforward PyTypeObject srvsvc_NetSrvInfo1548_Type;
 117 staticforward PyTypeObject srvsvc_NetSrvInfo1549_Type;
 118 staticforward PyTypeObject srvsvc_NetSrvInfo1550_Type;
 119 staticforward PyTypeObject srvsvc_NetSrvInfo1552_Type;
 120 staticforward PyTypeObject srvsvc_NetSrvInfo1553_Type;
 121 staticforward PyTypeObject srvsvc_NetSrvInfo1554_Type;
 122 staticforward PyTypeObject srvsvc_NetSrvInfo1555_Type;
 123 staticforward PyTypeObject srvsvc_NetSrvInfo1556_Type;
 124 staticforward PyTypeObject srvsvc_NetDiskInfo0_Type;
 125 staticforward PyTypeObject srvsvc_NetDiskInfo_Type;
 126 staticforward PyTypeObject srvsvc_Statistics_Type;
 127 staticforward PyTypeObject srvsvc_NetTransportInfo0_Type;
 128 staticforward PyTypeObject srvsvc_NetTransportCtr0_Type;
 129 staticforward PyTypeObject srvsvc_NetTransportInfo1_Type;
 130 staticforward PyTypeObject srvsvc_NetTransportCtr1_Type;
 131 staticforward PyTypeObject srvsvc_NetTransportInfo2_Type;
 132 staticforward PyTypeObject srvsvc_NetTransportCtr2_Type;
 133 staticforward PyTypeObject srvsvc_NetTransportInfo3_Type;
 134 staticforward PyTypeObject srvsvc_NetTransportCtr3_Type;
 135 staticforward PyTypeObject srvsvc_NetTransportInfoCtr_Type;
 136 staticforward PyTypeObject srvsvc_NetRemoteTODInfo_Type;
 137 staticforward PyTypeObject srvsvc_InterfaceType;
 138
 139 void initsrvsvc(void);static PyTypeObject *Object_Type;
 140 static PyTypeObject *sec_desc_buf_Type;
 141 static PyTypeObject *policy_handle_Type;
 142 static PyTypeObject *ClientConnection_Type;
 143 static PyTypeObject *ndr_syntax_id_Type;
 144
 145 static PyObject *py_srvsvc_NetCharDevInfo0_get_device(PyObject *obj, void *closure)
 146 {
 147         struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(obj);
 148         PyObject *py_device;
 149         if (object->device == NULL) {
 150                 py_device = Py_None;
 151                 Py_INCREF(py_device);
 152         } else {
 153                 if (object->device == NULL) {
 154                         py_device = Py_None;
 155                         Py_INCREF(py_device);
 156                 } else {
 157                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 158                 }
 159         }
 160         return py_device;
 161 }
 162
 163 static int py_srvsvc_NetCharDevInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
 164 {
 165         struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(py_obj);
 166         if (value == Py_None) {
 167                 object->device = NULL;
 168         } else {
 169                 object->device = NULL;
 170                 if (PyUnicode_Check(value)) {
 171                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 172                 } else if (PyString_Check(value)) {
 173                         object->device = PyString_AS_STRING(value);
 174                 } else {
 175                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 176                         return -1;
 177                 }
 178         }
 179         return 0;
 180 }
 181
 182 static PyGetSetDef py_srvsvc_NetCharDevInfo0_getsetters[] = {
 183         { discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo0_get_device, py_srvsvc_NetCharDevInfo0_set_device },
 184         { NULL }
 185 };
 186
 187 static PyObject *py_srvsvc_NetCharDevInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 188 {
 189         return pytalloc_new(struct srvsvc_NetCharDevInfo0, type);
 190 }
 191
 192
 193 static PyTypeObject srvsvc_NetCharDevInfo0_Type = {
 194         PyObject_HEAD_INIT(NULL) 0,
 195         .tp_name = "srvsvc.NetCharDevInfo0",
 196         .tp_getset = py_srvsvc_NetCharDevInfo0_getsetters,
 197         .tp_methods = NULL,
 198         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 199         .tp_basicsize = sizeof(pytalloc_Object),
 200         .tp_new = py_srvsvc_NetCharDevInfo0_new,
 201 };
 202
 203
 204 static PyObject *py_srvsvc_NetCharDevCtr0_get_count(PyObject *obj, void *closure)
 205 {
 206         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
 207         PyObject *py_count;
 208         py_count = PyInt_FromLong(object->count);
 209         return py_count;
 210 }
 211
 212 static int py_srvsvc_NetCharDevCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
 213 {
 214         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(py_obj);
 215         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 216         object->count = PyInt_AsLong(value);
 217         return 0;
 218 }
 219
 220 static PyObject *py_srvsvc_NetCharDevCtr0_get_array(PyObject *obj, void *closure)
 221 {
 222         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
 223         PyObject *py_array;
 224         if (object->array == NULL) {
 225                 py_array = Py_None;
 226                 Py_INCREF(py_array);
 227         } else {
 228                 py_array = PyList_New(object->count);
 229                 if (py_array == NULL) {
 230                         return NULL;
 231                 }
 232                 {
 233                         int array_cntr_1;
 234                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 235                                 PyObject *py_array_1;
 236                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo0_Type, object->array, &object->array[array_cntr_1]);
 237                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 238                         }
 239                 }
 240         }
 241         return py_array;
 242 }
 243
 244 static int py_srvsvc_NetCharDevCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
 245 {
 246         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(py_obj);
 247         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 248         if (value == Py_None) {
 249                 object->array = NULL;
 250         } else {
 251                 object->array = NULL;
 252                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 253                 {
 254                         int array_cntr_1;
 255                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 256                         if (!object->array) { return -1;; }
 257                         talloc_set_name_const(object->array, "ARRAY: object->array");
 258                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 259                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 260                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 261                                         PyErr_NoMemory();
 262                                         return -1;
 263                                 }
 264                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 265                         }
 266                 }
 267         }
 268         return 0;
 269 }
 270
 271 static PyGetSetDef py_srvsvc_NetCharDevCtr0_getsetters[] = {
 272         { discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr0_get_count, py_srvsvc_NetCharDevCtr0_set_count },
 273         { discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr0_get_array, py_srvsvc_NetCharDevCtr0_set_array },
 274         { NULL }
 275 };
 276
 277 static PyObject *py_srvsvc_NetCharDevCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 278 {
 279         return pytalloc_new(struct srvsvc_NetCharDevCtr0, type);
 280 }
 281
 282
 283 static PyTypeObject srvsvc_NetCharDevCtr0_Type = {
 284         PyObject_HEAD_INIT(NULL) 0,
 285         .tp_name = "srvsvc.NetCharDevCtr0",
 286         .tp_getset = py_srvsvc_NetCharDevCtr0_getsetters,
 287         .tp_methods = NULL,
 288         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 289         .tp_basicsize = sizeof(pytalloc_Object),
 290         .tp_new = py_srvsvc_NetCharDevCtr0_new,
 291 };
 292
 293
 294 static PyObject *py_srvsvc_NetCharDevInfo1_get_device(PyObject *obj, void *closure)
 295 {
 296         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 297         PyObject *py_device;
 298         if (object->device == NULL) {
 299                 py_device = Py_None;
 300                 Py_INCREF(py_device);
 301         } else {
 302                 if (object->device == NULL) {
 303                         py_device = Py_None;
 304                         Py_INCREF(py_device);
 305                 } else {
 306                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 307                 }
 308         }
 309         return py_device;
 310 }
 311
 312 static int py_srvsvc_NetCharDevInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
 313 {
 314         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 315         if (value == Py_None) {
 316                 object->device = NULL;
 317         } else {
 318                 object->device = NULL;
 319                 if (PyUnicode_Check(value)) {
 320                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 321                 } else if (PyString_Check(value)) {
 322                         object->device = PyString_AS_STRING(value);
 323                 } else {
 324                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 325                         return -1;
 326                 }
 327         }
 328         return 0;
 329 }
 330
 331 static PyObject *py_srvsvc_NetCharDevInfo1_get_status(PyObject *obj, void *closure)
 332 {
 333         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 334         PyObject *py_status;
 335         py_status = PyInt_FromLong(object->status);
 336         return py_status;
 337 }
 338
 339 static int py_srvsvc_NetCharDevInfo1_set_status(PyObject *py_obj, PyObject *value, void *closure)
 340 {
 341         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 342         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 343         object->status = PyInt_AsLong(value);
 344         return 0;
 345 }
 346
 347 static PyObject *py_srvsvc_NetCharDevInfo1_get_user(PyObject *obj, void *closure)
 348 {
 349         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 350         PyObject *py_user;
 351         if (object->user == NULL) {
 352                 py_user = Py_None;
 353                 Py_INCREF(py_user);
 354         } else {
 355                 if (object->user == NULL) {
 356                         py_user = Py_None;
 357                         Py_INCREF(py_user);
 358                 } else {
 359                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
 360                 }
 361         }
 362         return py_user;
 363 }
 364
 365 static int py_srvsvc_NetCharDevInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
 366 {
 367         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 368         if (value == Py_None) {
 369                 object->user = NULL;
 370         } else {
 371                 object->user = NULL;
 372                 if (PyUnicode_Check(value)) {
 373                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 374                 } else if (PyString_Check(value)) {
 375                         object->user = PyString_AS_STRING(value);
 376                 } else {
 377                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 378                         return -1;
 379                 }
 380         }
 381         return 0;
 382 }
 383
 384 static PyObject *py_srvsvc_NetCharDevInfo1_get_time(PyObject *obj, void *closure)
 385 {
 386         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 387         PyObject *py_time;
 388         py_time = PyInt_FromLong(object->time);
 389         return py_time;
 390 }
 391
 392 static int py_srvsvc_NetCharDevInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
 393 {
 394         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 395         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 396         object->time = PyInt_AsLong(value);
 397         return 0;
 398 }
 399
 400 static PyGetSetDef py_srvsvc_NetCharDevInfo1_getsetters[] = {
 401         { discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo1_get_device, py_srvsvc_NetCharDevInfo1_set_device },
 402         { discard_const_p(char, "status"), py_srvsvc_NetCharDevInfo1_get_status, py_srvsvc_NetCharDevInfo1_set_status },
 403         { discard_const_p(char, "user"), py_srvsvc_NetCharDevInfo1_get_user, py_srvsvc_NetCharDevInfo1_set_user },
 404         { discard_const_p(char, "time"), py_srvsvc_NetCharDevInfo1_get_time, py_srvsvc_NetCharDevInfo1_set_time },
 405         { NULL }
 406 };
 407
 408 static PyObject *py_srvsvc_NetCharDevInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 409 {
 410         return pytalloc_new(struct srvsvc_NetCharDevInfo1, type);
 411 }
 412
 413
 414 static PyTypeObject srvsvc_NetCharDevInfo1_Type = {
 415         PyObject_HEAD_INIT(NULL) 0,
 416         .tp_name = "srvsvc.NetCharDevInfo1",
 417         .tp_getset = py_srvsvc_NetCharDevInfo1_getsetters,
 418         .tp_methods = NULL,
 419         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 420         .tp_basicsize = sizeof(pytalloc_Object),
 421         .tp_new = py_srvsvc_NetCharDevInfo1_new,
 422 };
 423
 424
 425 static PyObject *py_srvsvc_NetCharDevCtr1_get_count(PyObject *obj, void *closure)
 426 {
 427         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
 428         PyObject *py_count;
 429         py_count = PyInt_FromLong(object->count);
 430         return py_count;
 431 }
 432
 433 static int py_srvsvc_NetCharDevCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
 434 {
 435         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(py_obj);
 436         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 437         object->count = PyInt_AsLong(value);
 438         return 0;
 439 }
 440
 441 static PyObject *py_srvsvc_NetCharDevCtr1_get_array(PyObject *obj, void *closure)
 442 {
 443         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
 444         PyObject *py_array;
 445         if (object->array == NULL) {
 446                 py_array = Py_None;
 447                 Py_INCREF(py_array);
 448         } else {
 449                 py_array = PyList_New(object->count);
 450                 if (py_array == NULL) {
 451                         return NULL;
 452                 }
 453                 {
 454                         int array_cntr_1;
 455                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 456                                 PyObject *py_array_1;
 457                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo1_Type, object->array, &object->array[array_cntr_1]);
 458                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 459                         }
 460                 }
 461         }
 462         return py_array;
 463 }
 464
 465 static int py_srvsvc_NetCharDevCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
 466 {
 467         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(py_obj);
 468         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 469         if (value == Py_None) {
 470                 object->array = NULL;
 471         } else {
 472                 object->array = NULL;
 473                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 474                 {
 475                         int array_cntr_1;
 476                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 477                         if (!object->array) { return -1;; }
 478                         talloc_set_name_const(object->array, "ARRAY: object->array");
 479                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 480                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 481                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 482                                         PyErr_NoMemory();
 483                                         return -1;
 484                                 }
 485                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 486                         }
 487                 }
 488         }
 489         return 0;
 490 }
 491
 492 static PyGetSetDef py_srvsvc_NetCharDevCtr1_getsetters[] = {
 493         { discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr1_get_count, py_srvsvc_NetCharDevCtr1_set_count },
 494         { discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr1_get_array, py_srvsvc_NetCharDevCtr1_set_array },
 495         { NULL }
 496 };
 497
 498 static PyObject *py_srvsvc_NetCharDevCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 499 {
 500         return pytalloc_new(struct srvsvc_NetCharDevCtr1, type);
 501 }
 502
 503
 504 static PyTypeObject srvsvc_NetCharDevCtr1_Type = {
 505         PyObject_HEAD_INIT(NULL) 0,
 506         .tp_name = "srvsvc.NetCharDevCtr1",
 507         .tp_getset = py_srvsvc_NetCharDevCtr1_getsetters,
 508         .tp_methods = NULL,
 509         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 510         .tp_basicsize = sizeof(pytalloc_Object),
 511         .tp_new = py_srvsvc_NetCharDevCtr1_new,
 512 };
 513
 514 static PyObject *py_import_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevInfo *in)
 515 {
 516         PyObject *ret;
 517
 518         switch (level) {
 519                 case 0:
 520                         if (in->info0 == NULL) {
 521                                 ret = Py_None;
 522                                 Py_INCREF(ret);
 523                         } else {
 524                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevInfo0_Type, in->info0, in->info0);
 525                         }
 526                         return ret;
 527
 528                 case 1:
 529                         if (in->info1 == NULL) {
 530                                 ret = Py_None;
 531                                 Py_INCREF(ret);
 532                         } else {
 533                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevInfo1_Type, in->info1, in->info1);
 534                         }
 535                         return ret;
 536
 537                 default:
 538                         ret = Py_None;
 539                         Py_INCREF(ret);
 540                         return ret;
 541
 542         }
 543         PyErr_SetString(PyExc_TypeError, "unknown union level");
 544         return NULL;
 545 }
 546
 547 static union srvsvc_NetCharDevInfo *py_export_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 548 {
 549         union srvsvc_NetCharDevInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevInfo);
 550         switch (level) {
 551                 case 0:
 552                         if (in == Py_None) {
 553                                 ret->info0 = NULL;
 554                         } else {
 555                                 ret->info0 = NULL;
 556                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, in, talloc_free(ret); return NULL;);
 557                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 558                                         PyErr_NoMemory();
 559                                         talloc_free(ret); return NULL;
 560                                 }
 561                                 ret->info0 = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(in);
 562                         }
 563                         break;
 564
 565                 case 1:
 566                         if (in == Py_None) {
 567                                 ret->info1 = NULL;
 568                         } else {
 569                                 ret->info1 = NULL;
 570                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, in, talloc_free(ret); return NULL;);
 571                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 572                                         PyErr_NoMemory();
 573                                         talloc_free(ret); return NULL;
 574                                 }
 575                                 ret->info1 = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(in);
 576                         }
 577                         break;
 578
 579                 default:
 580                         break;
 581
 582         }
 583
 584         return ret;
 585 }
 586
 587 static PyObject *py_import_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevCtr *in)
 588 {
 589         PyObject *ret;
 590
 591         switch (level) {
 592                 case 0:
 593                         if (in->ctr0 == NULL) {
 594                                 ret = Py_None;
 595                                 Py_INCREF(ret);
 596                         } else {
 597                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr0_Type, in->ctr0, in->ctr0);
 598                         }
 599                         return ret;
 600
 601                 case 1:
 602                         if (in->ctr1 == NULL) {
 603                                 ret = Py_None;
 604                                 Py_INCREF(ret);
 605                         } else {
 606                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr1_Type, in->ctr1, in->ctr1);
 607                         }
 608                         return ret;
 609
 610                 default:
 611                         ret = Py_None;
 612                         Py_INCREF(ret);
 613                         return ret;
 614
 615         }
 616         PyErr_SetString(PyExc_TypeError, "unknown union level");
 617         return NULL;
 618 }
 619
 620 static union srvsvc_NetCharDevCtr *py_export_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 621 {
 622         union srvsvc_NetCharDevCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevCtr);
 623         switch (level) {
 624                 case 0:
 625                         if (in == Py_None) {
 626                                 ret->ctr0 = NULL;
 627                         } else {
 628                                 ret->ctr0 = NULL;
 629                                 PY_CHECK_TYPE(&srvsvc_NetCharDevCtr0_Type, in, talloc_free(ret); return NULL;);
 630                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 631                                         PyErr_NoMemory();
 632                                         talloc_free(ret); return NULL;
 633                                 }
 634                                 ret->ctr0 = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(in);
 635                         }
 636                         break;
 637
 638                 case 1:
 639                         if (in == Py_None) {
 640                                 ret->ctr1 = NULL;
 641                         } else {
 642                                 ret->ctr1 = NULL;
 643                                 PY_CHECK_TYPE(&srvsvc_NetCharDevCtr1_Type, in, talloc_free(ret); return NULL;);
 644                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 645                                         PyErr_NoMemory();
 646                                         talloc_free(ret); return NULL;
 647                                 }
 648                                 ret->ctr1 = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(in);
 649                         }
 650                         break;
 651
 652                 default:
 653                         break;
 654
 655         }
 656
 657         return ret;
 658 }
 659
 660
 661 static PyObject *py_srvsvc_NetCharDevInfoCtr_get_level(PyObject *obj, void *closure)
 662 {
 663         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
 664         PyObject *py_level;
 665         py_level = PyInt_FromLong(object->level);
 666         return py_level;
 667 }
 668
 669 static int py_srvsvc_NetCharDevInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
 670 {
 671         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_obj);
 672         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 673         object->level = PyInt_AsLong(value);
 674         return 0;
 675 }
 676
 677 static PyObject *py_srvsvc_NetCharDevInfoCtr_get_ctr(PyObject *obj, void *closure)
 678 {
 679         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
 680         PyObject *py_ctr;
 681         py_ctr = py_import_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
 682         if (py_ctr == NULL) {
 683                 return NULL;
 684         }
 685         return py_ctr;
 686 }
 687
 688 static int py_srvsvc_NetCharDevInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
 689 {
 690         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_obj);
 691         {
 692                 union srvsvc_NetCharDevCtr *ctr_switch_0;
 693                 ctr_switch_0 = py_export_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
 694                 if (ctr_switch_0 == NULL) {
 695                         return -1;
 696                 }
 697                 object->ctr = *ctr_switch_0;
 698         }
 699         return 0;
 700 }
 701
 702 static PyGetSetDef py_srvsvc_NetCharDevInfoCtr_getsetters[] = {
 703         { discard_const_p(char, "level"), py_srvsvc_NetCharDevInfoCtr_get_level, py_srvsvc_NetCharDevInfoCtr_set_level },
 704         { discard_const_p(char, "ctr"), py_srvsvc_NetCharDevInfoCtr_get_ctr, py_srvsvc_NetCharDevInfoCtr_set_ctr },
 705         { NULL }
 706 };
 707
 708 static PyObject *py_srvsvc_NetCharDevInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 709 {
 710         return pytalloc_new(struct srvsvc_NetCharDevInfoCtr, type);
 711 }
 712
 713
 714 static PyTypeObject srvsvc_NetCharDevInfoCtr_Type = {
 715         PyObject_HEAD_INIT(NULL) 0,
 716         .tp_name = "srvsvc.NetCharDevInfoCtr",
 717         .tp_getset = py_srvsvc_NetCharDevInfoCtr_getsetters,
 718         .tp_methods = NULL,
 719         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 720         .tp_basicsize = sizeof(pytalloc_Object),
 721         .tp_new = py_srvsvc_NetCharDevInfoCtr_new,
 722 };
 723
 724
 725 static PyObject *py_srvsvc_NetCharDevQInfo0_get_device(PyObject *obj, void *closure)
 726 {
 727         struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(obj);
 728         PyObject *py_device;
 729         if (object->device == NULL) {
 730                 py_device = Py_None;
 731                 Py_INCREF(py_device);
 732         } else {
 733                 if (object->device == NULL) {
 734                         py_device = Py_None;
 735                         Py_INCREF(py_device);
 736                 } else {
 737                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 738                 }
 739         }
 740         return py_device;
 741 }
 742
 743 static int py_srvsvc_NetCharDevQInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
 744 {
 745         struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(py_obj);
 746         if (value == Py_None) {
 747                 object->device = NULL;
 748         } else {
 749                 object->device = NULL;
 750                 if (PyUnicode_Check(value)) {
 751                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 752                 } else if (PyString_Check(value)) {
 753                         object->device = PyString_AS_STRING(value);
 754                 } else {
 755                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 756                         return -1;
 757                 }
 758         }
 759         return 0;
 760 }
 761
 762 static PyGetSetDef py_srvsvc_NetCharDevQInfo0_getsetters[] = {
 763         { discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo0_get_device, py_srvsvc_NetCharDevQInfo0_set_device },
 764         { NULL }
 765 };
 766
 767 static PyObject *py_srvsvc_NetCharDevQInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 768 {
 769         return pytalloc_new(struct srvsvc_NetCharDevQInfo0, type);
 770 }
 771
 772
 773 static PyTypeObject srvsvc_NetCharDevQInfo0_Type = {
 774         PyObject_HEAD_INIT(NULL) 0,
 775         .tp_name = "srvsvc.NetCharDevQInfo0",
 776         .tp_getset = py_srvsvc_NetCharDevQInfo0_getsetters,
 777         .tp_methods = NULL,
 778         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 779         .tp_basicsize = sizeof(pytalloc_Object),
 780         .tp_new = py_srvsvc_NetCharDevQInfo0_new,
 781 };
 782
 783
 784 static PyObject *py_srvsvc_NetCharDevQCtr0_get_count(PyObject *obj, void *closure)
 785 {
 786         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
 787         PyObject *py_count;
 788         py_count = PyInt_FromLong(object->count);
 789         return py_count;
 790 }
 791
 792 static int py_srvsvc_NetCharDevQCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
 793 {
 794         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(py_obj);
 795         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 796         object->count = PyInt_AsLong(value);
 797         return 0;
 798 }
 799
 800 static PyObject *py_srvsvc_NetCharDevQCtr0_get_array(PyObject *obj, void *closure)
 801 {
 802         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
 803         PyObject *py_array;
 804         if (object->array == NULL) {
 805                 py_array = Py_None;
 806                 Py_INCREF(py_array);
 807         } else {
 808                 py_array = PyList_New(object->count);
 809                 if (py_array == NULL) {
 810                         return NULL;
 811                 }
 812                 {
 813                         int array_cntr_1;
 814                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 815                                 PyObject *py_array_1;
 816                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo0_Type, object->array, &object->array[array_cntr_1]);
 817                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 818                         }
 819                 }
 820         }
 821         return py_array;
 822 }
 823
 824 static int py_srvsvc_NetCharDevQCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
 825 {
 826         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(py_obj);
 827         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 828         if (value == Py_None) {
 829                 object->array = NULL;
 830         } else {
 831                 object->array = NULL;
 832                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 833                 {
 834                         int array_cntr_1;
 835                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 836                         if (!object->array) { return -1;; }
 837                         talloc_set_name_const(object->array, "ARRAY: object->array");
 838                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 839                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 840                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 841                                         PyErr_NoMemory();
 842                                         return -1;
 843                                 }
 844                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 845                         }
 846                 }
 847         }
 848         return 0;
 849 }
 850
 851 static PyGetSetDef py_srvsvc_NetCharDevQCtr0_getsetters[] = {
 852         { discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr0_get_count, py_srvsvc_NetCharDevQCtr0_set_count },
 853         { discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr0_get_array, py_srvsvc_NetCharDevQCtr0_set_array },
 854         { NULL }
 855 };
 856
 857 static PyObject *py_srvsvc_NetCharDevQCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 858 {
 859         return pytalloc_new(struct srvsvc_NetCharDevQCtr0, type);
 860 }
 861
 862
 863 static PyTypeObject srvsvc_NetCharDevQCtr0_Type = {
 864         PyObject_HEAD_INIT(NULL) 0,
 865         .tp_name = "srvsvc.NetCharDevQCtr0",
 866         .tp_getset = py_srvsvc_NetCharDevQCtr0_getsetters,
 867         .tp_methods = NULL,
 868         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 869         .tp_basicsize = sizeof(pytalloc_Object),
 870         .tp_new = py_srvsvc_NetCharDevQCtr0_new,
 871 };
 872
 873
 874 static PyObject *py_srvsvc_NetCharDevQInfo1_get_device(PyObject *obj, void *closure)
 875 {
 876         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 877         PyObject *py_device;
 878         if (object->device == NULL) {
 879                 py_device = Py_None;
 880                 Py_INCREF(py_device);
 881         } else {
 882                 if (object->device == NULL) {
 883                         py_device = Py_None;
 884                         Py_INCREF(py_device);
 885                 } else {
 886                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 887                 }
 888         }
 889         return py_device;
 890 }
 891
 892 static int py_srvsvc_NetCharDevQInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
 893 {
 894         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 895         if (value == Py_None) {
 896                 object->device = NULL;
 897         } else {
 898                 object->device = NULL;
 899                 if (PyUnicode_Check(value)) {
 900                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 901                 } else if (PyString_Check(value)) {
 902                         object->device = PyString_AS_STRING(value);
 903                 } else {
 904                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 905                         return -1;
 906                 }
 907         }
 908         return 0;
 909 }
 910
 911 static PyObject *py_srvsvc_NetCharDevQInfo1_get_priority(PyObject *obj, void *closure)
 912 {
 913         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 914         PyObject *py_priority;
 915         py_priority = PyInt_FromLong(object->priority);
 916         return py_priority;
 917 }
 918
 919 static int py_srvsvc_NetCharDevQInfo1_set_priority(PyObject *py_obj, PyObject *value, void *closure)
 920 {
 921         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 922         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 923         object->priority = PyInt_AsLong(value);
 924         return 0;
 925 }
 926
 927 static PyObject *py_srvsvc_NetCharDevQInfo1_get_devices(PyObject *obj, void *closure)
 928 {
 929         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 930         PyObject *py_devices;
 931         if (object->devices == NULL) {
 932                 py_devices = Py_None;
 933                 Py_INCREF(py_devices);
 934         } else {
 935                 if (object->devices == NULL) {
 936                         py_devices = Py_None;
 937                         Py_INCREF(py_devices);
 938                 } else {
 939                         py_devices = PyUnicode_Decode(object->devices, strlen(object->devices), "utf-8", "ignore");
 940                 }
 941         }
 942         return py_devices;
 943 }
 944
 945 static int py_srvsvc_NetCharDevQInfo1_set_devices(PyObject *py_obj, PyObject *value, void *closure)
 946 {
 947         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 948         if (value == Py_None) {
 949                 object->devices = NULL;
 950         } else {
 951                 object->devices = NULL;
 952                 if (PyUnicode_Check(value)) {
 953                         object->devices = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 954                 } else if (PyString_Check(value)) {
 955                         object->devices = PyString_AS_STRING(value);
 956                 } else {
 957                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 958                         return -1;
 959                 }
 960         }
 961         return 0;
 962 }
 963
 964 static PyObject *py_srvsvc_NetCharDevQInfo1_get_users(PyObject *obj, void *closure)
 965 {
 966         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 967         PyObject *py_users;
 968         py_users = PyInt_FromLong(object->users);
 969         return py_users;
 970 }
 971
 972 static int py_srvsvc_NetCharDevQInfo1_set_users(PyObject *py_obj, PyObject *value, void *closure)
 973 {
 974         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 975         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 976         object->users = PyInt_AsLong(value);
 977         return 0;
 978 }
 979
 980 static PyObject *py_srvsvc_NetCharDevQInfo1_get_num_ahead(PyObject *obj, void *closure)
 981 {
 982         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 983         PyObject *py_num_ahead;
 984         py_num_ahead = PyInt_FromLong(object->num_ahead);
 985         return py_num_ahead;
 986 }
 987
 988 static int py_srvsvc_NetCharDevQInfo1_set_num_ahead(PyObject *py_obj, PyObject *value, void *closure)
 989 {
 990         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 991         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 992         object->num_ahead = PyInt_AsLong(value);
 993         return 0;
 994 }
 995
 996 static PyGetSetDef py_srvsvc_NetCharDevQInfo1_getsetters[] = {
 997         { discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo1_get_device, py_srvsvc_NetCharDevQInfo1_set_device },
 998         { discard_const_p(char, "priority"), py_srvsvc_NetCharDevQInfo1_get_priority, py_srvsvc_NetCharDevQInfo1_set_priority },
 999         { discard_const_p(char, "devices"), py_srvsvc_NetCharDevQInfo1_get_devices, py_srvsvc_NetCharDevQInfo1_set_devices },
1000         { discard_const_p(char, "users"), py_srvsvc_NetCharDevQInfo1_get_users, py_srvsvc_NetCharDevQInfo1_set_users },
1001         { discard_const_p(char, "num_ahead"), py_srvsvc_NetCharDevQInfo1_get_num_ahead, py_srvsvc_NetCharDevQInfo1_set_num_ahead },
1002         { NULL }
1003 };
1004
1005 static PyObject *py_srvsvc_NetCharDevQInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1006 {
1007         return pytalloc_new(struct srvsvc_NetCharDevQInfo1, type);
1008 }
1009
1010
1011 static PyTypeObject srvsvc_NetCharDevQInfo1_Type = {
1012         PyObject_HEAD_INIT(NULL) 0,
1013         .tp_name = "srvsvc.NetCharDevQInfo1",
1014         .tp_getset = py_srvsvc_NetCharDevQInfo1_getsetters,
1015         .tp_methods = NULL,
1016         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1017         .tp_basicsize = sizeof(pytalloc_Object),
1018         .tp_new = py_srvsvc_NetCharDevQInfo1_new,
1019 };
1020
1021
1022 static PyObject *py_srvsvc_NetCharDevQCtr1_get_count(PyObject *obj, void *closure)
1023 {
1024         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
1025         PyObject *py_count;
1026         py_count = PyInt_FromLong(object->count);
1027         return py_count;
1028 }
1029
1030 static int py_srvsvc_NetCharDevQCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
1031 {
1032         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(py_obj);
1033         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1034         object->count = PyInt_AsLong(value);
1035         return 0;
1036 }
1037
1038 static PyObject *py_srvsvc_NetCharDevQCtr1_get_array(PyObject *obj, void *closure)
1039 {
1040         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
1041         PyObject *py_array;
1042         if (object->array == NULL) {
1043                 py_array = Py_None;
1044                 Py_INCREF(py_array);
1045         } else {
1046                 py_array = PyList_New(object->count);
1047                 if (py_array == NULL) {
1048                         return NULL;
1049                 }
1050                 {
1051                         int array_cntr_1;
1052                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1053                                 PyObject *py_array_1;
1054                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo1_Type, object->array, &object->array[array_cntr_1]);
1055                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1056                         }
1057                 }
1058         }
1059         return py_array;
1060 }
1061
1062 static int py_srvsvc_NetCharDevQCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
1063 {
1064         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(py_obj);
1065         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1066         if (value == Py_None) {
1067                 object->array = NULL;
1068         } else {
1069                 object->array = NULL;
1070                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1071                 {
1072                         int array_cntr_1;
1073                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1074                         if (!object->array) { return -1;; }
1075                         talloc_set_name_const(object->array, "ARRAY: object->array");
1076                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1077                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1078                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1079                                         PyErr_NoMemory();
1080                                         return -1;
1081                                 }
1082                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1083                         }
1084                 }
1085         }
1086         return 0;
1087 }
1088
1089 static PyGetSetDef py_srvsvc_NetCharDevQCtr1_getsetters[] = {
1090         { discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr1_get_count, py_srvsvc_NetCharDevQCtr1_set_count },
1091         { discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr1_get_array, py_srvsvc_NetCharDevQCtr1_set_array },
1092         { NULL }
1093 };
1094
1095 static PyObject *py_srvsvc_NetCharDevQCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1096 {
1097         return pytalloc_new(struct srvsvc_NetCharDevQCtr1, type);
1098 }
1099
1100
1101 static PyTypeObject srvsvc_NetCharDevQCtr1_Type = {
1102         PyObject_HEAD_INIT(NULL) 0,
1103         .tp_name = "srvsvc.NetCharDevQCtr1",
1104         .tp_getset = py_srvsvc_NetCharDevQCtr1_getsetters,
1105         .tp_methods = NULL,
1106         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1107         .tp_basicsize = sizeof(pytalloc_Object),
1108         .tp_new = py_srvsvc_NetCharDevQCtr1_new,
1109 };
1110
1111 static PyObject *py_import_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQInfo *in)
1112 {
1113         PyObject *ret;
1114
1115         switch (level) {
1116                 case 0:
1117                         if (in->info0 == NULL) {
1118                                 ret = Py_None;
1119                                 Py_INCREF(ret);
1120                         } else {
1121                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo0_Type, in->info0, in->info0);
1122                         }
1123                         return ret;
1124
1125                 case 1:
1126                         if (in->info1 == NULL) {
1127                                 ret = Py_None;
1128                                 Py_INCREF(ret);
1129                         } else {
1130                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo1_Type, in->info1, in->info1);
1131                         }
1132                         return ret;
1133
1134                 default:
1135                         ret = Py_None;
1136                         Py_INCREF(ret);
1137                         return ret;
1138
1139         }
1140         PyErr_SetString(PyExc_TypeError, "unknown union level");
1141         return NULL;
1142 }
1143
1144 static union srvsvc_NetCharDevQInfo *py_export_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1145 {
1146         union srvsvc_NetCharDevQInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQInfo);
1147         switch (level) {
1148                 case 0:
1149                         if (in == Py_None) {
1150                                 ret->info0 = NULL;
1151                         } else {
1152                                 ret->info0 = NULL;
1153                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, in, talloc_free(ret); return NULL;);
1154                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1155                                         PyErr_NoMemory();
1156                                         talloc_free(ret); return NULL;
1157                                 }
1158                                 ret->info0 = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(in);
1159                         }
1160                         break;
1161
1162                 case 1:
1163                         if (in == Py_None) {
1164                                 ret->info1 = NULL;
1165                         } else {
1166                                 ret->info1 = NULL;
1167                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, in, talloc_free(ret); return NULL;);
1168                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1169                                         PyErr_NoMemory();
1170                                         talloc_free(ret); return NULL;
1171                                 }
1172                                 ret->info1 = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(in);
1173                         }
1174                         break;
1175
1176                 default:
1177                         break;
1178
1179         }
1180
1181         return ret;
1182 }
1183
1184 static PyObject *py_import_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQCtr *in)
1185 {
1186         PyObject *ret;
1187
1188         switch (level) {
1189                 case 0:
1190                         if (in->ctr0 == NULL) {
1191                                 ret = Py_None;
1192                                 Py_INCREF(ret);
1193                         } else {
1194                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr0_Type, in->ctr0, in->ctr0);
1195                         }
1196                         return ret;
1197
1198                 case 1:
1199                         if (in->ctr1 == NULL) {
1200                                 ret = Py_None;
1201                                 Py_INCREF(ret);
1202                         } else {
1203                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr1_Type, in->ctr1, in->ctr1);
1204                         }
1205                         return ret;
1206
1207                 default:
1208                         ret = Py_None;
1209                         Py_INCREF(ret);
1210                         return ret;
1211
1212         }
1213         PyErr_SetString(PyExc_TypeError, "unknown union level");
1214         return NULL;
1215 }
1216
1217 static union srvsvc_NetCharDevQCtr *py_export_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1218 {
1219         union srvsvc_NetCharDevQCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQCtr);
1220         switch (level) {
1221                 case 0:
1222                         if (in == Py_None) {
1223                                 ret->ctr0 = NULL;
1224                         } else {
1225                                 ret->ctr0 = NULL;
1226                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr0_Type, in, talloc_free(ret); return NULL;);
1227                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1228                                         PyErr_NoMemory();
1229                                         talloc_free(ret); return NULL;
1230                                 }
1231                                 ret->ctr0 = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(in);
1232                         }
1233                         break;
1234
1235                 case 1:
1236                         if (in == Py_None) {
1237                                 ret->ctr1 = NULL;
1238                         } else {
1239                                 ret->ctr1 = NULL;
1240                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr1_Type, in, talloc_free(ret); return NULL;);
1241                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1242                                         PyErr_NoMemory();
1243                                         talloc_free(ret); return NULL;
1244                                 }
1245                                 ret->ctr1 = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(in);
1246                         }
1247                         break;
1248
1249                 default:
1250                         break;
1251
1252         }
1253
1254         return ret;
1255 }
1256
1257
1258 static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_level(PyObject *obj, void *closure)
1259 {
1260         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
1261         PyObject *py_level;
1262         py_level = PyInt_FromLong(object->level);
1263         return py_level;
1264 }
1265
1266 static int py_srvsvc_NetCharDevQInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
1267 {
1268         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_obj);
1269         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1270         object->level = PyInt_AsLong(value);
1271         return 0;
1272 }
1273
1274 static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_ctr(PyObject *obj, void *closure)
1275 {
1276         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
1277         PyObject *py_ctr;
1278         py_ctr = py_import_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
1279         if (py_ctr == NULL) {
1280                 return NULL;
1281         }
1282         return py_ctr;
1283 }
1284
1285 static int py_srvsvc_NetCharDevQInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
1286 {
1287         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_obj);
1288         {
1289                 union srvsvc_NetCharDevQCtr *ctr_switch_0;
1290                 ctr_switch_0 = py_export_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
1291                 if (ctr_switch_0 == NULL) {
1292                         return -1;
1293                 }
1294                 object->ctr = *ctr_switch_0;
1295         }
1296         return 0;
1297 }
1298
1299 static PyGetSetDef py_srvsvc_NetCharDevQInfoCtr_getsetters[] = {
1300         { discard_const_p(char, "level"), py_srvsvc_NetCharDevQInfoCtr_get_level, py_srvsvc_NetCharDevQInfoCtr_set_level },
1301         { discard_const_p(char, "ctr"), py_srvsvc_NetCharDevQInfoCtr_get_ctr, py_srvsvc_NetCharDevQInfoCtr_set_ctr },
1302         { NULL }
1303 };
1304
1305 static PyObject *py_srvsvc_NetCharDevQInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1306 {
1307         return pytalloc_new(struct srvsvc_NetCharDevQInfoCtr, type);
1308 }
1309
1310
1311 static PyTypeObject srvsvc_NetCharDevQInfoCtr_Type = {
1312         PyObject_HEAD_INIT(NULL) 0,
1313         .tp_name = "srvsvc.NetCharDevQInfoCtr",
1314         .tp_getset = py_srvsvc_NetCharDevQInfoCtr_getsetters,
1315         .tp_methods = NULL,
1316         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1317         .tp_basicsize = sizeof(pytalloc_Object),
1318         .tp_new = py_srvsvc_NetCharDevQInfoCtr_new,
1319 };
1320
1321
1322 static PyObject *py_srvsvc_NetConnInfo0_get_conn_id(PyObject *obj, void *closure)
1323 {
1324         struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(obj);
1325         PyObject *py_conn_id;
1326         py_conn_id = PyInt_FromLong(object->conn_id);
1327         return py_conn_id;
1328 }
1329
1330 static int py_srvsvc_NetConnInfo0_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
1331 {
1332         struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(py_obj);
1333         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1334         object->conn_id = PyInt_AsLong(value);
1335         return 0;
1336 }
1337
1338 static PyGetSetDef py_srvsvc_NetConnInfo0_getsetters[] = {
1339         { discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo0_get_conn_id, py_srvsvc_NetConnInfo0_set_conn_id },
1340         { NULL }
1341 };
1342
1343 static PyObject *py_srvsvc_NetConnInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1344 {
1345         return pytalloc_new(struct srvsvc_NetConnInfo0, type);
1346 }
1347
1348
1349 static PyTypeObject srvsvc_NetConnInfo0_Type = {
1350         PyObject_HEAD_INIT(NULL) 0,
1351         .tp_name = "srvsvc.NetConnInfo0",
1352         .tp_getset = py_srvsvc_NetConnInfo0_getsetters,
1353         .tp_methods = NULL,
1354         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1355         .tp_basicsize = sizeof(pytalloc_Object),
1356         .tp_new = py_srvsvc_NetConnInfo0_new,
1357 };
1358
1359
1360 static PyObject *py_srvsvc_NetConnCtr0_get_count(PyObject *obj, void *closure)
1361 {
1362         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
1363         PyObject *py_count;
1364         py_count = PyInt_FromLong(object->count);
1365         return py_count;
1366 }
1367
1368 static int py_srvsvc_NetConnCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
1369 {
1370         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(py_obj);
1371         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1372         object->count = PyInt_AsLong(value);
1373         return 0;
1374 }
1375
1376 static PyObject *py_srvsvc_NetConnCtr0_get_array(PyObject *obj, void *closure)
1377 {
1378         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
1379         PyObject *py_array;
1380         if (object->array == NULL) {
1381                 py_array = Py_None;
1382                 Py_INCREF(py_array);
1383         } else {
1384                 py_array = PyList_New(object->count);
1385                 if (py_array == NULL) {
1386                         return NULL;
1387                 }
1388                 {
1389                         int array_cntr_1;
1390                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1391                                 PyObject *py_array_1;
1392                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo0_Type, object->array, &object->array[array_cntr_1]);
1393                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1394                         }
1395                 }
1396         }
1397         return py_array;
1398 }
1399
1400 static int py_srvsvc_NetConnCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
1401 {
1402         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(py_obj);
1403         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1404         if (value == Py_None) {
1405                 object->array = NULL;
1406         } else {
1407                 object->array = NULL;
1408                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1409                 {
1410                         int array_cntr_1;
1411                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1412                         if (!object->array) { return -1;; }
1413                         talloc_set_name_const(object->array, "ARRAY: object->array");
1414                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1415                                 PY_CHECK_TYPE(&srvsvc_NetConnInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1416                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1417                                         PyErr_NoMemory();
1418                                         return -1;
1419                                 }
1420                                 object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1421                         }
1422                 }
1423         }
1424         return 0;
1425 }
1426
1427 static PyGetSetDef py_srvsvc_NetConnCtr0_getsetters[] = {
1428         { discard_const_p(char, "count"), py_srvsvc_NetConnCtr0_get_count, py_srvsvc_NetConnCtr0_set_count },
1429         { discard_const_p(char, "array"), py_srvsvc_NetConnCtr0_get_array, py_srvsvc_NetConnCtr0_set_array },
1430         { NULL }
1431 };
1432
1433 static PyObject *py_srvsvc_NetConnCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1434 {
1435         return pytalloc_new(struct srvsvc_NetConnCtr0, type);
1436 }
1437
1438
1439 static PyTypeObject srvsvc_NetConnCtr0_Type = {
1440         PyObject_HEAD_INIT(NULL) 0,
1441         .tp_name = "srvsvc.NetConnCtr0",
1442         .tp_getset = py_srvsvc_NetConnCtr0_getsetters,
1443         .tp_methods = NULL,
1444         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1445         .tp_basicsize = sizeof(pytalloc_Object),
1446         .tp_new = py_srvsvc_NetConnCtr0_new,
1447 };
1448
1449
1450 static PyObject *py_srvsvc_NetConnInfo1_get_conn_id(PyObject *obj, void *closure)
1451 {
1452         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1453         PyObject *py_conn_id;
1454         py_conn_id = PyInt_FromLong(object->conn_id);
1455         return py_conn_id;
1456 }
1457
1458 static int py_srvsvc_NetConnInfo1_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
1459 {
1460         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1461         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1462         object->conn_id = PyInt_AsLong(value);
1463         return 0;
1464 }
1465
1466 static PyObject *py_srvsvc_NetConnInfo1_get_conn_type(PyObject *obj, void *closure)
1467 {
1468         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1469         PyObject *py_conn_type;
1470         py_conn_type = PyInt_FromLong(object->conn_type);
1471         return py_conn_type;
1472 }
1473
1474 static int py_srvsvc_NetConnInfo1_set_conn_type(PyObject *py_obj, PyObject *value, void *closure)
1475 {
1476         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1477         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1478         object->conn_type = PyInt_AsLong(value);
1479         return 0;
1480 }
1481
1482 static PyObject *py_srvsvc_NetConnInfo1_get_num_open(PyObject *obj, void *closure)
1483 {
1484         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1485         PyObject *py_num_open;
1486         py_num_open = PyInt_FromLong(object->num_open);
1487         return py_num_open;
1488 }
1489
1490 static int py_srvsvc_NetConnInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
1491 {
1492         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1493         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1494         object->num_open = PyInt_AsLong(value);
1495         return 0;
1496 }
1497
1498 static PyObject *py_srvsvc_NetConnInfo1_get_num_users(PyObject *obj, void *closure)
1499 {
1500         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1501         PyObject *py_num_users;
1502         py_num_users = PyInt_FromLong(object->num_users);
1503         return py_num_users;
1504 }
1505
1506 static int py_srvsvc_NetConnInfo1_set_num_users(PyObject *py_obj, PyObject *value, void *closure)
1507 {
1508         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1509         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1510         object->num_users = PyInt_AsLong(value);
1511         return 0;
1512 }
1513
1514 static PyObject *py_srvsvc_NetConnInfo1_get_conn_time(PyObject *obj, void *closure)
1515 {
1516         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1517         PyObject *py_conn_time;
1518         py_conn_time = PyInt_FromLong(object->conn_time);
1519         return py_conn_time;
1520 }
1521
1522 static int py_srvsvc_NetConnInfo1_set_conn_time(PyObject *py_obj, PyObject *value, void *closure)
1523 {
1524         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1525         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1526         object->conn_time = PyInt_AsLong(value);
1527         return 0;
1528 }
1529
1530 static PyObject *py_srvsvc_NetConnInfo1_get_user(PyObject *obj, void *closure)
1531 {
1532         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1533         PyObject *py_user;
1534         if (object->user == NULL) {
1535                 py_user = Py_None;
1536                 Py_INCREF(py_user);
1537         } else {
1538                 if (object->user == NULL) {
1539                         py_user = Py_None;
1540                         Py_INCREF(py_user);
1541                 } else {
1542                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
1543                 }
1544         }
1545         return py_user;
1546 }
1547
1548 static int py_srvsvc_NetConnInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
1549 {
1550         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1551         if (value == Py_None) {
1552                 object->user = NULL;
1553         } else {
1554                 object->user = NULL;
1555                 if (PyUnicode_Check(value)) {
1556                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
1557                 } else if (PyString_Check(value)) {
1558                         object->user = PyString_AS_STRING(value);
1559                 } else {
1560                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
1561                         return -1;
1562                 }
1563         }
1564         return 0;
1565 }
1566
1567 static PyObject *py_srvsvc_NetConnInfo1_get_share(PyObject *obj, void *closure)
1568 {
1569         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1570         PyObject *py_share;
1571         if (object->share == NULL) {
1572                 py_share = Py_None;
1573                 Py_INCREF(py_share);
1574         } else {
1575                 if (object->share == NULL) {
1576                         py_share = Py_None;
1577                         Py_INCREF(py_share);
1578                 } else {
1579                         py_share = PyUnicode_Decode(object->share, strlen(object->share), "utf-8", "ignore");
1580                 }
1581         }
1582         return py_share;
1583 }
1584
1585 static int py_srvsvc_NetConnInfo1_set_share(PyObject *py_obj, PyObject *value, void *closure)
1586 {
1587         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1588         if (value == Py_None) {
1589                 object->share = NULL;
1590         } else {
1591                 object->share = NULL;
1592                 if (PyUnicode_Check(value)) {
1593                         object->share = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
1594                 } else if (PyString_Check(value)) {
1595                         object->share = PyString_AS_STRING(value);
1596                 } else {
1597                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
1598                         return -1;
1599                 }
1600         }
1601         return 0;
1602 }
1603
1604 static PyGetSetDef py_srvsvc_NetConnInfo1_getsetters[] = {
1605         { discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo1_get_conn_id, py_srvsvc_NetConnInfo1_set_conn_id },
1606         { discard_const_p(char, "conn_type"), py_srvsvc_NetConnInfo1_get_conn_type, py_srvsvc_NetConnInfo1_set_conn_type },
1607         { discard_const_p(char, "num_open"), py_srvsvc_NetConnInfo1_get_num_open, py_srvsvc_NetConnInfo1_set_num_open },
1608         { discard_const_p(char, "num_users"), py_srvsvc_NetConnInfo1_get_num_users, py_srvsvc_NetConnInfo1_set_num_users },
1609         { discard_const_p(char, "conn_time"), py_srvsvc_NetConnInfo1_get_conn_time, py_srvsvc_NetConnInfo1_set_conn_time },
1610         { discard_const_p(char, "user"), py_srvsvc_NetConnInfo1_get_user, py_srvsvc_NetConnInfo1_set_user },
1611         { discard_const_p(char, "share"), py_srvsvc_NetConnInfo1_get_share, py_srvsvc_NetConnInfo1_set_share },
1612         { NULL }
1613 };
1614
1615 static PyObject *py_srvsvc_NetConnInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1616 {
1617         return pytalloc_new(struct srvsvc_NetConnInfo1, type);
1618 }
1619
1620
1621 static PyTypeObject srvsvc_NetConnInfo1_Type = {
1622         PyObject_HEAD_INIT(NULL) 0,
1623         .tp_name = "srvsvc.NetConnInfo1",
1624         .tp_getset = py_srvsvc_NetConnInfo1_getsetters,
1625         .tp_methods = NULL,
1626         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1627         .tp_basicsize = sizeof(pytalloc_Object),
1628         .tp_new = py_srvsvc_NetConnInfo1_new,
1629 };
1630
1631
1632 static PyObject *py_srvsvc_NetConnCtr1_get_count(PyObject *obj, void *closure)
1633 {
1634         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
1635         PyObject *py_count;
1636         py_count = PyInt_FromLong(object->count);
1637         return py_count;
1638 }
1639
1640 static int py_srvsvc_NetConnCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
1641 {
1642         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(py_obj);
1643         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1644         object->count = PyInt_AsLong(value);
1645         return 0;
1646 }
1647
1648 static PyObject *py_srvsvc_NetConnCtr1_get_array(PyObject *obj, void *closure)
1649 {
1650         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
1651         PyObject *py_array;
1652         if (object->array == NULL) {
1653                 py_array = Py_None;
1654                 Py_INCREF(py_array);
1655         } else {
1656                 py_array = PyList_New(object->count);
1657                 if (py_array == NULL) {
1658                         return NULL;
1659                 }
1660                 {
1661                         int array_cntr_1;
1662                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1663                                 PyObject *py_array_1;
1664                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo1_Type, object->array, &object->array[array_cntr_1]);
1665                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1666                         }
1667                 }
1668         }
1669         return py_array;
1670 }
1671
1672 static int py_srvsvc_NetConnCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
1673 {
1674         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(py_obj);
1675         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1676         if (value == Py_None) {
1677                 object->array = NULL;
1678         } else {
1679                 object->array = NULL;
1680                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1681                 {
1682                         int array_cntr_1;
1683                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1684                         if (!object->array) { return -1;; }
1685                         talloc_set_name_const(object->array, "ARRAY: object->array");
1686                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1687                                 PY_CHECK_TYPE(&srvsvc_NetConnInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1688                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1689                                         PyErr_NoMemory();
1690                                         return -1;
1691                                 }
1692                                 object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1693                         }
1694                 }
1695         }
1696         return 0;
1697 }
1698
1699 static PyGetSetDef py_srvsvc_NetConnCtr1_getsetters[] = {
1700         { discard_const_p(char, "count"), py_srvsvc_NetConnCtr1_get_count, py_srvsvc_NetConnCtr1_set_count },
1701         { discard_const_p(char, "array"), py_srvsvc_NetConnCtr1_get_array, py_srvsvc_NetConnCtr1_set_array },
1702         { NULL }
1703 };
1704
1705 static PyObject *py_srvsvc_NetConnCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1706 {
1707         return pytalloc_new(struct srvsvc_NetConnCtr1, type);
1708 }
1709
1710
1711 static PyTypeObject srvsvc_NetConnCtr1_Type = {
1712         PyObject_HEAD_INIT(NULL) 0,
1713         .tp_name = "srvsvc.NetConnCtr1",
1714         .tp_getset = py_srvsvc_NetConnCtr1_getsetters,
1715         .tp_methods = NULL,
1716         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1717         .tp_basicsize = sizeof(pytalloc_Object),
1718         .tp_new = py_srvsvc_NetConnCtr1_new,
1719 };
1720
1721 static PyObject *py_import_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetConnCtr *in)
1722 {
1723         PyObject *ret;
1724
1725         switch (level) {
1726                 case 0:
1727                         if (in->ctr0 == NULL) {
1728                                 ret = Py_None;
1729                                 Py_INCREF(ret);
1730                         } else {
1731                                 ret = pytalloc_reference_ex(&srvsvc_NetConnCtr0_Type, in->ctr0, in->ctr0);
1732                         }
1733                         return ret;
1734
1735                 case 1:
1736                         if (in->ctr1 == NULL) {
1737                                 ret = Py_None;
1738                                 Py_INCREF(ret);
1739                         } else {
1740                                 ret = pytalloc_reference_ex(&srvsvc_NetConnCtr1_Type, in->ctr1, in->ctr1);
1741                         }
1742                         return ret;
1743
1744                 default:
1745                         ret = Py_None;
1746                         Py_INCREF(ret);
1747                         return ret;
1748
1749         }
1750         PyErr_SetString(PyExc_TypeError, "unknown union level");
1751         return NULL;
1752 }
1753
1754 static union srvsvc_NetConnCtr *py_export_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1755 {
1756         union srvsvc_NetConnCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetConnCtr);
1757         switch (level) {
1758                 case 0:
1759                         if (in == Py_None) {
1760                                 ret->ctr0 = NULL;
1761                         } else {
1762                                 ret->ctr0 = NULL;
1763                                 PY_CHECK_TYPE(&srvsvc_NetConnCtr0_Type, in, talloc_free(ret); return NULL;);
1764                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1765                                         PyErr_NoMemory();
1766                                         talloc_free(ret); return NULL;
1767                                 }
1768                                 ret->ctr0 = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(in);
1769                         }
1770                         break;
1771
1772                 case 1:
1773                         if (in == Py_None) {
1774                                 ret->ctr1 = NULL;
1775                         } else {
1776                                 ret->ctr1 = NULL;
1777                                 PY_CHECK_TYPE(&srvsvc_NetConnCtr1_Type, in, talloc_free(ret); return NULL;);
1778                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1779                                         PyErr_NoMemory();
1780                                         talloc_free(ret); return NULL;
1781                                 }
1782                                 ret->ctr1 = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(in);
1783                         }
1784                         break;
1785
1786                 default:
1787                         break;
1788
1789         }
1790
1791         return ret;
1792 }
1793
1794
1795 static PyObject *py_srvsvc_NetConnInfoCtr_get_level(PyObject *obj, void *closure)
1796 {
1797         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
1798         PyObject *py_level;
1799         py_level = PyInt_FromLong(object->level);
1800         return py_level;
1801 }
1802
1803 static int py_srvsvc_NetConnInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
1804 {
1805         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_obj);
1806         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1807         object->level = PyInt_AsLong(value);
1808         return 0;
1809 }
1810
1811 static PyObject *py_srvsvc_NetConnInfoCtr_get_ctr(PyObject *obj, void *closure)
1812 {
1813         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
1814         PyObject *py_ctr;
1815         py_ctr = py_import_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
1816         if (py_ctr == NULL) {
1817                 return NULL;
1818         }
1819         return py_ctr;
1820 }
1821
1822 static int py_srvsvc_NetConnInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
1823 {
1824         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_obj);
1825         {
1826                 union srvsvc_NetConnCtr *ctr_switch_0;
1827                 ctr_switch_0 = py_export_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
1828                 if (ctr_switch_0 == NULL) {
1829                         return -1;
1830                 }
1831                 object->ctr = *ctr_switch_0;
1832         }
1833         return 0;
1834 }
1835
1836 static PyGetSetDef py_srvsvc_NetConnInfoCtr_getsetters[] = {
1837         { discard_const_p(char, "level"), py_srvsvc_NetConnInfoCtr_get_level, py_srvsvc_NetConnInfoCtr_set_level },
1838         { discard_const_p(char, "ctr"), py_srvsvc_NetConnInfoCtr_get_ctr, py_srvsvc_NetConnInfoCtr_set_ctr },
1839         { NULL }
1840 };
1841
1842 static PyObject *py_srvsvc_NetConnInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1843 {
1844         return pytalloc_new(struct srvsvc_NetConnInfoCtr, type);
1845 }
1846
1847
1848 static PyTypeObject srvsvc_NetConnInfoCtr_Type = {
1849         PyObject_HEAD_INIT(NULL) 0,
1850         .tp_name = "srvsvc.NetConnInfoCtr",
1851         .tp_getset = py_srvsvc_NetConnInfoCtr_getsetters,
1852         .tp_methods = NULL,
1853         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1854         .tp_basicsize = sizeof(pytalloc_Object),
1855         .tp_new = py_srvsvc_NetConnInfoCtr_new,
1856 };
1857
1858
1859 static PyObject *py_srvsvc_NetFileInfo2_get_fid(PyObject *obj, void *closure)
1860 {
1861         struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(obj);
1862         PyObject *py_fid;
1863         py_fid = PyInt_FromLong(object->fid);
1864         return py_fid;
1865 }
1866
1867 static int py_srvsvc_NetFileInfo2_set_fid(PyObject *py_obj, PyObject *value, void *closure)
1868 {
1869         struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(py_obj);
1870         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1871         object->fid = PyInt_AsLong(value);
1872         return 0;
1873 }
1874
1875 static PyGetSetDef py_srvsvc_NetFileInfo2_getsetters[] = {
1876         { discard_const_p(char, "fid"), py_srvsvc_NetFileInfo2_get_fid, py_srvsvc_NetFileInfo2_set_fid },
1877         { NULL }
1878 };
1879
1880 static PyObject *py_srvsvc_NetFileInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1881 {
1882         return pytalloc_new(struct srvsvc_NetFileInfo2, type);
1883 }
1884
1885
1886 static PyTypeObject srvsvc_NetFileInfo2_Type = {
1887         PyObject_HEAD_INIT(NULL) 0,
1888         .tp_name = "srvsvc.NetFileInfo2",
1889         .tp_getset = py_srvsvc_NetFileInfo2_getsetters,
1890         .tp_methods = NULL,
1891         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1892         .tp_basicsize = sizeof(pytalloc_Object),
1893         .tp_new = py_srvsvc_NetFileInfo2_new,
1894 };
1895
1896
1897 static PyObject *py_srvsvc_NetFileCtr2_get_count(PyObject *obj, void *closure)
1898 {
1899         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
1900         PyObject *py_count;
1901         py_count = PyInt_FromLong(object->count);
1902         return py_count;
1903 }
1904
1905 static int py_srvsvc_NetFileCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
1906 {
1907         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(py_obj);
1908         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1909         object->count = PyInt_AsLong(value);
1910         return 0;
1911 }
1912
1913 static PyObject *py_srvsvc_NetFileCtr2_get_array(PyObject *obj, void *closure)
1914 {
1915         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
1916         PyObject *py_array;
1917         if (object->array == NULL) {
1918                 py_array = Py_None;
1919                 Py_INCREF(py_array);
1920         } else {
1921                 py_array = PyList_New(object->count);
1922                 if (py_array == NULL) {
1923                         return NULL;
1924                 }
1925                 {
1926                         int array_cntr_1;
1927                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1928                                 PyObject *py_array_1;
1929                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, object->array, &object->array[array_cntr_1]);
1930                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1931                         }
1932                 }
1933         }
1934         return py_array;
1935 }
1936
1937 static int py_srvsvc_NetFileCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
1938 {
1939         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(py_obj);
1940         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1941         if (value == Py_None) {
1942                 object->array = NULL;
1943         } else {
1944                 object->array = NULL;
1945                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1946                 {
1947                         int array_cntr_1;
1948                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1949                         if (!object->array) { return -1;; }
1950                         talloc_set_name_const(object->array, "ARRAY: object->array");
1951                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1952                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1953                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1954                                         PyErr_NoMemory();
1955                                         return -1;
1956                                 }
1957                                 object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1958                         }
1959                 }
1960         }
1961         return 0;
1962 }
1963
1964 static PyGetSetDef py_srvsvc_NetFileCtr2_getsetters[] = {
1965         { discard_const_p(char, "count"), py_srvsvc_NetFileCtr2_get_count, py_srvsvc_NetFileCtr2_set_count },
1966         { discard_const_p(char, "array"), py_srvsvc_NetFileCtr2_get_array, py_srvsvc_NetFileCtr2_set_array },
1967         { NULL }
1968 };
1969
1970 static PyObject *py_srvsvc_NetFileCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1971 {
1972         return pytalloc_new(struct srvsvc_NetFileCtr2, type);
1973 }
1974
1975
1976 static PyTypeObject srvsvc_NetFileCtr2_Type = {
1977         PyObject_HEAD_INIT(NULL) 0,
1978         .tp_name = "srvsvc.NetFileCtr2",
1979         .tp_getset = py_srvsvc_NetFileCtr2_getsetters,
1980         .tp_methods = NULL,
1981         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1982         .tp_basicsize = sizeof(pytalloc_Object),
1983         .tp_new = py_srvsvc_NetFileCtr2_new,
1984 };
1985
1986
1987 static PyObject *py_srvsvc_NetFileInfo3_get_fid(PyObject *obj, void *closure)
1988 {
1989         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
1990         PyObject *py_fid;
1991         py_fid = PyInt_FromLong(object->fid);
1992         return py_fid;
1993 }
1994
1995 static int py_srvsvc_NetFileInfo3_set_fid(PyObject *py_obj, PyObject *value, void *closure)
1996 {
1997         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
1998         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1999         object->fid = PyInt_AsLong(value);
2000         return 0;
2001 }
2002
2003 static PyObject *py_srvsvc_NetFileInfo3_get_permissions(PyObject *obj, void *closure)
2004 {
2005         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2006         PyObject *py_permissions;
2007         py_permissions = PyInt_FromLong(object->permissions);
2008         return py_permissions;
2009 }
2010
2011 static int py_srvsvc_NetFileInfo3_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
2012 {
2013         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2014         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2015         object->permissions = PyInt_AsLong(value);
2016         return 0;
2017 }
2018
2019 static PyObject *py_srvsvc_NetFileInfo3_get_num_locks(PyObject *obj, void *closure)
2020 {
2021         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2022         PyObject *py_num_locks;
2023         py_num_locks = PyInt_FromLong(object->num_locks);
2024         return py_num_locks;
2025 }
2026
2027 static int py_srvsvc_NetFileInfo3_set_num_locks(PyObject *py_obj, PyObject *value, void *closure)
2028 {
2029         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2030         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2031         object->num_locks = PyInt_AsLong(value);
2032         return 0;
2033 }
2034
2035 static PyObject *py_srvsvc_NetFileInfo3_get_path(PyObject *obj, void *closure)
2036 {
2037         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2038         PyObject *py_path;
2039         if (object->path == NULL) {
2040                 py_path = Py_None;
2041                 Py_INCREF(py_path);
2042         } else {
2043                 if (object->path == NULL) {
2044                         py_path = Py_None;
2045                         Py_INCREF(py_path);
2046                 } else {
2047                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
2048                 }
2049         }
2050         return py_path;
2051 }
2052
2053 static int py_srvsvc_NetFileInfo3_set_path(PyObject *py_obj, PyObject *value, void *closure)
2054 {
2055         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2056         if (value == Py_None) {
2057                 object->path = NULL;
2058         } else {
2059                 object->path = NULL;
2060                 if (PyUnicode_Check(value)) {
2061                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2062                 } else if (PyString_Check(value)) {
2063                         object->path = PyString_AS_STRING(value);
2064                 } else {
2065                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2066                         return -1;
2067                 }
2068         }
2069         return 0;
2070 }
2071
2072 static PyObject *py_srvsvc_NetFileInfo3_get_user(PyObject *obj, void *closure)
2073 {
2074         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2075         PyObject *py_user;
2076         if (object->user == NULL) {
2077                 py_user = Py_None;
2078                 Py_INCREF(py_user);
2079         } else {
2080                 if (object->user == NULL) {
2081                         py_user = Py_None;
2082                         Py_INCREF(py_user);
2083                 } else {
2084                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2085                 }
2086         }
2087         return py_user;
2088 }
2089
2090 static int py_srvsvc_NetFileInfo3_set_user(PyObject *py_obj, PyObject *value, void *closure)
2091 {
2092         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2093         if (value == Py_None) {
2094                 object->user = NULL;
2095         } else {
2096                 object->user = NULL;
2097                 if (PyUnicode_Check(value)) {
2098                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2099                 } else if (PyString_Check(value)) {
2100                         object->user = PyString_AS_STRING(value);
2101                 } else {
2102                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2103                         return -1;
2104                 }
2105         }
2106         return 0;
2107 }
2108
2109 static PyGetSetDef py_srvsvc_NetFileInfo3_getsetters[] = {
2110         { discard_const_p(char, "fid"), py_srvsvc_NetFileInfo3_get_fid, py_srvsvc_NetFileInfo3_set_fid },
2111         { discard_const_p(char, "permissions"), py_srvsvc_NetFileInfo3_get_permissions, py_srvsvc_NetFileInfo3_set_permissions },
2112         { discard_const_p(char, "num_locks"), py_srvsvc_NetFileInfo3_get_num_locks, py_srvsvc_NetFileInfo3_set_num_locks },
2113         { discard_const_p(char, "path"), py_srvsvc_NetFileInfo3_get_path, py_srvsvc_NetFileInfo3_set_path },
2114         { discard_const_p(char, "user"), py_srvsvc_NetFileInfo3_get_user, py_srvsvc_NetFileInfo3_set_user },
2115         { NULL }
2116 };
2117
2118 static PyObject *py_srvsvc_NetFileInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2119 {
2120         return pytalloc_new(struct srvsvc_NetFileInfo3, type);
2121 }
2122
2123
2124 static PyTypeObject srvsvc_NetFileInfo3_Type = {
2125         PyObject_HEAD_INIT(NULL) 0,
2126         .tp_name = "srvsvc.NetFileInfo3",
2127         .tp_getset = py_srvsvc_NetFileInfo3_getsetters,
2128         .tp_methods = NULL,
2129         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2130         .tp_basicsize = sizeof(pytalloc_Object),
2131         .tp_new = py_srvsvc_NetFileInfo3_new,
2132 };
2133
2134
2135 static PyObject *py_srvsvc_NetFileCtr3_get_count(PyObject *obj, void *closure)
2136 {
2137         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
2138         PyObject *py_count;
2139         py_count = PyInt_FromLong(object->count);
2140         return py_count;
2141 }
2142
2143 static int py_srvsvc_NetFileCtr3_set_count(PyObject *py_obj, PyObject *value, void *closure)
2144 {
2145         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(py_obj);
2146         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2147         object->count = PyInt_AsLong(value);
2148         return 0;
2149 }
2150
2151 static PyObject *py_srvsvc_NetFileCtr3_get_array(PyObject *obj, void *closure)
2152 {
2153         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
2154         PyObject *py_array;
2155         if (object->array == NULL) {
2156                 py_array = Py_None;
2157                 Py_INCREF(py_array);
2158         } else {
2159                 py_array = PyList_New(object->count);
2160                 if (py_array == NULL) {
2161                         return NULL;
2162                 }
2163                 {
2164                         int array_cntr_1;
2165                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2166                                 PyObject *py_array_1;
2167                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo3_Type, object->array, &object->array[array_cntr_1]);
2168                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2169                         }
2170                 }
2171         }
2172         return py_array;
2173 }
2174
2175 static int py_srvsvc_NetFileCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
2176 {
2177         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(py_obj);
2178         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2179         if (value == Py_None) {
2180                 object->array = NULL;
2181         } else {
2182                 object->array = NULL;
2183                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2184                 {
2185                         int array_cntr_1;
2186                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2187                         if (!object->array) { return -1;; }
2188                         talloc_set_name_const(object->array, "ARRAY: object->array");
2189                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2190                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2191                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2192                                         PyErr_NoMemory();
2193                                         return -1;
2194                                 }
2195                                 object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2196                         }
2197                 }
2198         }
2199         return 0;
2200 }
2201
2202 static PyGetSetDef py_srvsvc_NetFileCtr3_getsetters[] = {
2203         { discard_const_p(char, "count"), py_srvsvc_NetFileCtr3_get_count, py_srvsvc_NetFileCtr3_set_count },
2204         { discard_const_p(char, "array"), py_srvsvc_NetFileCtr3_get_array, py_srvsvc_NetFileCtr3_set_array },
2205         { NULL }
2206 };
2207
2208 static PyObject *py_srvsvc_NetFileCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2209 {
2210         return pytalloc_new(struct srvsvc_NetFileCtr3, type);
2211 }
2212
2213
2214 static PyTypeObject srvsvc_NetFileCtr3_Type = {
2215         PyObject_HEAD_INIT(NULL) 0,
2216         .tp_name = "srvsvc.NetFileCtr3",
2217         .tp_getset = py_srvsvc_NetFileCtr3_getsetters,
2218         .tp_methods = NULL,
2219         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2220         .tp_basicsize = sizeof(pytalloc_Object),
2221         .tp_new = py_srvsvc_NetFileCtr3_new,
2222 };
2223
2224 static PyObject *py_import_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileInfo *in)
2225 {
2226         PyObject *ret;
2227
2228         switch (level) {
2229                 case 2:
2230                         if (in->info2 == NULL) {
2231                                 ret = Py_None;
2232                                 Py_INCREF(ret);
2233                         } else {
2234                                 ret = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, in->info2, in->info2);
2235                         }
2236                         return ret;
2237
2238                 case 3:
2239                         if (in->info3 == NULL) {
2240                                 ret = Py_None;
2241                                 Py_INCREF(ret);
2242                         } else {
2243                                 ret = pytalloc_reference_ex(&srvsvc_NetFileInfo3_Type, in->info3, in->info3);
2244                         }
2245                         return ret;
2246
2247                 default:
2248                         ret = Py_None;
2249                         Py_INCREF(ret);
2250                         return ret;
2251
2252         }
2253         PyErr_SetString(PyExc_TypeError, "unknown union level");
2254         return NULL;
2255 }
2256
2257 static union srvsvc_NetFileInfo *py_export_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2258 {
2259         union srvsvc_NetFileInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetFileInfo);
2260         switch (level) {
2261                 case 2:
2262                         if (in == Py_None) {
2263                                 ret->info2 = NULL;
2264                         } else {
2265                                 ret->info2 = NULL;
2266                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, in, talloc_free(ret); return NULL;);
2267                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2268                                         PyErr_NoMemory();
2269                                         talloc_free(ret); return NULL;
2270                                 }
2271                                 ret->info2 = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(in);
2272                         }
2273                         break;
2274
2275                 case 3:
2276                         if (in == Py_None) {
2277                                 ret->info3 = NULL;
2278                         } else {
2279                                 ret->info3 = NULL;
2280                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, in, talloc_free(ret); return NULL;);
2281                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2282                                         PyErr_NoMemory();
2283                                         talloc_free(ret); return NULL;
2284                                 }
2285                                 ret->info3 = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(in);
2286                         }
2287                         break;
2288
2289                 default:
2290                         break;
2291
2292         }
2293
2294         return ret;
2295 }
2296
2297 static PyObject *py_import_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileCtr *in)
2298 {
2299         PyObject *ret;
2300
2301         switch (level) {
2302                 case 2:
2303                         if (in->ctr2 == NULL) {
2304                                 ret = Py_None;
2305                                 Py_INCREF(ret);
2306                         } else {
2307                                 ret = pytalloc_reference_ex(&srvsvc_NetFileCtr2_Type, in->ctr2, in->ctr2);
2308                         }
2309                         return ret;
2310
2311                 case 3:
2312                         if (in->ctr3 == NULL) {
2313                                 ret = Py_None;
2314                                 Py_INCREF(ret);
2315                         } else {
2316                                 ret = pytalloc_reference_ex(&srvsvc_NetFileCtr3_Type, in->ctr3, in->ctr3);
2317                         }
2318                         return ret;
2319
2320                 default:
2321                         ret = Py_None;
2322                         Py_INCREF(ret);
2323                         return ret;
2324
2325         }
2326         PyErr_SetString(PyExc_TypeError, "unknown union level");
2327         return NULL;
2328 }
2329
2330 static union srvsvc_NetFileCtr *py_export_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2331 {
2332         union srvsvc_NetFileCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetFileCtr);
2333         switch (level) {
2334                 case 2:
2335                         if (in == Py_None) {
2336                                 ret->ctr2 = NULL;
2337                         } else {
2338                                 ret->ctr2 = NULL;
2339                                 PY_CHECK_TYPE(&srvsvc_NetFileCtr2_Type, in, talloc_free(ret); return NULL;);
2340                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2341                                         PyErr_NoMemory();
2342                                         talloc_free(ret); return NULL;
2343                                 }
2344                                 ret->ctr2 = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(in);
2345                         }
2346                         break;
2347
2348                 case 3:
2349                         if (in == Py_None) {
2350                                 ret->ctr3 = NULL;
2351                         } else {
2352                                 ret->ctr3 = NULL;
2353                                 PY_CHECK_TYPE(&srvsvc_NetFileCtr3_Type, in, talloc_free(ret); return NULL;);
2354                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2355                                         PyErr_NoMemory();
2356                                         talloc_free(ret); return NULL;
2357                                 }
2358                                 ret->ctr3 = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(in);
2359                         }
2360                         break;
2361
2362                 default:
2363                         break;
2364
2365         }
2366
2367         return ret;
2368 }
2369
2370
2371 static PyObject *py_srvsvc_NetFileInfoCtr_get_level(PyObject *obj, void *closure)
2372 {
2373         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
2374         PyObject *py_level;
2375         py_level = PyInt_FromLong(object->level);
2376         return py_level;
2377 }
2378
2379 static int py_srvsvc_NetFileInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
2380 {
2381         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_obj);
2382         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2383         object->level = PyInt_AsLong(value);
2384         return 0;
2385 }
2386
2387 static PyObject *py_srvsvc_NetFileInfoCtr_get_ctr(PyObject *obj, void *closure)
2388 {
2389         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
2390         PyObject *py_ctr;
2391         py_ctr = py_import_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
2392         if (py_ctr == NULL) {
2393                 return NULL;
2394         }
2395         return py_ctr;
2396 }
2397
2398 static int py_srvsvc_NetFileInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
2399 {
2400         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_obj);
2401         {
2402                 union srvsvc_NetFileCtr *ctr_switch_0;
2403                 ctr_switch_0 = py_export_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
2404                 if (ctr_switch_0 == NULL) {
2405                         return -1;
2406                 }
2407                 object->ctr = *ctr_switch_0;
2408         }
2409         return 0;
2410 }
2411
2412 static PyGetSetDef py_srvsvc_NetFileInfoCtr_getsetters[] = {
2413         { discard_const_p(char, "level"), py_srvsvc_NetFileInfoCtr_get_level, py_srvsvc_NetFileInfoCtr_set_level },
2414         { discard_const_p(char, "ctr"), py_srvsvc_NetFileInfoCtr_get_ctr, py_srvsvc_NetFileInfoCtr_set_ctr },
2415         { NULL }
2416 };
2417
2418 static PyObject *py_srvsvc_NetFileInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2419 {
2420         return pytalloc_new(struct srvsvc_NetFileInfoCtr, type);
2421 }
2422
2423
2424 static PyTypeObject srvsvc_NetFileInfoCtr_Type = {
2425         PyObject_HEAD_INIT(NULL) 0,
2426         .tp_name = "srvsvc.NetFileInfoCtr",
2427         .tp_getset = py_srvsvc_NetFileInfoCtr_getsetters,
2428         .tp_methods = NULL,
2429         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2430         .tp_basicsize = sizeof(pytalloc_Object),
2431         .tp_new = py_srvsvc_NetFileInfoCtr_new,
2432 };
2433
2434
2435 static PyObject *py_srvsvc_NetSessInfo0_get_client(PyObject *obj, void *closure)
2436 {
2437         struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(obj);
2438         PyObject *py_client;
2439         if (object->client == NULL) {
2440                 py_client = Py_None;
2441                 Py_INCREF(py_client);
2442         } else {
2443                 if (object->client == NULL) {
2444                         py_client = Py_None;
2445                         Py_INCREF(py_client);
2446                 } else {
2447                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2448                 }
2449         }
2450         return py_client;
2451 }
2452
2453 static int py_srvsvc_NetSessInfo0_set_client(PyObject *py_obj, PyObject *value, void *closure)
2454 {
2455         struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(py_obj);
2456         if (value == Py_None) {
2457                 object->client = NULL;
2458         } else {
2459                 object->client = NULL;
2460                 if (PyUnicode_Check(value)) {
2461                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2462                 } else if (PyString_Check(value)) {
2463                         object->client = PyString_AS_STRING(value);
2464                 } else {
2465                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2466                         return -1;
2467                 }
2468         }
2469         return 0;
2470 }
2471
2472 static PyGetSetDef py_srvsvc_NetSessInfo0_getsetters[] = {
2473         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo0_get_client, py_srvsvc_NetSessInfo0_set_client },
2474         { NULL }
2475 };
2476
2477 static PyObject *py_srvsvc_NetSessInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2478 {
2479         return pytalloc_new(struct srvsvc_NetSessInfo0, type);
2480 }
2481
2482
2483 static PyTypeObject srvsvc_NetSessInfo0_Type = {
2484         PyObject_HEAD_INIT(NULL) 0,
2485         .tp_name = "srvsvc.NetSessInfo0",
2486         .tp_getset = py_srvsvc_NetSessInfo0_getsetters,
2487         .tp_methods = NULL,
2488         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2489         .tp_basicsize = sizeof(pytalloc_Object),
2490         .tp_new = py_srvsvc_NetSessInfo0_new,
2491 };
2492
2493
2494 static PyObject *py_srvsvc_NetSessCtr0_get_count(PyObject *obj, void *closure)
2495 {
2496         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
2497         PyObject *py_count;
2498         py_count = PyInt_FromLong(object->count);
2499         return py_count;
2500 }
2501
2502 static int py_srvsvc_NetSessCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
2503 {
2504         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(py_obj);
2505         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2506         object->count = PyInt_AsLong(value);
2507         return 0;
2508 }
2509
2510 static PyObject *py_srvsvc_NetSessCtr0_get_array(PyObject *obj, void *closure)
2511 {
2512         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
2513         PyObject *py_array;
2514         if (object->array == NULL) {
2515                 py_array = Py_None;
2516                 Py_INCREF(py_array);
2517         } else {
2518                 py_array = PyList_New(object->count);
2519                 if (py_array == NULL) {
2520                         return NULL;
2521                 }
2522                 {
2523                         int array_cntr_1;
2524                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2525                                 PyObject *py_array_1;
2526                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo0_Type, object->array, &object->array[array_cntr_1]);
2527                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2528                         }
2529                 }
2530         }
2531         return py_array;
2532 }
2533
2534 static int py_srvsvc_NetSessCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
2535 {
2536         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(py_obj);
2537         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2538         if (value == Py_None) {
2539                 object->array = NULL;
2540         } else {
2541                 object->array = NULL;
2542                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2543                 {
2544                         int array_cntr_1;
2545                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2546                         if (!object->array) { return -1;; }
2547                         talloc_set_name_const(object->array, "ARRAY: object->array");
2548                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2549                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2550                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2551                                         PyErr_NoMemory();
2552                                         return -1;
2553                                 }
2554                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2555                         }
2556                 }
2557         }
2558         return 0;
2559 }
2560
2561 static PyGetSetDef py_srvsvc_NetSessCtr0_getsetters[] = {
2562         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr0_get_count, py_srvsvc_NetSessCtr0_set_count },
2563         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr0_get_array, py_srvsvc_NetSessCtr0_set_array },
2564         { NULL }
2565 };
2566
2567 static PyObject *py_srvsvc_NetSessCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2568 {
2569         return pytalloc_new(struct srvsvc_NetSessCtr0, type);
2570 }
2571
2572
2573 static PyTypeObject srvsvc_NetSessCtr0_Type = {
2574         PyObject_HEAD_INIT(NULL) 0,
2575         .tp_name = "srvsvc.NetSessCtr0",
2576         .tp_getset = py_srvsvc_NetSessCtr0_getsetters,
2577         .tp_methods = NULL,
2578         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2579         .tp_basicsize = sizeof(pytalloc_Object),
2580         .tp_new = py_srvsvc_NetSessCtr0_new,
2581 };
2582
2583
2584 static PyObject *py_srvsvc_NetSessInfo1_get_client(PyObject *obj, void *closure)
2585 {
2586         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2587         PyObject *py_client;
2588         if (object->client == NULL) {
2589                 py_client = Py_None;
2590                 Py_INCREF(py_client);
2591         } else {
2592                 if (object->client == NULL) {
2593                         py_client = Py_None;
2594                         Py_INCREF(py_client);
2595                 } else {
2596                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2597                 }
2598         }
2599         return py_client;
2600 }
2601
2602 static int py_srvsvc_NetSessInfo1_set_client(PyObject *py_obj, PyObject *value, void *closure)
2603 {
2604         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2605         if (value == Py_None) {
2606                 object->client = NULL;
2607         } else {
2608                 object->client = NULL;
2609                 if (PyUnicode_Check(value)) {
2610                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2611                 } else if (PyString_Check(value)) {
2612                         object->client = PyString_AS_STRING(value);
2613                 } else {
2614                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2615                         return -1;
2616                 }
2617         }
2618         return 0;
2619 }
2620
2621 static PyObject *py_srvsvc_NetSessInfo1_get_user(PyObject *obj, void *closure)
2622 {
2623         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2624         PyObject *py_user;
2625         if (object->user == NULL) {
2626                 py_user = Py_None;
2627                 Py_INCREF(py_user);
2628         } else {
2629                 if (object->user == NULL) {
2630                         py_user = Py_None;
2631                         Py_INCREF(py_user);
2632                 } else {
2633                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2634                 }
2635         }
2636         return py_user;
2637 }
2638
2639 static int py_srvsvc_NetSessInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
2640 {
2641         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2642         if (value == Py_None) {
2643                 object->user = NULL;
2644         } else {
2645                 object->user = NULL;
2646                 if (PyUnicode_Check(value)) {
2647                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2648                 } else if (PyString_Check(value)) {
2649                         object->user = PyString_AS_STRING(value);
2650                 } else {
2651                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2652                         return -1;
2653                 }
2654         }
2655         return 0;
2656 }
2657
2658 static PyObject *py_srvsvc_NetSessInfo1_get_num_open(PyObject *obj, void *closure)
2659 {
2660         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2661         PyObject *py_num_open;
2662         py_num_open = PyInt_FromLong(object->num_open);
2663         return py_num_open;
2664 }
2665
2666 static int py_srvsvc_NetSessInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
2667 {
2668         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2669         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2670         object->num_open = PyInt_AsLong(value);
2671         return 0;
2672 }
2673
2674 static PyObject *py_srvsvc_NetSessInfo1_get_time(PyObject *obj, void *closure)
2675 {
2676         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2677         PyObject *py_time;
2678         py_time = PyInt_FromLong(object->time);
2679         return py_time;
2680 }
2681
2682 static int py_srvsvc_NetSessInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
2683 {
2684         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2685         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2686         object->time = PyInt_AsLong(value);
2687         return 0;
2688 }
2689
2690 static PyObject *py_srvsvc_NetSessInfo1_get_idle_time(PyObject *obj, void *closure)
2691 {
2692         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2693         PyObject *py_idle_time;
2694         py_idle_time = PyInt_FromLong(object->idle_time);
2695         return py_idle_time;
2696 }
2697
2698 static int py_srvsvc_NetSessInfo1_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
2699 {
2700         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2701         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2702         object->idle_time = PyInt_AsLong(value);
2703         return 0;
2704 }
2705
2706 static PyObject *py_srvsvc_NetSessInfo1_get_user_flags(PyObject *obj, void *closure)
2707 {
2708         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2709         PyObject *py_user_flags;
2710         py_user_flags = PyInt_FromLong(object->user_flags);
2711         return py_user_flags;
2712 }
2713
2714 static int py_srvsvc_NetSessInfo1_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
2715 {
2716         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2717         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2718         object->user_flags = PyInt_AsLong(value);
2719         return 0;
2720 }
2721
2722 static PyGetSetDef py_srvsvc_NetSessInfo1_getsetters[] = {
2723         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo1_get_client, py_srvsvc_NetSessInfo1_set_client },
2724         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo1_get_user, py_srvsvc_NetSessInfo1_set_user },
2725         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo1_get_num_open, py_srvsvc_NetSessInfo1_set_num_open },
2726         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo1_get_time, py_srvsvc_NetSessInfo1_set_time },
2727         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo1_get_idle_time, py_srvsvc_NetSessInfo1_set_idle_time },
2728         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo1_get_user_flags, py_srvsvc_NetSessInfo1_set_user_flags },
2729         { NULL }
2730 };
2731
2732 static PyObject *py_srvsvc_NetSessInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2733 {
2734         return pytalloc_new(struct srvsvc_NetSessInfo1, type);
2735 }
2736
2737
2738 static PyTypeObject srvsvc_NetSessInfo1_Type = {
2739         PyObject_HEAD_INIT(NULL) 0,
2740         .tp_name = "srvsvc.NetSessInfo1",
2741         .tp_getset = py_srvsvc_NetSessInfo1_getsetters,
2742         .tp_methods = NULL,
2743         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2744         .tp_basicsize = sizeof(pytalloc_Object),
2745         .tp_new = py_srvsvc_NetSessInfo1_new,
2746 };
2747
2748
2749 static PyObject *py_srvsvc_NetSessCtr1_get_count(PyObject *obj, void *closure)
2750 {
2751         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
2752         PyObject *py_count;
2753         py_count = PyInt_FromLong(object->count);
2754         return py_count;
2755 }
2756
2757 static int py_srvsvc_NetSessCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
2758 {
2759         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(py_obj);
2760         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2761         object->count = PyInt_AsLong(value);
2762         return 0;
2763 }
2764
2765 static PyObject *py_srvsvc_NetSessCtr1_get_array(PyObject *obj, void *closure)
2766 {
2767         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
2768         PyObject *py_array;
2769         if (object->array == NULL) {
2770                 py_array = Py_None;
2771                 Py_INCREF(py_array);
2772         } else {
2773                 py_array = PyList_New(object->count);
2774                 if (py_array == NULL) {
2775                         return NULL;
2776                 }
2777                 {
2778                         int array_cntr_1;
2779                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2780                                 PyObject *py_array_1;
2781                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo1_Type, object->array, &object->array[array_cntr_1]);
2782                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2783                         }
2784                 }
2785         }
2786         return py_array;
2787 }
2788
2789 static int py_srvsvc_NetSessCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
2790 {
2791         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(py_obj);
2792         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2793         if (value == Py_None) {
2794                 object->array = NULL;
2795         } else {
2796                 object->array = NULL;
2797                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2798                 {
2799                         int array_cntr_1;
2800                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2801                         if (!object->array) { return -1;; }
2802                         talloc_set_name_const(object->array, "ARRAY: object->array");
2803                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2804                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2805                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2806                                         PyErr_NoMemory();
2807                                         return -1;
2808                                 }
2809                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2810                         }
2811                 }
2812         }
2813         return 0;
2814 }
2815
2816 static PyGetSetDef py_srvsvc_NetSessCtr1_getsetters[] = {
2817         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr1_get_count, py_srvsvc_NetSessCtr1_set_count },
2818         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr1_get_array, py_srvsvc_NetSessCtr1_set_array },
2819         { NULL }
2820 };
2821
2822 static PyObject *py_srvsvc_NetSessCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2823 {
2824         return pytalloc_new(struct srvsvc_NetSessCtr1, type);
2825 }
2826
2827
2828 static PyTypeObject srvsvc_NetSessCtr1_Type = {
2829         PyObject_HEAD_INIT(NULL) 0,
2830         .tp_name = "srvsvc.NetSessCtr1",
2831         .tp_getset = py_srvsvc_NetSessCtr1_getsetters,
2832         .tp_methods = NULL,
2833         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2834         .tp_basicsize = sizeof(pytalloc_Object),
2835         .tp_new = py_srvsvc_NetSessCtr1_new,
2836 };
2837
2838
2839 static PyObject *py_srvsvc_NetSessInfo2_get_client(PyObject *obj, void *closure)
2840 {
2841         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2842         PyObject *py_client;
2843         if (object->client == NULL) {
2844                 py_client = Py_None;
2845                 Py_INCREF(py_client);
2846         } else {
2847                 if (object->client == NULL) {
2848                         py_client = Py_None;
2849                         Py_INCREF(py_client);
2850                 } else {
2851                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2852                 }
2853         }
2854         return py_client;
2855 }
2856
2857 static int py_srvsvc_NetSessInfo2_set_client(PyObject *py_obj, PyObject *value, void *closure)
2858 {
2859         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2860         if (value == Py_None) {
2861                 object->client = NULL;
2862         } else {
2863                 object->client = NULL;
2864                 if (PyUnicode_Check(value)) {
2865                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2866                 } else if (PyString_Check(value)) {
2867                         object->client = PyString_AS_STRING(value);
2868                 } else {
2869                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2870                         return -1;
2871                 }
2872         }
2873         return 0;
2874 }
2875
2876 static PyObject *py_srvsvc_NetSessInfo2_get_user(PyObject *obj, void *closure)
2877 {
2878         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2879         PyObject *py_user;
2880         if (object->user == NULL) {
2881                 py_user = Py_None;
2882                 Py_INCREF(py_user);
2883         } else {
2884                 if (object->user == NULL) {
2885                         py_user = Py_None;
2886                         Py_INCREF(py_user);
2887                 } else {
2888                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2889                 }
2890         }
2891         return py_user;
2892 }
2893
2894 static int py_srvsvc_NetSessInfo2_set_user(PyObject *py_obj, PyObject *value, void *closure)
2895 {
2896         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2897         if (value == Py_None) {
2898                 object->user = NULL;
2899         } else {
2900                 object->user = NULL;
2901                 if (PyUnicode_Check(value)) {
2902                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2903                 } else if (PyString_Check(value)) {
2904                         object->user = PyString_AS_STRING(value);
2905                 } else {
2906                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2907                         return -1;
2908                 }
2909         }
2910         return 0;
2911 }
2912
2913 static PyObject *py_srvsvc_NetSessInfo2_get_num_open(PyObject *obj, void *closure)
2914 {
2915         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2916         PyObject *py_num_open;
2917         py_num_open = PyInt_FromLong(object->num_open);
2918         return py_num_open;
2919 }
2920
2921 static int py_srvsvc_NetSessInfo2_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
2922 {
2923         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2924         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2925         object->num_open = PyInt_AsLong(value);
2926         return 0;
2927 }
2928
2929 static PyObject *py_srvsvc_NetSessInfo2_get_time(PyObject *obj, void *closure)
2930 {
2931         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2932         PyObject *py_time;
2933         py_time = PyInt_FromLong(object->time);
2934         return py_time;
2935 }
2936
2937 static int py_srvsvc_NetSessInfo2_set_time(PyObject *py_obj, PyObject *value, void *closure)
2938 {
2939         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2940         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2941         object->time = PyInt_AsLong(value);
2942         return 0;
2943 }
2944
2945 static PyObject *py_srvsvc_NetSessInfo2_get_idle_time(PyObject *obj, void *closure)
2946 {
2947         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2948         PyObject *py_idle_time;
2949         py_idle_time = PyInt_FromLong(object->idle_time);
2950         return py_idle_time;
2951 }
2952
2953 static int py_srvsvc_NetSessInfo2_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
2954 {
2955         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2956         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2957         object->idle_time = PyInt_AsLong(value);
2958         return 0;
2959 }
2960
2961 static PyObject *py_srvsvc_NetSessInfo2_get_user_flags(PyObject *obj, void *closure)
2962 {
2963         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2964         PyObject *py_user_flags;
2965         py_user_flags = PyInt_FromLong(object->user_flags);
2966         return py_user_flags;
2967 }
2968
2969 static int py_srvsvc_NetSessInfo2_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
2970 {
2971         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2972         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2973         object->user_flags = PyInt_AsLong(value);
2974         return 0;
2975 }
2976
2977 static PyObject *py_srvsvc_NetSessInfo2_get_client_type(PyObject *obj, void *closure)
2978 {
2979         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2980         PyObject *py_client_type;
2981         if (object->client_type == NULL) {
2982                 py_client_type = Py_None;
2983                 Py_INCREF(py_client_type);
2984         } else {
2985                 if (object->client_type == NULL) {
2986                         py_client_type = Py_None;
2987                         Py_INCREF(py_client_type);
2988                 } else {
2989                         py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
2990                 }
2991         }
2992         return py_client_type;
2993 }
2994
2995 static int py_srvsvc_NetSessInfo2_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
2996 {
2997         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2998         if (value == Py_None) {
2999                 object->client_type = NULL;
3000         } else {
3001                 object->client_type = NULL;
3002                 if (PyUnicode_Check(value)) {
3003                         object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3004                 } else if (PyString_Check(value)) {
3005                         object->client_type = PyString_AS_STRING(value);
3006                 } else {
3007                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3008                         return -1;
3009                 }
3010         }
3011         return 0;
3012 }
3013
3014 static PyGetSetDef py_srvsvc_NetSessInfo2_getsetters[] = {
3015         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo2_get_client, py_srvsvc_NetSessInfo2_set_client },
3016         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo2_get_user, py_srvsvc_NetSessInfo2_set_user },
3017         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo2_get_num_open, py_srvsvc_NetSessInfo2_set_num_open },
3018         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo2_get_time, py_srvsvc_NetSessInfo2_set_time },
3019         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo2_get_idle_time, py_srvsvc_NetSessInfo2_set_idle_time },
3020         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo2_get_user_flags, py_srvsvc_NetSessInfo2_set_user_flags },
3021         { discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo2_get_client_type, py_srvsvc_NetSessInfo2_set_client_type },
3022         { NULL }
3023 };
3024
3025 static PyObject *py_srvsvc_NetSessInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3026 {
3027         return pytalloc_new(struct srvsvc_NetSessInfo2, type);
3028 }
3029
3030
3031 static PyTypeObject srvsvc_NetSessInfo2_Type = {
3032         PyObject_HEAD_INIT(NULL) 0,
3033         .tp_name = "srvsvc.NetSessInfo2",
3034         .tp_getset = py_srvsvc_NetSessInfo2_getsetters,
3035         .tp_methods = NULL,
3036         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3037         .tp_basicsize = sizeof(pytalloc_Object),
3038         .tp_new = py_srvsvc_NetSessInfo2_new,
3039 };
3040
3041
3042 static PyObject *py_srvsvc_NetSessCtr2_get_count(PyObject *obj, void *closure)
3043 {
3044         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
3045         PyObject *py_count;
3046         py_count = PyInt_FromLong(object->count);
3047         return py_count;
3048 }
3049
3050 static int py_srvsvc_NetSessCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
3051 {
3052         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(py_obj);
3053         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3054         object->count = PyInt_AsLong(value);
3055         return 0;
3056 }
3057
3058 static PyObject *py_srvsvc_NetSessCtr2_get_array(PyObject *obj, void *closure)
3059 {
3060         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
3061         PyObject *py_array;
3062         if (object->array == NULL) {
3063                 py_array = Py_None;
3064                 Py_INCREF(py_array);
3065         } else {
3066                 py_array = PyList_New(object->count);
3067                 if (py_array == NULL) {
3068                         return NULL;
3069                 }
3070                 {
3071                         int array_cntr_1;
3072                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3073                                 PyObject *py_array_1;
3074                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo2_Type, object->array, &object->array[array_cntr_1]);
3075                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3076                         }
3077                 }
3078         }
3079         return py_array;
3080 }
3081
3082 static int py_srvsvc_NetSessCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
3083 {
3084         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(py_obj);
3085         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3086         if (value == Py_None) {
3087                 object->array = NULL;
3088         } else {
3089                 object->array = NULL;
3090                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3091                 {
3092                         int array_cntr_1;
3093                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3094                         if (!object->array) { return -1;; }
3095                         talloc_set_name_const(object->array, "ARRAY: object->array");
3096                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3097                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3098                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3099                                         PyErr_NoMemory();
3100                                         return -1;
3101                                 }
3102                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3103                         }
3104                 }
3105         }
3106         return 0;
3107 }
3108
3109 static PyGetSetDef py_srvsvc_NetSessCtr2_getsetters[] = {
3110         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr2_get_count, py_srvsvc_NetSessCtr2_set_count },
3111         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr2_get_array, py_srvsvc_NetSessCtr2_set_array },
3112         { NULL }
3113 };
3114
3115 static PyObject *py_srvsvc_NetSessCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3116 {
3117         return pytalloc_new(struct srvsvc_NetSessCtr2, type);
3118 }
3119
3120
3121 static PyTypeObject srvsvc_NetSessCtr2_Type = {
3122         PyObject_HEAD_INIT(NULL) 0,
3123         .tp_name = "srvsvc.NetSessCtr2",
3124         .tp_getset = py_srvsvc_NetSessCtr2_getsetters,
3125         .tp_methods = NULL,
3126         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3127         .tp_basicsize = sizeof(pytalloc_Object),
3128         .tp_new = py_srvsvc_NetSessCtr2_new,
3129 };
3130
3131
3132 static PyObject *py_srvsvc_NetSessInfo10_get_client(PyObject *obj, void *closure)
3133 {
3134         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3135         PyObject *py_client;
3136         if (object->client == NULL) {
3137                 py_client = Py_None;
3138                 Py_INCREF(py_client);
3139         } else {
3140                 if (object->client == NULL) {
3141                         py_client = Py_None;
3142                         Py_INCREF(py_client);
3143                 } else {
3144                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
3145                 }
3146         }
3147         return py_client;
3148 }
3149
3150 static int py_srvsvc_NetSessInfo10_set_client(PyObject *py_obj, PyObject *value, void *closure)
3151 {
3152         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3153         if (value == Py_None) {
3154                 object->client = NULL;
3155         } else {
3156                 object->client = NULL;
3157                 if (PyUnicode_Check(value)) {
3158                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3159                 } else if (PyString_Check(value)) {
3160                         object->client = PyString_AS_STRING(value);
3161                 } else {
3162                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3163                         return -1;
3164                 }
3165         }
3166         return 0;
3167 }
3168
3169 static PyObject *py_srvsvc_NetSessInfo10_get_user(PyObject *obj, void *closure)
3170 {
3171         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3172         PyObject *py_user;
3173         if (object->user == NULL) {
3174                 py_user = Py_None;
3175                 Py_INCREF(py_user);
3176         } else {
3177                 if (object->user == NULL) {
3178                         py_user = Py_None;
3179                         Py_INCREF(py_user);
3180                 } else {
3181                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
3182                 }
3183         }
3184         return py_user;
3185 }
3186
3187 static int py_srvsvc_NetSessInfo10_set_user(PyObject *py_obj, PyObject *value, void *closure)
3188 {
3189         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3190         if (value == Py_None) {
3191                 object->user = NULL;
3192         } else {
3193                 object->user = NULL;
3194                 if (PyUnicode_Check(value)) {
3195                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3196                 } else if (PyString_Check(value)) {
3197                         object->user = PyString_AS_STRING(value);
3198                 } else {
3199                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3200                         return -1;
3201                 }
3202         }
3203         return 0;
3204 }
3205
3206 static PyObject *py_srvsvc_NetSessInfo10_get_time(PyObject *obj, void *closure)
3207 {
3208         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3209         PyObject *py_time;
3210         py_time = PyInt_FromLong(object->time);
3211         return py_time;
3212 }
3213
3214 static int py_srvsvc_NetSessInfo10_set_time(PyObject *py_obj, PyObject *value, void *closure)
3215 {
3216         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3217         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3218         object->time = PyInt_AsLong(value);
3219         return 0;
3220 }
3221
3222 static PyObject *py_srvsvc_NetSessInfo10_get_idle_time(PyObject *obj, void *closure)
3223 {
3224         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3225         PyObject *py_idle_time;
3226         py_idle_time = PyInt_FromLong(object->idle_time);
3227         return py_idle_time;
3228 }
3229
3230 static int py_srvsvc_NetSessInfo10_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
3231 {
3232         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3233         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3234         object->idle_time = PyInt_AsLong(value);
3235         return 0;
3236 }
3237
3238 static PyGetSetDef py_srvsvc_NetSessInfo10_getsetters[] = {
3239         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo10_get_client, py_srvsvc_NetSessInfo10_set_client },
3240         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo10_get_user, py_srvsvc_NetSessInfo10_set_user },
3241         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo10_get_time, py_srvsvc_NetSessInfo10_set_time },
3242         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo10_get_idle_time, py_srvsvc_NetSessInfo10_set_idle_time },
3243         { NULL }
3244 };
3245
3246 static PyObject *py_srvsvc_NetSessInfo10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3247 {
3248         return pytalloc_new(struct srvsvc_NetSessInfo10, type);
3249 }
3250
3251
3252 static PyTypeObject srvsvc_NetSessInfo10_Type = {
3253         PyObject_HEAD_INIT(NULL) 0,
3254         .tp_name = "srvsvc.NetSessInfo10",
3255         .tp_getset = py_srvsvc_NetSessInfo10_getsetters,
3256         .tp_methods = NULL,
3257         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3258         .tp_basicsize = sizeof(pytalloc_Object),
3259         .tp_new = py_srvsvc_NetSessInfo10_new,
3260 };
3261
3262
3263 static PyObject *py_srvsvc_NetSessCtr10_get_count(PyObject *obj, void *closure)
3264 {
3265         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
3266         PyObject *py_count;
3267         py_count = PyInt_FromLong(object->count);
3268         return py_count;
3269 }
3270
3271 static int py_srvsvc_NetSessCtr10_set_count(PyObject *py_obj, PyObject *value, void *closure)
3272 {
3273         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(py_obj);
3274         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3275         object->count = PyInt_AsLong(value);
3276         return 0;
3277 }
3278
3279 static PyObject *py_srvsvc_NetSessCtr10_get_array(PyObject *obj, void *closure)
3280 {
3281         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
3282         PyObject *py_array;
3283         if (object->array == NULL) {
3284                 py_array = Py_None;
3285                 Py_INCREF(py_array);
3286         } else {
3287                 py_array = PyList_New(object->count);
3288                 if (py_array == NULL) {
3289                         return NULL;
3290                 }
3291                 {
3292                         int array_cntr_1;
3293                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3294                                 PyObject *py_array_1;
3295                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo10_Type, object->array, &object->array[array_cntr_1]);
3296                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3297                         }
3298                 }
3299         }
3300         return py_array;
3301 }
3302
3303 static int py_srvsvc_NetSessCtr10_set_array(PyObject *py_obj, PyObject *value, void *closure)
3304 {
3305         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(py_obj);
3306         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3307         if (value == Py_None) {
3308                 object->array = NULL;
3309         } else {
3310                 object->array = NULL;
3311                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3312                 {
3313                         int array_cntr_1;
3314                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3315                         if (!object->array) { return -1;; }
3316                         talloc_set_name_const(object->array, "ARRAY: object->array");
3317                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3318                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo10_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3319                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3320                                         PyErr_NoMemory();
3321                                         return -1;
3322                                 }
3323                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3324                         }
3325                 }
3326         }
3327         return 0;
3328 }
3329
3330 static PyGetSetDef py_srvsvc_NetSessCtr10_getsetters[] = {
3331         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr10_get_count, py_srvsvc_NetSessCtr10_set_count },
3332         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr10_get_array, py_srvsvc_NetSessCtr10_set_array },
3333         { NULL }
3334 };
3335
3336 static PyObject *py_srvsvc_NetSessCtr10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3337 {
3338         return pytalloc_new(struct srvsvc_NetSessCtr10, type);
3339 }
3340
3341
3342 static PyTypeObject srvsvc_NetSessCtr10_Type = {
3343         PyObject_HEAD_INIT(NULL) 0,
3344         .tp_name = "srvsvc.NetSessCtr10",
3345         .tp_getset = py_srvsvc_NetSessCtr10_getsetters,
3346         .tp_methods = NULL,
3347         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3348         .tp_basicsize = sizeof(pytalloc_Object),
3349         .tp_new = py_srvsvc_NetSessCtr10_new,
3350 };
3351
3352
3353 static PyObject *py_srvsvc_NetSessInfo502_get_client(PyObject *obj, void *closure)
3354 {
3355         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3356         PyObject *py_client;
3357         if (object->client == NULL) {
3358                 py_client = Py_None;
3359                 Py_INCREF(py_client);
3360         } else {
3361                 if (object->client == NULL) {
3362                         py_client = Py_None;
3363                         Py_INCREF(py_client);
3364                 } else {
3365                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
3366                 }
3367         }
3368         return py_client;
3369 }
3370
3371 static int py_srvsvc_NetSessInfo502_set_client(PyObject *py_obj, PyObject *value, void *closure)
3372 {
3373         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3374         if (value == Py_None) {
3375                 object->client = NULL;
3376         } else {
3377                 object->client = NULL;
3378                 if (PyUnicode_Check(value)) {
3379                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3380                 } else if (PyString_Check(value)) {
3381                         object->client = PyString_AS_STRING(value);
3382                 } else {
3383                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3384                         return -1;
3385                 }
3386         }
3387         return 0;
3388 }
3389
3390 static PyObject *py_srvsvc_NetSessInfo502_get_user(PyObject *obj, void *closure)
3391 {
3392         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3393         PyObject *py_user;
3394         if (object->user == NULL) {
3395                 py_user = Py_None;
3396                 Py_INCREF(py_user);
3397         } else {
3398                 if (object->user == NULL) {
3399                         py_user = Py_None;
3400                         Py_INCREF(py_user);
3401                 } else {
3402                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
3403                 }
3404         }
3405         return py_user;
3406 }
3407
3408 static int py_srvsvc_NetSessInfo502_set_user(PyObject *py_obj, PyObject *value, void *closure)
3409 {
3410         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3411         if (value == Py_None) {
3412                 object->user = NULL;
3413         } else {
3414                 object->user = NULL;
3415                 if (PyUnicode_Check(value)) {
3416                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3417                 } else if (PyString_Check(value)) {
3418                         object->user = PyString_AS_STRING(value);
3419                 } else {
3420                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3421                         return -1;
3422                 }
3423         }
3424         return 0;
3425 }
3426
3427 static PyObject *py_srvsvc_NetSessInfo502_get_num_open(PyObject *obj, void *closure)
3428 {
3429         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3430         PyObject *py_num_open;
3431         py_num_open = PyInt_FromLong(object->num_open);
3432         return py_num_open;
3433 }
3434
3435 static int py_srvsvc_NetSessInfo502_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
3436 {
3437         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3438         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3439         object->num_open = PyInt_AsLong(value);
3440         return 0;
3441 }
3442
3443 static PyObject *py_srvsvc_NetSessInfo502_get_time(PyObject *obj, void *closure)
3444 {
3445         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3446         PyObject *py_time;
3447         py_time = PyInt_FromLong(object->time);
3448         return py_time;
3449 }
3450
3451 static int py_srvsvc_NetSessInfo502_set_time(PyObject *py_obj, PyObject *value, void *closure)
3452 {
3453         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3454         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3455         object->time = PyInt_AsLong(value);
3456         return 0;
3457 }
3458
3459 static PyObject *py_srvsvc_NetSessInfo502_get_idle_time(PyObject *obj, void *closure)
3460 {
3461         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3462         PyObject *py_idle_time;
3463         py_idle_time = PyInt_FromLong(object->idle_time);
3464         return py_idle_time;
3465 }
3466
3467 static int py_srvsvc_NetSessInfo502_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
3468 {
3469         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3470         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3471         object->idle_time = PyInt_AsLong(value);
3472         return 0;
3473 }
3474
3475 static PyObject *py_srvsvc_NetSessInfo502_get_user_flags(PyObject *obj, void *closure)
3476 {
3477         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3478         PyObject *py_user_flags;
3479         py_user_flags = PyInt_FromLong(object->user_flags);
3480         return py_user_flags;
3481 }
3482
3483 static int py_srvsvc_NetSessInfo502_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
3484 {
3485         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3486         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3487         object->user_flags = PyInt_AsLong(value);
3488         return 0;
3489 }
3490
3491 static PyObject *py_srvsvc_NetSessInfo502_get_client_type(PyObject *obj, void *closure)
3492 {
3493         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3494         PyObject *py_client_type;
3495         if (object->client_type == NULL) {
3496                 py_client_type = Py_None;
3497                 Py_INCREF(py_client_type);
3498         } else {
3499                 if (object->client_type == NULL) {
3500                         py_client_type = Py_None;
3501                         Py_INCREF(py_client_type);
3502                 } else {
3503                         py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
3504                 }
3505         }
3506         return py_client_type;
3507 }
3508
3509 static int py_srvsvc_NetSessInfo502_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
3510 {
3511         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3512         if (value == Py_None) {
3513                 object->client_type = NULL;
3514         } else {
3515                 object->client_type = NULL;
3516                 if (PyUnicode_Check(value)) {
3517                         object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3518                 } else if (PyString_Check(value)) {
3519                         object->client_type = PyString_AS_STRING(value);
3520                 } else {
3521                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3522                         return -1;
3523                 }
3524         }
3525         return 0;
3526 }
3527
3528 static PyObject *py_srvsvc_NetSessInfo502_get_transport(PyObject *obj, void *closure)
3529 {
3530         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3531         PyObject *py_transport;
3532         if (object->transport == NULL) {
3533                 py_transport = Py_None;
3534                 Py_INCREF(py_transport);
3535         } else {
3536                 if (object->transport == NULL) {
3537                         py_transport = Py_None;
3538                         Py_INCREF(py_transport);
3539                 } else {
3540                         py_transport = PyUnicode_Decode(object->transport, strlen(object->transport), "utf-8", "ignore");
3541                 }
3542         }
3543         return py_transport;
3544 }
3545
3546 static int py_srvsvc_NetSessInfo502_set_transport(PyObject *py_obj, PyObject *value, void *closure)
3547 {
3548         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3549         if (value == Py_None) {
3550                 object->transport = NULL;
3551         } else {
3552                 object->transport = NULL;
3553                 if (PyUnicode_Check(value)) {
3554                         object->transport = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3555                 } else if (PyString_Check(value)) {
3556                         object->transport = PyString_AS_STRING(value);
3557                 } else {
3558                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3559                         return -1;
3560                 }
3561         }
3562         return 0;
3563 }
3564
3565 static PyGetSetDef py_srvsvc_NetSessInfo502_getsetters[] = {
3566         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo502_get_client, py_srvsvc_NetSessInfo502_set_client },
3567         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo502_get_user, py_srvsvc_NetSessInfo502_set_user },
3568         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo502_get_num_open, py_srvsvc_NetSessInfo502_set_num_open },
3569         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo502_get_time, py_srvsvc_NetSessInfo502_set_time },
3570         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo502_get_idle_time, py_srvsvc_NetSessInfo502_set_idle_time },
3571         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo502_get_user_flags, py_srvsvc_NetSessInfo502_set_user_flags },
3572         { discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo502_get_client_type, py_srvsvc_NetSessInfo502_set_client_type },
3573         { discard_const_p(char, "transport"), py_srvsvc_NetSessInfo502_get_transport, py_srvsvc_NetSessInfo502_set_transport },
3574         { NULL }
3575 };
3576
3577 static PyObject *py_srvsvc_NetSessInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3578 {
3579         return pytalloc_new(struct srvsvc_NetSessInfo502, type);
3580 }
3581
3582
3583 static PyTypeObject srvsvc_NetSessInfo502_Type = {
3584         PyObject_HEAD_INIT(NULL) 0,
3585         .tp_name = "srvsvc.NetSessInfo502",
3586         .tp_getset = py_srvsvc_NetSessInfo502_getsetters,
3587         .tp_methods = NULL,
3588         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3589         .tp_basicsize = sizeof(pytalloc_Object),
3590         .tp_new = py_srvsvc_NetSessInfo502_new,
3591 };
3592
3593
3594 static PyObject *py_srvsvc_NetSessCtr502_get_count(PyObject *obj, void *closure)
3595 {
3596         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
3597         PyObject *py_count;
3598         py_count = PyInt_FromLong(object->count);
3599         return py_count;
3600 }
3601
3602 static int py_srvsvc_NetSessCtr502_set_count(PyObject *py_obj, PyObject *value, void *closure)
3603 {
3604         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(py_obj);
3605         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3606         object->count = PyInt_AsLong(value);
3607         return 0;
3608 }
3609
3610 static PyObject *py_srvsvc_NetSessCtr502_get_array(PyObject *obj, void *closure)
3611 {
3612         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
3613         PyObject *py_array;
3614         if (object->array == NULL) {
3615                 py_array = Py_None;
3616                 Py_INCREF(py_array);
3617         } else {
3618                 py_array = PyList_New(object->count);
3619                 if (py_array == NULL) {
3620                         return NULL;
3621                 }
3622                 {
3623                         int array_cntr_1;
3624                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3625                                 PyObject *py_array_1;
3626                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo502_Type, object->array, &object->array[array_cntr_1]);
3627                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3628                         }
3629                 }
3630         }
3631         return py_array;
3632 }
3633
3634 static int py_srvsvc_NetSessCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
3635 {
3636         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(py_obj);
3637         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3638         if (value == Py_None) {
3639                 object->array = NULL;
3640         } else {
3641                 object->array = NULL;
3642                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3643                 {
3644                         int array_cntr_1;
3645                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3646                         if (!object->array) { return -1;; }
3647                         talloc_set_name_const(object->array, "ARRAY: object->array");
3648                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3649                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3650                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3651                                         PyErr_NoMemory();
3652                                         return -1;
3653                                 }
3654                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3655                         }
3656                 }
3657         }
3658         return 0;
3659 }
3660
3661 static PyGetSetDef py_srvsvc_NetSessCtr502_getsetters[] = {
3662         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr502_get_count, py_srvsvc_NetSessCtr502_set_count },
3663         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr502_get_array, py_srvsvc_NetSessCtr502_set_array },
3664         { NULL }
3665 };
3666
3667 static PyObject *py_srvsvc_NetSessCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3668 {
3669         return pytalloc_new(struct srvsvc_NetSessCtr502, type);
3670 }
3671
3672
3673 static PyTypeObject srvsvc_NetSessCtr502_Type = {
3674         PyObject_HEAD_INIT(NULL) 0,
3675         .tp_name = "srvsvc.NetSessCtr502",
3676         .tp_getset = py_srvsvc_NetSessCtr502_getsetters,
3677         .tp_methods = NULL,
3678         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3679         .tp_basicsize = sizeof(pytalloc_Object),
3680         .tp_new = py_srvsvc_NetSessCtr502_new,
3681 };
3682
3683 static PyObject *py_import_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSessCtr *in)
3684 {
3685         PyObject *ret;
3686
3687         switch (level) {
3688                 case 0:
3689                         if (in->ctr0 == NULL) {
3690                                 ret = Py_None;
3691                                 Py_INCREF(ret);
3692                         } else {
3693                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr0_Type, in->ctr0, in->ctr0);
3694                         }
3695                         return ret;
3696
3697                 case 1:
3698                         if (in->ctr1 == NULL) {
3699                                 ret = Py_None;
3700                                 Py_INCREF(ret);
3701                         } else {
3702                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr1_Type, in->ctr1, in->ctr1);
3703                         }
3704                         return ret;
3705
3706                 case 2:
3707                         if (in->ctr2 == NULL) {
3708                                 ret = Py_None;
3709                                 Py_INCREF(ret);
3710                         } else {
3711                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr2_Type, in->ctr2, in->ctr2);
3712                         }
3713                         return ret;
3714
3715                 case 10:
3716                         if (in->ctr10 == NULL) {
3717                                 ret = Py_None;
3718                                 Py_INCREF(ret);
3719                         } else {
3720                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr10_Type, in->ctr10, in->ctr10);
3721                         }
3722                         return ret;
3723
3724                 case 502:
3725                         if (in->ctr502 == NULL) {
3726                                 ret = Py_None;
3727                                 Py_INCREF(ret);
3728                         } else {
3729                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr502_Type, in->ctr502, in->ctr502);
3730                         }
3731                         return ret;
3732
3733                 default:
3734                         ret = Py_None;
3735                         Py_INCREF(ret);
3736                         return ret;
3737
3738         }
3739         PyErr_SetString(PyExc_TypeError, "unknown union level");
3740         return NULL;
3741 }
3742
3743 static union srvsvc_NetSessCtr *py_export_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
3744 {
3745         union srvsvc_NetSessCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetSessCtr);
3746         switch (level) {
3747                 case 0:
3748                         if (in == Py_None) {
3749                                 ret->ctr0 = NULL;
3750                         } else {
3751                                 ret->ctr0 = NULL;
3752                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr0_Type, in, talloc_free(ret); return NULL;);
3753                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3754                                         PyErr_NoMemory();
3755                                         talloc_free(ret); return NULL;
3756                                 }
3757                                 ret->ctr0 = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(in);
3758                         }
3759                         break;
3760
3761                 case 1:
3762                         if (in == Py_None) {
3763                                 ret->ctr1 = NULL;
3764                         } else {
3765                                 ret->ctr1 = NULL;
3766                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr1_Type, in, talloc_free(ret); return NULL;);
3767                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3768                                         PyErr_NoMemory();
3769                                         talloc_free(ret); return NULL;
3770                                 }
3771                                 ret->ctr1 = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(in);
3772                         }
3773                         break;
3774
3775                 case 2:
3776                         if (in == Py_None) {
3777                                 ret->ctr2 = NULL;
3778                         } else {
3779                                 ret->ctr2 = NULL;
3780                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr2_Type, in, talloc_free(ret); return NULL;);
3781                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3782                                         PyErr_NoMemory();
3783                                         talloc_free(ret); return NULL;
3784                                 }
3785                                 ret->ctr2 = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(in);
3786                         }
3787                         break;
3788
3789                 case 10:
3790                         if (in == Py_None) {
3791                                 ret->ctr10 = NULL;
3792                         } else {
3793                                 ret->ctr10 = NULL;
3794                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr10_Type, in, talloc_free(ret); return NULL;);
3795                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3796                                         PyErr_NoMemory();
3797                                         talloc_free(ret); return NULL;
3798                                 }
3799                                 ret->ctr10 = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(in);
3800                         }
3801                         break;
3802
3803                 case 502:
3804                         if (in == Py_None) {
3805                                 ret->ctr502 = NULL;
3806                         } else {
3807                                 ret->ctr502 = NULL;
3808                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr502_Type, in, talloc_free(ret); return NULL;);
3809                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3810                                         PyErr_NoMemory();
3811                                         talloc_free(ret); return NULL;
3812                                 }
3813                                 ret->ctr502 = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(in);
3814                         }
3815                         break;
3816
3817                 default:
3818                         break;
3819
3820         }
3821
3822         return ret;
3823 }
3824
3825
3826 static PyObject *py_srvsvc_NetSessInfoCtr_get_level(PyObject *obj, void *closure)
3827 {
3828         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
3829         PyObject *py_level;
3830         py_level = PyInt_FromLong(object->level);
3831         return py_level;
3832 }
3833
3834 static int py_srvsvc_NetSessInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
3835 {
3836         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_obj);
3837         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3838         object->level = PyInt_AsLong(value);
3839         return 0;
3840 }
3841
3842 static PyObject *py_srvsvc_NetSessInfoCtr_get_ctr(PyObject *obj, void *closure)
3843 {
3844         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
3845         PyObject *py_ctr;
3846         py_ctr = py_import_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
3847         if (py_ctr == NULL) {
3848                 return NULL;
3849         }
3850         return py_ctr;
3851 }
3852
3853 static int py_srvsvc_NetSessInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
3854 {
3855         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_obj);
3856         {
3857                 union srvsvc_NetSessCtr *ctr_switch_0;
3858                 ctr_switch_0 = py_export_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
3859                 if (ctr_switch_0 == NULL) {
3860                         return -1;
3861                 }
3862                 object->ctr = *ctr_switch_0;
3863         }
3864         return 0;
3865 }
3866
3867 static PyGetSetDef py_srvsvc_NetSessInfoCtr_getsetters[] = {
3868         { discard_const_p(char, "level"), py_srvsvc_NetSessInfoCtr_get_level, py_srvsvc_NetSessInfoCtr_set_level },
3869         { discard_const_p(char, "ctr"), py_srvsvc_NetSessInfoCtr_get_ctr, py_srvsvc_NetSessInfoCtr_set_ctr },
3870         { NULL }
3871 };
3872
3873 static PyObject *py_srvsvc_NetSessInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3874 {
3875         return pytalloc_new(struct srvsvc_NetSessInfoCtr, type);
3876 }
3877
3878
3879 static PyTypeObject srvsvc_NetSessInfoCtr_Type = {
3880         PyObject_HEAD_INIT(NULL) 0,
3881         .tp_name = "srvsvc.NetSessInfoCtr",
3882         .tp_getset = py_srvsvc_NetSessInfoCtr_getsetters,
3883         .tp_methods = NULL,
3884         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3885         .tp_basicsize = sizeof(pytalloc_Object),
3886         .tp_new = py_srvsvc_NetSessInfoCtr_new,
3887 };
3888
3889
3890 static PyObject *py_srvsvc_NetShareInfo0_get_name(PyObject *obj, void *closure)
3891 {
3892         struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(obj);
3893         PyObject *py_name;
3894         if (object->name == NULL) {
3895                 py_name = Py_None;
3896                 Py_INCREF(py_name);
3897         } else {
3898                 if (object->name == NULL) {
3899                         py_name = Py_None;
3900                         Py_INCREF(py_name);
3901                 } else {
3902                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
3903                 }
3904         }
3905         return py_name;
3906 }
3907
3908 static int py_srvsvc_NetShareInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
3909 {
3910         struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(py_obj);
3911         if (value == Py_None) {
3912                 object->name = NULL;
3913         } else {
3914                 object->name = NULL;
3915                 if (PyUnicode_Check(value)) {
3916                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3917                 } else if (PyString_Check(value)) {
3918                         object->name = PyString_AS_STRING(value);
3919                 } else {
3920                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3921                         return -1;
3922                 }
3923         }
3924         return 0;
3925 }
3926
3927 static PyGetSetDef py_srvsvc_NetShareInfo0_getsetters[] = {
3928         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo0_get_name, py_srvsvc_NetShareInfo0_set_name },
3929         { NULL }
3930 };
3931
3932 static PyObject *py_srvsvc_NetShareInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3933 {
3934         return pytalloc_new(struct srvsvc_NetShareInfo0, type);
3935 }
3936
3937
3938 static PyTypeObject srvsvc_NetShareInfo0_Type = {
3939         PyObject_HEAD_INIT(NULL) 0,
3940         .tp_name = "srvsvc.NetShareInfo0",
3941         .tp_getset = py_srvsvc_NetShareInfo0_getsetters,
3942         .tp_methods = NULL,
3943         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3944         .tp_basicsize = sizeof(pytalloc_Object),
3945         .tp_new = py_srvsvc_NetShareInfo0_new,
3946 };
3947
3948
3949 static PyObject *py_srvsvc_NetShareCtr0_get_count(PyObject *obj, void *closure)
3950 {
3951         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
3952         PyObject *py_count;
3953         py_count = PyInt_FromLong(object->count);
3954         return py_count;
3955 }
3956
3957 static int py_srvsvc_NetShareCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
3958 {
3959         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(py_obj);
3960         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3961         object->count = PyInt_AsLong(value);
3962         return 0;
3963 }
3964
3965 static PyObject *py_srvsvc_NetShareCtr0_get_array(PyObject *obj, void *closure)
3966 {
3967         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
3968         PyObject *py_array;
3969         if (object->array == NULL) {
3970                 py_array = Py_None;
3971                 Py_INCREF(py_array);
3972         } else {
3973                 py_array = PyList_New(object->count);
3974                 if (py_array == NULL) {
3975                         return NULL;
3976                 }
3977                 {
3978                         int array_cntr_1;
3979                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3980                                 PyObject *py_array_1;
3981                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo0_Type, object->array, &object->array[array_cntr_1]);
3982                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3983                         }
3984                 }
3985         }
3986         return py_array;
3987 }
3988
3989 static int py_srvsvc_NetShareCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
3990 {
3991         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(py_obj);
3992         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3993         if (value == Py_None) {
3994                 object->array = NULL;
3995         } else {
3996                 object->array = NULL;
3997                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3998                 {
3999                         int array_cntr_1;
4000                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4001                         if (!object->array) { return -1;; }
4002                         talloc_set_name_const(object->array, "ARRAY: object->array");
4003                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4004                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4005                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4006                                         PyErr_NoMemory();
4007                                         return -1;
4008                                 }
4009                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4010                         }
4011                 }
4012         }
4013         return 0;
4014 }
4015
4016 static PyGetSetDef py_srvsvc_NetShareCtr0_getsetters[] = {
4017         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr0_get_count, py_srvsvc_NetShareCtr0_set_count },
4018         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr0_get_array, py_srvsvc_NetShareCtr0_set_array },
4019         { NULL }
4020 };
4021
4022 static PyObject *py_srvsvc_NetShareCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4023 {
4024         return pytalloc_new(struct srvsvc_NetShareCtr0, type);
4025 }
4026
4027
4028 static PyTypeObject srvsvc_NetShareCtr0_Type = {
4029         PyObject_HEAD_INIT(NULL) 0,
4030         .tp_name = "srvsvc.NetShareCtr0",
4031         .tp_getset = py_srvsvc_NetShareCtr0_getsetters,
4032         .tp_methods = NULL,
4033         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4034         .tp_basicsize = sizeof(pytalloc_Object),
4035         .tp_new = py_srvsvc_NetShareCtr0_new,
4036 };
4037
4038
4039 static PyObject *py_srvsvc_NetShareInfo1_get_name(PyObject *obj, void *closure)
4040 {
4041         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4042         PyObject *py_name;
4043         if (object->name == NULL) {
4044                 py_name = Py_None;
4045                 Py_INCREF(py_name);
4046         } else {
4047                 if (object->name == NULL) {
4048                         py_name = Py_None;
4049                         Py_INCREF(py_name);
4050                 } else {
4051                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4052                 }
4053         }
4054         return py_name;
4055 }
4056
4057 static int py_srvsvc_NetShareInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
4058 {
4059         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4060         if (value == Py_None) {
4061                 object->name = NULL;
4062         } else {
4063                 object->name = NULL;
4064                 if (PyUnicode_Check(value)) {
4065                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4066                 } else if (PyString_Check(value)) {
4067                         object->name = PyString_AS_STRING(value);
4068                 } else {
4069                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4070                         return -1;
4071                 }
4072         }
4073         return 0;
4074 }
4075
4076 static PyObject *py_srvsvc_NetShareInfo1_get_type(PyObject *obj, void *closure)
4077 {
4078         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4079         PyObject *py_type;
4080         py_type = PyInt_FromLong(object->type);
4081         return py_type;
4082 }
4083
4084 static int py_srvsvc_NetShareInfo1_set_type(PyObject *py_obj, PyObject *value, void *closure)
4085 {
4086         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4087         if (PyLong_Check(value)) {
4088                 object->type = PyLong_AsLongLong(value);
4089         } else if (PyInt_Check(value)) {
4090                 object->type = PyInt_AsLong(value);
4091         } else {
4092                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4093                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4094                 return -1;
4095         }
4096         return 0;
4097 }
4098
4099 static PyObject *py_srvsvc_NetShareInfo1_get_comment(PyObject *obj, void *closure)
4100 {
4101         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4102         PyObject *py_comment;
4103         if (object->comment == NULL) {
4104                 py_comment = Py_None;
4105                 Py_INCREF(py_comment);
4106         } else {
4107                 if (object->comment == NULL) {
4108                         py_comment = Py_None;
4109                         Py_INCREF(py_comment);
4110                 } else {
4111                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4112                 }
4113         }
4114         return py_comment;
4115 }
4116
4117 static int py_srvsvc_NetShareInfo1_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4118 {
4119         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4120         if (value == Py_None) {
4121                 object->comment = NULL;
4122         } else {
4123                 object->comment = NULL;
4124                 if (PyUnicode_Check(value)) {
4125                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4126                 } else if (PyString_Check(value)) {
4127                         object->comment = PyString_AS_STRING(value);
4128                 } else {
4129                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4130                         return -1;
4131                 }
4132         }
4133         return 0;
4134 }
4135
4136 static PyGetSetDef py_srvsvc_NetShareInfo1_getsetters[] = {
4137         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo1_get_name, py_srvsvc_NetShareInfo1_set_name },
4138         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo1_get_type, py_srvsvc_NetShareInfo1_set_type },
4139         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1_get_comment, py_srvsvc_NetShareInfo1_set_comment },
4140         { NULL }
4141 };
4142
4143 static PyObject *py_srvsvc_NetShareInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4144 {
4145         return pytalloc_new(struct srvsvc_NetShareInfo1, type);
4146 }
4147
4148
4149 static PyTypeObject srvsvc_NetShareInfo1_Type = {
4150         PyObject_HEAD_INIT(NULL) 0,
4151         .tp_name = "srvsvc.NetShareInfo1",
4152         .tp_getset = py_srvsvc_NetShareInfo1_getsetters,
4153         .tp_methods = NULL,
4154         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4155         .tp_basicsize = sizeof(pytalloc_Object),
4156         .tp_new = py_srvsvc_NetShareInfo1_new,
4157 };
4158
4159
4160 static PyObject *py_srvsvc_NetShareCtr1_get_count(PyObject *obj, void *closure)
4161 {
4162         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
4163         PyObject *py_count;
4164         py_count = PyInt_FromLong(object->count);
4165         return py_count;
4166 }
4167
4168 static int py_srvsvc_NetShareCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
4169 {
4170         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(py_obj);
4171         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4172         object->count = PyInt_AsLong(value);
4173         return 0;
4174 }
4175
4176 static PyObject *py_srvsvc_NetShareCtr1_get_array(PyObject *obj, void *closure)
4177 {
4178         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
4179         PyObject *py_array;
4180         if (object->array == NULL) {
4181                 py_array = Py_None;
4182                 Py_INCREF(py_array);
4183         } else {
4184                 py_array = PyList_New(object->count);
4185                 if (py_array == NULL) {
4186                         return NULL;
4187                 }
4188                 {
4189                         int array_cntr_1;
4190                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4191                                 PyObject *py_array_1;
4192                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1_Type, object->array, &object->array[array_cntr_1]);
4193                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4194                         }
4195                 }
4196         }
4197         return py_array;
4198 }
4199
4200 static int py_srvsvc_NetShareCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
4201 {
4202         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(py_obj);
4203         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4204         if (value == Py_None) {
4205                 object->array = NULL;
4206         } else {
4207                 object->array = NULL;
4208                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4209                 {
4210                         int array_cntr_1;
4211                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4212                         if (!object->array) { return -1;; }
4213                         talloc_set_name_const(object->array, "ARRAY: object->array");
4214                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4215                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4216                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4217                                         PyErr_NoMemory();
4218                                         return -1;
4219                                 }
4220                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4221                         }
4222                 }
4223         }
4224         return 0;
4225 }
4226
4227 static PyGetSetDef py_srvsvc_NetShareCtr1_getsetters[] = {
4228         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1_get_count, py_srvsvc_NetShareCtr1_set_count },
4229         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1_get_array, py_srvsvc_NetShareCtr1_set_array },
4230         { NULL }
4231 };
4232
4233 static PyObject *py_srvsvc_NetShareCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4234 {
4235         return pytalloc_new(struct srvsvc_NetShareCtr1, type);
4236 }
4237
4238
4239 static PyTypeObject srvsvc_NetShareCtr1_Type = {
4240         PyObject_HEAD_INIT(NULL) 0,
4241         .tp_name = "srvsvc.NetShareCtr1",
4242         .tp_getset = py_srvsvc_NetShareCtr1_getsetters,
4243         .tp_methods = NULL,
4244         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4245         .tp_basicsize = sizeof(pytalloc_Object),
4246         .tp_new = py_srvsvc_NetShareCtr1_new,
4247 };
4248
4249
4250 static PyObject *py_srvsvc_NetShareInfo2_get_name(PyObject *obj, void *closure)
4251 {
4252         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4253         PyObject *py_name;
4254         if (object->name == NULL) {
4255                 py_name = Py_None;
4256                 Py_INCREF(py_name);
4257         } else {
4258                 if (object->name == NULL) {
4259                         py_name = Py_None;
4260                         Py_INCREF(py_name);
4261                 } else {
4262                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4263                 }
4264         }
4265         return py_name;
4266 }
4267
4268 static int py_srvsvc_NetShareInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
4269 {
4270         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4271         if (value == Py_None) {
4272                 object->name = NULL;
4273         } else {
4274                 object->name = NULL;
4275                 if (PyUnicode_Check(value)) {
4276                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4277                 } else if (PyString_Check(value)) {
4278                         object->name = PyString_AS_STRING(value);
4279                 } else {
4280                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4281                         return -1;
4282                 }
4283         }
4284         return 0;
4285 }
4286
4287 static PyObject *py_srvsvc_NetShareInfo2_get_type(PyObject *obj, void *closure)
4288 {
4289         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4290         PyObject *py_type;
4291         py_type = PyInt_FromLong(object->type);
4292         return py_type;
4293 }
4294
4295 static int py_srvsvc_NetShareInfo2_set_type(PyObject *py_obj, PyObject *value, void *closure)
4296 {
4297         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4298         if (PyLong_Check(value)) {
4299                 object->type = PyLong_AsLongLong(value);
4300         } else if (PyInt_Check(value)) {
4301                 object->type = PyInt_AsLong(value);
4302         } else {
4303                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4304                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4305                 return -1;
4306         }
4307         return 0;
4308 }
4309
4310 static PyObject *py_srvsvc_NetShareInfo2_get_comment(PyObject *obj, void *closure)
4311 {
4312         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4313         PyObject *py_comment;
4314         if (object->comment == NULL) {
4315                 py_comment = Py_None;
4316                 Py_INCREF(py_comment);
4317         } else {
4318                 if (object->comment == NULL) {
4319                         py_comment = Py_None;
4320                         Py_INCREF(py_comment);
4321                 } else {
4322                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4323                 }
4324         }
4325         return py_comment;
4326 }
4327
4328 static int py_srvsvc_NetShareInfo2_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4329 {
4330         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4331         if (value == Py_None) {
4332                 object->comment = NULL;
4333         } else {
4334                 object->comment = NULL;
4335                 if (PyUnicode_Check(value)) {
4336                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4337                 } else if (PyString_Check(value)) {
4338                         object->comment = PyString_AS_STRING(value);
4339                 } else {
4340                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4341                         return -1;
4342                 }
4343         }
4344         return 0;
4345 }
4346
4347 static PyObject *py_srvsvc_NetShareInfo2_get_permissions(PyObject *obj, void *closure)
4348 {
4349         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4350         PyObject *py_permissions;
4351         py_permissions = PyInt_FromLong(object->permissions);
4352         return py_permissions;
4353 }
4354
4355 static int py_srvsvc_NetShareInfo2_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
4356 {
4357         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4358         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4359         object->permissions = PyInt_AsLong(value);
4360         return 0;
4361 }
4362
4363 static PyObject *py_srvsvc_NetShareInfo2_get_max_users(PyObject *obj, void *closure)
4364 {
4365         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4366         PyObject *py_max_users;
4367         py_max_users = PyInt_FromLong(object->max_users);
4368         return py_max_users;
4369 }
4370
4371 static int py_srvsvc_NetShareInfo2_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
4372 {
4373         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4374         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4375         object->max_users = PyInt_AsLong(value);
4376         return 0;
4377 }
4378
4379 static PyObject *py_srvsvc_NetShareInfo2_get_current_users(PyObject *obj, void *closure)
4380 {
4381         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4382         PyObject *py_current_users;
4383         py_current_users = PyInt_FromLong(object->current_users);
4384         return py_current_users;
4385 }
4386
4387 static int py_srvsvc_NetShareInfo2_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
4388 {
4389         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4390         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4391         object->current_users = PyInt_AsLong(value);
4392         return 0;
4393 }
4394
4395 static PyObject *py_srvsvc_NetShareInfo2_get_path(PyObject *obj, void *closure)
4396 {
4397         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4398         PyObject *py_path;
4399         if (object->path == NULL) {
4400                 py_path = Py_None;
4401                 Py_INCREF(py_path);
4402         } else {
4403                 if (object->path == NULL) {
4404                         py_path = Py_None;
4405                         Py_INCREF(py_path);
4406                 } else {
4407                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
4408                 }
4409         }
4410         return py_path;
4411 }
4412
4413 static int py_srvsvc_NetShareInfo2_set_path(PyObject *py_obj, PyObject *value, void *closure)
4414 {
4415         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4416         if (value == Py_None) {
4417                 object->path = NULL;
4418         } else {
4419                 object->path = NULL;
4420                 if (PyUnicode_Check(value)) {
4421                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4422                 } else if (PyString_Check(value)) {
4423                         object->path = PyString_AS_STRING(value);
4424                 } else {
4425                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4426                         return -1;
4427                 }
4428         }
4429         return 0;
4430 }
4431
4432 static PyObject *py_srvsvc_NetShareInfo2_get_password(PyObject *obj, void *closure)
4433 {
4434         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4435         PyObject *py_password;
4436         if (object->password == NULL) {
4437                 py_password = Py_None;
4438                 Py_INCREF(py_password);
4439         } else {
4440                 if (object->password == NULL) {
4441                         py_password = Py_None;
4442                         Py_INCREF(py_password);
4443                 } else {
4444                         py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
4445                 }
4446         }
4447         return py_password;
4448 }
4449
4450 static int py_srvsvc_NetShareInfo2_set_password(PyObject *py_obj, PyObject *value, void *closure)
4451 {
4452         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4453         if (value == Py_None) {
4454                 object->password = NULL;
4455         } else {
4456                 object->password = NULL;
4457                 if (PyUnicode_Check(value)) {
4458                         object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4459                 } else if (PyString_Check(value)) {
4460                         object->password = PyString_AS_STRING(value);
4461                 } else {
4462                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4463                         return -1;
4464                 }
4465         }
4466         return 0;
4467 }
4468
4469 static PyGetSetDef py_srvsvc_NetShareInfo2_getsetters[] = {
4470         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo2_get_name, py_srvsvc_NetShareInfo2_set_name },
4471         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo2_get_type, py_srvsvc_NetShareInfo2_set_type },
4472         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo2_get_comment, py_srvsvc_NetShareInfo2_set_comment },
4473         { discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo2_get_permissions, py_srvsvc_NetShareInfo2_set_permissions },
4474         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo2_get_max_users, py_srvsvc_NetShareInfo2_set_max_users },
4475         { discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo2_get_current_users, py_srvsvc_NetShareInfo2_set_current_users },
4476         { discard_const_p(char, "path"), py_srvsvc_NetShareInfo2_get_path, py_srvsvc_NetShareInfo2_set_path },
4477         { discard_const_p(char, "password"), py_srvsvc_NetShareInfo2_get_password, py_srvsvc_NetShareInfo2_set_password },
4478         { NULL }
4479 };
4480
4481 static PyObject *py_srvsvc_NetShareInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4482 {
4483         return pytalloc_new(struct srvsvc_NetShareInfo2, type);
4484 }
4485
4486
4487 static PyTypeObject srvsvc_NetShareInfo2_Type = {
4488         PyObject_HEAD_INIT(NULL) 0,
4489         .tp_name = "srvsvc.NetShareInfo2",
4490         .tp_getset = py_srvsvc_NetShareInfo2_getsetters,
4491         .tp_methods = NULL,
4492         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4493         .tp_basicsize = sizeof(pytalloc_Object),
4494         .tp_new = py_srvsvc_NetShareInfo2_new,
4495 };
4496
4497
4498 static PyObject *py_srvsvc_NetShareCtr2_get_count(PyObject *obj, void *closure)
4499 {
4500         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
4501         PyObject *py_count;
4502         py_count = PyInt_FromLong(object->count);
4503         return py_count;
4504 }
4505
4506 static int py_srvsvc_NetShareCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
4507 {
4508         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(py_obj);
4509         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4510         object->count = PyInt_AsLong(value);
4511         return 0;
4512 }
4513
4514 static PyObject *py_srvsvc_NetShareCtr2_get_array(PyObject *obj, void *closure)
4515 {
4516         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
4517         PyObject *py_array;
4518         if (object->array == NULL) {
4519                 py_array = Py_None;
4520                 Py_INCREF(py_array);
4521         } else {
4522                 py_array = PyList_New(object->count);
4523                 if (py_array == NULL) {
4524                         return NULL;
4525                 }
4526                 {
4527                         int array_cntr_1;
4528                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4529                                 PyObject *py_array_1;
4530                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo2_Type, object->array, &object->array[array_cntr_1]);
4531                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4532                         }
4533                 }
4534         }
4535         return py_array;
4536 }
4537
4538 static int py_srvsvc_NetShareCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
4539 {
4540         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(py_obj);
4541         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4542         if (value == Py_None) {
4543                 object->array = NULL;
4544         } else {
4545                 object->array = NULL;
4546                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4547                 {
4548                         int array_cntr_1;
4549                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4550                         if (!object->array) { return -1;; }
4551                         talloc_set_name_const(object->array, "ARRAY: object->array");
4552                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4553                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4554                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4555                                         PyErr_NoMemory();
4556                                         return -1;
4557                                 }
4558                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4559                         }
4560                 }
4561         }
4562         return 0;
4563 }
4564
4565 static PyGetSetDef py_srvsvc_NetShareCtr2_getsetters[] = {
4566         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr2_get_count, py_srvsvc_NetShareCtr2_set_count },
4567         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr2_get_array, py_srvsvc_NetShareCtr2_set_array },
4568         { NULL }
4569 };
4570
4571 static PyObject *py_srvsvc_NetShareCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4572 {
4573         return pytalloc_new(struct srvsvc_NetShareCtr2, type);
4574 }
4575
4576
4577 static PyTypeObject srvsvc_NetShareCtr2_Type = {
4578         PyObject_HEAD_INIT(NULL) 0,
4579         .tp_name = "srvsvc.NetShareCtr2",
4580         .tp_getset = py_srvsvc_NetShareCtr2_getsetters,
4581         .tp_methods = NULL,
4582         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4583         .tp_basicsize = sizeof(pytalloc_Object),
4584         .tp_new = py_srvsvc_NetShareCtr2_new,
4585 };
4586
4587
4588 static PyObject *py_srvsvc_NetShareInfo501_get_name(PyObject *obj, void *closure)
4589 {
4590         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4591         PyObject *py_name;
4592         if (object->name == NULL) {
4593                 py_name = Py_None;
4594                 Py_INCREF(py_name);
4595         } else {
4596                 if (object->name == NULL) {
4597                         py_name = Py_None;
4598                         Py_INCREF(py_name);
4599                 } else {
4600                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4601                 }
4602         }
4603         return py_name;
4604 }
4605
4606 static int py_srvsvc_NetShareInfo501_set_name(PyObject *py_obj, PyObject *value, void *closure)
4607 {
4608         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4609         if (value == Py_None) {
4610                 object->name = NULL;
4611         } else {
4612                 object->name = NULL;
4613                 if (PyUnicode_Check(value)) {
4614                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4615                 } else if (PyString_Check(value)) {
4616                         object->name = PyString_AS_STRING(value);
4617                 } else {
4618                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4619                         return -1;
4620                 }
4621         }
4622         return 0;
4623 }
4624
4625 static PyObject *py_srvsvc_NetShareInfo501_get_type(PyObject *obj, void *closure)
4626 {
4627         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4628         PyObject *py_type;
4629         py_type = PyInt_FromLong(object->type);
4630         return py_type;
4631 }
4632
4633 static int py_srvsvc_NetShareInfo501_set_type(PyObject *py_obj, PyObject *value, void *closure)
4634 {
4635         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4636         if (PyLong_Check(value)) {
4637                 object->type = PyLong_AsLongLong(value);
4638         } else if (PyInt_Check(value)) {
4639                 object->type = PyInt_AsLong(value);
4640         } else {
4641                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4642                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4643                 return -1;
4644         }
4645         return 0;
4646 }
4647
4648 static PyObject *py_srvsvc_NetShareInfo501_get_comment(PyObject *obj, void *closure)
4649 {
4650         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4651         PyObject *py_comment;
4652         if (object->comment == NULL) {
4653                 py_comment = Py_None;
4654                 Py_INCREF(py_comment);
4655         } else {
4656                 if (object->comment == NULL) {
4657                         py_comment = Py_None;
4658                         Py_INCREF(py_comment);
4659                 } else {
4660                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4661                 }
4662         }
4663         return py_comment;
4664 }
4665
4666 static int py_srvsvc_NetShareInfo501_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4667 {
4668         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4669         if (value == Py_None) {
4670                 object->comment = NULL;
4671         } else {
4672                 object->comment = NULL;
4673                 if (PyUnicode_Check(value)) {
4674                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4675                 } else if (PyString_Check(value)) {
4676                         object->comment = PyString_AS_STRING(value);
4677                 } else {
4678                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4679                         return -1;
4680                 }
4681         }
4682         return 0;
4683 }
4684
4685 static PyObject *py_srvsvc_NetShareInfo501_get_csc_policy(PyObject *obj, void *closure)
4686 {
4687         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4688         PyObject *py_csc_policy;
4689         py_csc_policy = PyInt_FromLong(object->csc_policy);
4690         return py_csc_policy;
4691 }
4692
4693 static int py_srvsvc_NetShareInfo501_set_csc_policy(PyObject *py_obj, PyObject *value, void *closure)
4694 {
4695         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4696         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4697         object->csc_policy = PyInt_AsLong(value);
4698         return 0;
4699 }
4700
4701 static PyGetSetDef py_srvsvc_NetShareInfo501_getsetters[] = {
4702         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo501_get_name, py_srvsvc_NetShareInfo501_set_name },
4703         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo501_get_type, py_srvsvc_NetShareInfo501_set_type },
4704         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo501_get_comment, py_srvsvc_NetShareInfo501_set_comment },
4705         { discard_const_p(char, "csc_policy"), py_srvsvc_NetShareInfo501_get_csc_policy, py_srvsvc_NetShareInfo501_set_csc_policy },
4706         { NULL }
4707 };
4708
4709 static PyObject *py_srvsvc_NetShareInfo501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4710 {
4711         return pytalloc_new(struct srvsvc_NetShareInfo501, type);
4712 }
4713
4714
4715 static PyTypeObject srvsvc_NetShareInfo501_Type = {
4716         PyObject_HEAD_INIT(NULL) 0,
4717         .tp_name = "srvsvc.NetShareInfo501",
4718         .tp_getset = py_srvsvc_NetShareInfo501_getsetters,
4719         .tp_methods = NULL,
4720         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4721         .tp_basicsize = sizeof(pytalloc_Object),
4722         .tp_new = py_srvsvc_NetShareInfo501_new,
4723 };
4724
4725
4726 static PyObject *py_srvsvc_NetShareCtr501_get_count(PyObject *obj, void *closure)
4727 {
4728         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
4729         PyObject *py_count;
4730         py_count = PyInt_FromLong(object->count);
4731         return py_count;
4732 }
4733
4734 static int py_srvsvc_NetShareCtr501_set_count(PyObject *py_obj, PyObject *value, void *closure)
4735 {
4736         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(py_obj);
4737         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4738         object->count = PyInt_AsLong(value);
4739         return 0;
4740 }
4741
4742 static PyObject *py_srvsvc_NetShareCtr501_get_array(PyObject *obj, void *closure)
4743 {
4744         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
4745         PyObject *py_array;
4746         if (object->array == NULL) {
4747                 py_array = Py_None;
4748                 Py_INCREF(py_array);
4749         } else {
4750                 py_array = PyList_New(object->count);
4751                 if (py_array == NULL) {
4752                         return NULL;
4753                 }
4754                 {
4755                         int array_cntr_1;
4756                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4757                                 PyObject *py_array_1;
4758                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, object->array, &object->array[array_cntr_1]);
4759                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4760                         }
4761                 }
4762         }
4763         return py_array;
4764 }
4765
4766 static int py_srvsvc_NetShareCtr501_set_array(PyObject *py_obj, PyObject *value, void *closure)
4767 {
4768         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(py_obj);
4769         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4770         if (value == Py_None) {
4771                 object->array = NULL;
4772         } else {
4773                 object->array = NULL;
4774                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4775                 {
4776                         int array_cntr_1;
4777                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4778                         if (!object->array) { return -1;; }
4779                         talloc_set_name_const(object->array, "ARRAY: object->array");
4780                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4781                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4782                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4783                                         PyErr_NoMemory();
4784                                         return -1;
4785                                 }
4786                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4787                         }
4788                 }
4789         }
4790         return 0;
4791 }
4792
4793 static PyGetSetDef py_srvsvc_NetShareCtr501_getsetters[] = {
4794         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr501_get_count, py_srvsvc_NetShareCtr501_set_count },
4795         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr501_get_array, py_srvsvc_NetShareCtr501_set_array },
4796         { NULL }
4797 };
4798
4799 static PyObject *py_srvsvc_NetShareCtr501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4800 {
4801         return pytalloc_new(struct srvsvc_NetShareCtr501, type);
4802 }
4803
4804
4805 static PyTypeObject srvsvc_NetShareCtr501_Type = {
4806         PyObject_HEAD_INIT(NULL) 0,
4807         .tp_name = "srvsvc.NetShareCtr501",
4808         .tp_getset = py_srvsvc_NetShareCtr501_getsetters,
4809         .tp_methods = NULL,
4810         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4811         .tp_basicsize = sizeof(pytalloc_Object),
4812         .tp_new = py_srvsvc_NetShareCtr501_new,
4813 };
4814
4815
4816 static PyObject *py_srvsvc_NetShareInfo502_get_name(PyObject *obj, void *closure)
4817 {
4818         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4819         PyObject *py_name;
4820         if (object->name == NULL) {
4821                 py_name = Py_None;
4822                 Py_INCREF(py_name);
4823         } else {
4824                 if (object->name == NULL) {
4825                         py_name = Py_None;
4826                         Py_INCREF(py_name);
4827                 } else {
4828                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4829                 }
4830         }
4831         return py_name;
4832 }
4833
4834 static int py_srvsvc_NetShareInfo502_set_name(PyObject *py_obj, PyObject *value, void *closure)
4835 {
4836         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4837         if (value == Py_None) {
4838                 object->name = NULL;
4839         } else {
4840                 object->name = NULL;
4841                 if (PyUnicode_Check(value)) {
4842                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4843                 } else if (PyString_Check(value)) {
4844                         object->name = PyString_AS_STRING(value);
4845                 } else {
4846                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4847                         return -1;
4848                 }
4849         }
4850         return 0;
4851 }
4852
4853 static PyObject *py_srvsvc_NetShareInfo502_get_type(PyObject *obj, void *closure)
4854 {
4855         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4856         PyObject *py_type;
4857         py_type = PyInt_FromLong(object->type);
4858         return py_type;
4859 }
4860
4861 static int py_srvsvc_NetShareInfo502_set_type(PyObject *py_obj, PyObject *value, void *closure)
4862 {
4863         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4864         if (PyLong_Check(value)) {
4865                 object->type = PyLong_AsLongLong(value);
4866         } else if (PyInt_Check(value)) {
4867                 object->type = PyInt_AsLong(value);
4868         } else {
4869                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4870                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4871                 return -1;
4872         }
4873         return 0;
4874 }
4875
4876 static PyObject *py_srvsvc_NetShareInfo502_get_comment(PyObject *obj, void *closure)
4877 {
4878         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4879         PyObject *py_comment;
4880         if (object->comment == NULL) {
4881                 py_comment = Py_None;
4882                 Py_INCREF(py_comment);
4883         } else {
4884                 if (object->comment == NULL) {
4885                         py_comment = Py_None;
4886                         Py_INCREF(py_comment);
4887                 } else {
4888                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4889                 }
4890         }
4891         return py_comment;
4892 }
4893
4894 static int py_srvsvc_NetShareInfo502_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4895 {
4896         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4897         if (value == Py_None) {
4898                 object->comment = NULL;
4899         } else {
4900                 object->comment = NULL;
4901                 if (PyUnicode_Check(value)) {
4902                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4903                 } else if (PyString_Check(value)) {
4904                         object->comment = PyString_AS_STRING(value);
4905                 } else {
4906                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4907                         return -1;
4908                 }
4909         }
4910         return 0;
4911 }
4912
4913 static PyObject *py_srvsvc_NetShareInfo502_get_permissions(PyObject *obj, void *closure)
4914 {
4915         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4916         PyObject *py_permissions;
4917         py_permissions = PyInt_FromLong(object->permissions);
4918         return py_permissions;
4919 }
4920
4921 static int py_srvsvc_NetShareInfo502_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
4922 {
4923         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4924         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4925         object->permissions = PyInt_AsLong(value);
4926         return 0;
4927 }
4928
4929 static PyObject *py_srvsvc_NetShareInfo502_get_max_users(PyObject *obj, void *closure)
4930 {
4931         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4932         PyObject *py_max_users;
4933         py_max_users = PyInt_FromLong(object->max_users);
4934         return py_max_users;
4935 }
4936
4937 static int py_srvsvc_NetShareInfo502_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
4938 {
4939         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4940         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4941         object->max_users = PyInt_AsLong(value);
4942         return 0;
4943 }
4944
4945 static PyObject *py_srvsvc_NetShareInfo502_get_current_users(PyObject *obj, void *closure)
4946 {
4947         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4948         PyObject *py_current_users;
4949         py_current_users = PyInt_FromLong(object->current_users);
4950         return py_current_users;
4951 }
4952
4953 static int py_srvsvc_NetShareInfo502_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
4954 {
4955         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4956         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4957         object->current_users = PyInt_AsLong(value);
4958         return 0;
4959 }
4960
4961 static PyObject *py_srvsvc_NetShareInfo502_get_path(PyObject *obj, void *closure)
4962 {
4963         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4964         PyObject *py_path;
4965         if (object->path == NULL) {
4966                 py_path = Py_None;
4967                 Py_INCREF(py_path);
4968         } else {
4969                 if (object->path == NULL) {
4970                         py_path = Py_None;
4971                         Py_INCREF(py_path);
4972                 } else {
4973                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
4974                 }
4975         }
4976         return py_path;
4977 }
4978
4979 static int py_srvsvc_NetShareInfo502_set_path(PyObject *py_obj, PyObject *value, void *closure)
4980 {
4981         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4982         if (value == Py_None) {
4983                 object->path = NULL;
4984         } else {
4985                 object->path = NULL;
4986                 if (PyUnicode_Check(value)) {
4987                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4988                 } else if (PyString_Check(value)) {
4989                         object->path = PyString_AS_STRING(value);
4990                 } else {
4991                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4992                         return -1;
4993                 }
4994         }
4995         return 0;
4996 }
4997
4998 static PyObject *py_srvsvc_NetShareInfo502_get_password(PyObject *obj, void *closure)
4999 {
5000         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
5001         PyObject *py_password;
5002         if (object->password == NULL) {
5003                 py_password = Py_None;
5004                 Py_INCREF(py_password);
5005         } else {
5006                 if (object->password == NULL) {
5007                         py_password = Py_None;
5008                         Py_INCREF(py_password);
5009                 } else {
5010                         py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
5011                 }
5012         }
5013         return py_password;
5014 }
5015
5016 static int py_srvsvc_NetShareInfo502_set_password(PyObject *py_obj, PyObject *value, void *closure)
5017 {
5018         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
5019         if (value == Py_None) {
5020                 object->password = NULL;
5021         } else {
5022                 object->password = NULL;
5023                 if (PyUnicode_Check(value)) {
5024                         object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5025                 } else if (PyString_Check(value)) {
5026                         object->password = PyString_AS_STRING(value);
5027                 } else {
5028                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5029                         return -1;
5030                 }
5031         }
5032         return 0;
5033 }
5034
5035 static PyObject *py_srvsvc_NetShareInfo502_get_sd_buf(PyObject *obj, void *closure)
5036 {
5037         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
5038         PyObject *py_sd_buf;
5039         py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, pytalloc_get_mem_ctx(obj), &object->sd_buf);
5040         return py_sd_buf;
5041 }
5042
5043 static int py_srvsvc_NetShareInfo502_set_sd_buf(PyObject *py_obj, PyObject *value, void *closure)
5044 {
5045         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
5046         PY_CHECK_TYPE(sec_desc_buf_Type, value, return -1;);
5047         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
5048                 PyErr_NoMemory();
5049                 return -1;
5050         }
5051         object->sd_buf = *(struct sec_desc_buf *)pytalloc_get_ptr(value);
5052         return 0;
5053 }
5054
5055 static PyGetSetDef py_srvsvc_NetShareInfo502_getsetters[] = {
5056         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo502_get_name, py_srvsvc_NetShareInfo502_set_name },
5057         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo502_get_type, py_srvsvc_NetShareInfo502_set_type },
5058         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo502_get_comment, py_srvsvc_NetShareInfo502_set_comment },
5059         { discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo502_get_permissions, py_srvsvc_NetShareInfo502_set_permissions },
5060         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo502_get_max_users, py_srvsvc_NetShareInfo502_set_max_users },
5061         { discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo502_get_current_users, py_srvsvc_NetShareInfo502_set_current_users },
5062         { discard_const_p(char, "path"), py_srvsvc_NetShareInfo502_get_path, py_srvsvc_NetShareInfo502_set_path },
5063         { discard_const_p(char, "password"), py_srvsvc_NetShareInfo502_get_password, py_srvsvc_NetShareInfo502_set_password },
5064         { discard_const_p(char, "sd_buf"), py_srvsvc_NetShareInfo502_get_sd_buf, py_srvsvc_NetShareInfo502_set_sd_buf },
5065         { NULL }
5066 };
5067
5068 static PyObject *py_srvsvc_NetShareInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5069 {
5070         return pytalloc_new(struct srvsvc_NetShareInfo502, type);
5071 }
5072
5073
5074 static PyTypeObject srvsvc_NetShareInfo502_Type = {
5075         PyObject_HEAD_INIT(NULL) 0,
5076         .tp_name = "srvsvc.NetShareInfo502",
5077         .tp_getset = py_srvsvc_NetShareInfo502_getsetters,
5078         .tp_methods = NULL,
5079         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5080         .tp_basicsize = sizeof(pytalloc_Object),
5081         .tp_new = py_srvsvc_NetShareInfo502_new,
5082 };
5083
5084
5085 static PyObject *py_srvsvc_NetShareCtr502_get_count(PyObject *obj, void *closure)
5086 {
5087         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
5088         PyObject *py_count;
5089         py_count = PyInt_FromLong(object->count);
5090         return py_count;
5091 }
5092
5093 static int py_srvsvc_NetShareCtr502_set_count(PyObject *py_obj, PyObject *value, void *closure)
5094 {
5095         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(py_obj);
5096         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5097         object->count = PyInt_AsLong(value);
5098         return 0;
5099 }
5100
5101 static PyObject *py_srvsvc_NetShareCtr502_get_array(PyObject *obj, void *closure)
5102 {
5103         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
5104         PyObject *py_array;
5105         if (object->array == NULL) {
5106                 py_array = Py_None;
5107                 Py_INCREF(py_array);
5108         } else {
5109                 py_array = PyList_New(object->count);
5110                 if (py_array == NULL) {
5111                         return NULL;
5112                 }
5113                 {
5114                         int array_cntr_1;
5115                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5116                                 PyObject *py_array_1;
5117                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, object->array, &object->array[array_cntr_1]);
5118                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5119                         }
5120                 }
5121         }
5122         return py_array;
5123 }
5124
5125 static int py_srvsvc_NetShareCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
5126 {
5127         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(py_obj);
5128         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5129         if (value == Py_None) {
5130                 object->array = NULL;
5131         } else {
5132                 object->array = NULL;
5133                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5134                 {
5135                         int array_cntr_1;
5136                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5137                         if (!object->array) { return -1;; }
5138                         talloc_set_name_const(object->array, "ARRAY: object->array");
5139                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5140                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5141                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5142                                         PyErr_NoMemory();
5143                                         return -1;
5144                                 }
5145                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5146                         }
5147                 }
5148         }
5149         return 0;
5150 }
5151
5152 static PyGetSetDef py_srvsvc_NetShareCtr502_getsetters[] = {
5153         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr502_get_count, py_srvsvc_NetShareCtr502_set_count },
5154         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr502_get_array, py_srvsvc_NetShareCtr502_set_array },
5155         { NULL }
5156 };
5157
5158 static PyObject *py_srvsvc_NetShareCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5159 {
5160         return pytalloc_new(struct srvsvc_NetShareCtr502, type);
5161 }
5162
5163
5164 static PyTypeObject srvsvc_NetShareCtr502_Type = {
5165         PyObject_HEAD_INIT(NULL) 0,
5166         .tp_name = "srvsvc.NetShareCtr502",
5167         .tp_getset = py_srvsvc_NetShareCtr502_getsetters,
5168         .tp_methods = NULL,
5169         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5170         .tp_basicsize = sizeof(pytalloc_Object),
5171         .tp_new = py_srvsvc_NetShareCtr502_new,
5172 };
5173
5174
5175 static PyObject *py_srvsvc_NetShareInfo1004_get_comment(PyObject *obj, void *closure)
5176 {
5177         struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(obj);
5178         PyObject *py_comment;
5179         if (object->comment == NULL) {
5180                 py_comment = Py_None;
5181                 Py_INCREF(py_comment);
5182         } else {
5183                 if (object->comment == NULL) {
5184                         py_comment = Py_None;
5185                         Py_INCREF(py_comment);
5186                 } else {
5187                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
5188                 }
5189         }
5190         return py_comment;
5191 }
5192
5193 static int py_srvsvc_NetShareInfo1004_set_comment(PyObject *py_obj, PyObject *value, void *closure)
5194 {
5195         struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(py_obj);
5196         if (value == Py_None) {
5197                 object->comment = NULL;
5198         } else {
5199                 object->comment = NULL;
5200                 if (PyUnicode_Check(value)) {
5201                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5202                 } else if (PyString_Check(value)) {
5203                         object->comment = PyString_AS_STRING(value);
5204                 } else {
5205                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5206                         return -1;
5207                 }
5208         }
5209         return 0;
5210 }
5211
5212 static PyGetSetDef py_srvsvc_NetShareInfo1004_getsetters[] = {
5213         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1004_get_comment, py_srvsvc_NetShareInfo1004_set_comment },
5214         { NULL }
5215 };
5216
5217 static PyObject *py_srvsvc_NetShareInfo1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5218 {
5219         return pytalloc_new(struct srvsvc_NetShareInfo1004, type);
5220 }
5221
5222
5223 static PyTypeObject srvsvc_NetShareInfo1004_Type = {
5224         PyObject_HEAD_INIT(NULL) 0,
5225         .tp_name = "srvsvc.NetShareInfo1004",
5226         .tp_getset = py_srvsvc_NetShareInfo1004_getsetters,
5227         .tp_methods = NULL,
5228         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5229         .tp_basicsize = sizeof(pytalloc_Object),
5230         .tp_new = py_srvsvc_NetShareInfo1004_new,
5231 };
5232
5233
5234 static PyObject *py_srvsvc_NetShareCtr1004_get_count(PyObject *obj, void *closure)
5235 {
5236         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
5237         PyObject *py_count;
5238         py_count = PyInt_FromLong(object->count);
5239         return py_count;
5240 }
5241
5242 static int py_srvsvc_NetShareCtr1004_set_count(PyObject *py_obj, PyObject *value, void *closure)
5243 {
5244         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(py_obj);
5245         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5246         object->count = PyInt_AsLong(value);
5247         return 0;
5248 }
5249
5250 static PyObject *py_srvsvc_NetShareCtr1004_get_array(PyObject *obj, void *closure)
5251 {
5252         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
5253         PyObject *py_array;
5254         if (object->array == NULL) {
5255                 py_array = Py_None;
5256                 Py_INCREF(py_array);
5257         } else {
5258                 py_array = PyList_New(object->count);
5259                 if (py_array == NULL) {
5260                         return NULL;
5261                 }
5262                 {
5263                         int array_cntr_1;
5264                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5265                                 PyObject *py_array_1;
5266                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, object->array, &object->array[array_cntr_1]);
5267                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5268                         }
5269                 }
5270         }
5271         return py_array;
5272 }
5273
5274 static int py_srvsvc_NetShareCtr1004_set_array(PyObject *py_obj, PyObject *value, void *closure)
5275 {
5276         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(py_obj);
5277         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5278         if (value == Py_None) {
5279                 object->array = NULL;
5280         } else {
5281                 object->array = NULL;
5282                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5283                 {
5284                         int array_cntr_1;
5285                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5286                         if (!object->array) { return -1;; }
5287                         talloc_set_name_const(object->array, "ARRAY: object->array");
5288                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5289                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5290                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5291                                         PyErr_NoMemory();
5292                                         return -1;
5293                                 }
5294                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5295                         }
5296                 }
5297         }
5298         return 0;
5299 }
5300
5301 static PyGetSetDef py_srvsvc_NetShareCtr1004_getsetters[] = {
5302         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1004_get_count, py_srvsvc_NetShareCtr1004_set_count },
5303         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1004_get_array, py_srvsvc_NetShareCtr1004_set_array },
5304         { NULL }
5305 };
5306
5307 static PyObject *py_srvsvc_NetShareCtr1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5308 {
5309         return pytalloc_new(struct srvsvc_NetShareCtr1004, type);
5310 }
5311
5312
5313 static PyTypeObject srvsvc_NetShareCtr1004_Type = {
5314         PyObject_HEAD_INIT(NULL) 0,
5315         .tp_name = "srvsvc.NetShareCtr1004",
5316         .tp_getset = py_srvsvc_NetShareCtr1004_getsetters,
5317         .tp_methods = NULL,
5318         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5319         .tp_basicsize = sizeof(pytalloc_Object),
5320         .tp_new = py_srvsvc_NetShareCtr1004_new,
5321 };
5322
5323
5324 static PyObject *py_srvsvc_NetShareInfo1005_get_dfs_flags(PyObject *obj, void *closure)
5325 {
5326         struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(obj);
5327         PyObject *py_dfs_flags;
5328         py_dfs_flags = PyInt_FromLong(object->dfs_flags);
5329         return py_dfs_flags;
5330 }
5331
5332 static int py_srvsvc_NetShareInfo1005_set_dfs_flags(PyObject *py_obj, PyObject *value, void *closure)
5333 {
5334         struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(py_obj);
5335         if (PyLong_Check(value)) {
5336                 object->dfs_flags = PyLong_AsLongLong(value);
5337         } else if (PyInt_Check(value)) {
5338                 object->dfs_flags = PyInt_AsLong(value);
5339         } else {
5340                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5341                   PyInt_Type.tp_name, PyLong_Type.tp_name);
5342                 return -1;
5343         }
5344         return 0;
5345 }
5346
5347 static PyGetSetDef py_srvsvc_NetShareInfo1005_getsetters[] = {
5348         { discard_const_p(char, "dfs_flags"), py_srvsvc_NetShareInfo1005_get_dfs_flags, py_srvsvc_NetShareInfo1005_set_dfs_flags },
5349         { NULL }
5350 };
5351
5352 static PyObject *py_srvsvc_NetShareInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5353 {
5354         return pytalloc_new(struct srvsvc_NetShareInfo1005, type);
5355 }
5356
5357
5358 static PyTypeObject srvsvc_NetShareInfo1005_Type = {
5359         PyObject_HEAD_INIT(NULL) 0,
5360         .tp_name = "srvsvc.NetShareInfo1005",
5361         .tp_getset = py_srvsvc_NetShareInfo1005_getsetters,
5362         .tp_methods = NULL,
5363         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5364         .tp_basicsize = sizeof(pytalloc_Object),
5365         .tp_new = py_srvsvc_NetShareInfo1005_new,
5366 };
5367
5368
5369 static PyObject *py_srvsvc_NetShareCtr1005_get_count(PyObject *obj, void *closure)
5370 {
5371         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
5372         PyObject *py_count;
5373         py_count = PyInt_FromLong(object->count);
5374         return py_count;
5375 }
5376
5377 static int py_srvsvc_NetShareCtr1005_set_count(PyObject *py_obj, PyObject *value, void *closure)
5378 {
5379         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(py_obj);
5380         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5381         object->count = PyInt_AsLong(value);
5382         return 0;
5383 }
5384
5385 static PyObject *py_srvsvc_NetShareCtr1005_get_array(PyObject *obj, void *closure)
5386 {
5387         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
5388         PyObject *py_array;
5389         if (object->array == NULL) {
5390                 py_array = Py_None;
5391                 Py_INCREF(py_array);
5392         } else {
5393                 py_array = PyList_New(object->count);
5394                 if (py_array == NULL) {
5395                         return NULL;
5396                 }
5397                 {
5398                         int array_cntr_1;
5399                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5400                                 PyObject *py_array_1;
5401                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, object->array, &object->array[array_cntr_1]);
5402                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5403                         }
5404                 }
5405         }
5406         return py_array;
5407 }
5408
5409 static int py_srvsvc_NetShareCtr1005_set_array(PyObject *py_obj, PyObject *value, void *closure)
5410 {
5411         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(py_obj);
5412         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5413         if (value == Py_None) {
5414                 object->array = NULL;
5415         } else {
5416                 object->array = NULL;
5417                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5418                 {
5419                         int array_cntr_1;
5420                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5421                         if (!object->array) { return -1;; }
5422                         talloc_set_name_const(object->array, "ARRAY: object->array");
5423                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5424                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5425                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5426                                         PyErr_NoMemory();
5427                                         return -1;
5428                                 }
5429                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5430                         }
5431                 }
5432         }
5433         return 0;
5434 }
5435
5436 static PyGetSetDef py_srvsvc_NetShareCtr1005_getsetters[] = {
5437         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1005_get_count, py_srvsvc_NetShareCtr1005_set_count },
5438         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1005_get_array, py_srvsvc_NetShareCtr1005_set_array },
5439         { NULL }
5440 };
5441
5442 static PyObject *py_srvsvc_NetShareCtr1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5443 {
5444         return pytalloc_new(struct srvsvc_NetShareCtr1005, type);
5445 }
5446
5447
5448 static PyTypeObject srvsvc_NetShareCtr1005_Type = {
5449         PyObject_HEAD_INIT(NULL) 0,
5450         .tp_name = "srvsvc.NetShareCtr1005",
5451         .tp_getset = py_srvsvc_NetShareCtr1005_getsetters,
5452         .tp_methods = NULL,
5453         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5454         .tp_basicsize = sizeof(pytalloc_Object),
5455         .tp_new = py_srvsvc_NetShareCtr1005_new,
5456 };
5457
5458
5459 static PyObject *py_srvsvc_NetShareInfo1006_get_max_users(PyObject *obj, void *closure)
5460 {
5461         struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(obj);
5462         PyObject *py_max_users;
5463         py_max_users = PyInt_FromLong(object->max_users);
5464         return py_max_users;
5465 }
5466
5467 static int py_srvsvc_NetShareInfo1006_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
5468 {
5469         struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(py_obj);
5470         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5471         object->max_users = PyInt_AsLong(value);
5472         return 0;
5473 }
5474
5475 static PyGetSetDef py_srvsvc_NetShareInfo1006_getsetters[] = {
5476         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo1006_get_max_users, py_srvsvc_NetShareInfo1006_set_max_users },
5477         { NULL }
5478 };
5479
5480 static PyObject *py_srvsvc_NetShareInfo1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5481 {
5482         return pytalloc_new(struct srvsvc_NetShareInfo1006, type);
5483 }
5484
5485
5486 static PyTypeObject srvsvc_NetShareInfo1006_Type = {
5487         PyObject_HEAD_INIT(NULL) 0,
5488         .tp_name = "srvsvc.NetShareInfo1006",
5489         .tp_getset = py_srvsvc_NetShareInfo1006_getsetters,
5490         .tp_methods = NULL,
5491         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5492         .tp_basicsize = sizeof(pytalloc_Object),
5493         .tp_new = py_srvsvc_NetShareInfo1006_new,
5494 };
5495
5496
5497 static PyObject *py_srvsvc_NetShareCtr1006_get_count(PyObject *obj, void *closure)
5498 {
5499         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
5500         PyObject *py_count;
5501         py_count = PyInt_FromLong(object->count);
5502         return py_count;
5503 }
5504
5505 static int py_srvsvc_NetShareCtr1006_set_count(PyObject *py_obj, PyObject *value, void *closure)
5506 {
5507         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(py_obj);
5508         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5509         object->count = PyInt_AsLong(value);
5510         return 0;
5511 }
5512
5513 static PyObject *py_srvsvc_NetShareCtr1006_get_array(PyObject *obj, void *closure)
5514 {
5515         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
5516         PyObject *py_array;
5517         if (object->array == NULL) {
5518                 py_array = Py_None;
5519                 Py_INCREF(py_array);
5520         } else {
5521                 py_array = PyList_New(object->count);
5522                 if (py_array == NULL) {
5523                         return NULL;
5524                 }
5525                 {
5526                         int array_cntr_1;
5527                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5528                                 PyObject *py_array_1;
5529                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, object->array, &object->array[array_cntr_1]);
5530                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5531                         }
5532                 }
5533         }
5534         return py_array;
5535 }
5536
5537 static int py_srvsvc_NetShareCtr1006_set_array(PyObject *py_obj, PyObject *value, void *closure)
5538 {
5539         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(py_obj);
5540         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5541         if (value == Py_None) {
5542                 object->array = NULL;
5543         } else {
5544                 object->array = NULL;
5545                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5546                 {
5547                         int array_cntr_1;
5548                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5549                         if (!object->array) { return -1;; }
5550                         talloc_set_name_const(object->array, "ARRAY: object->array");
5551                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5552                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5553                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5554                                         PyErr_NoMemory();
5555                                         return -1;
5556                                 }
5557                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5558                         }
5559                 }
5560         }
5561         return 0;
5562 }
5563
5564 static PyGetSetDef py_srvsvc_NetShareCtr1006_getsetters[] = {
5565         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1006_get_count, py_srvsvc_NetShareCtr1006_set_count },
5566         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1006_get_array, py_srvsvc_NetShareCtr1006_set_array },
5567         { NULL }
5568 };
5569
5570 static PyObject *py_srvsvc_NetShareCtr1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5571 {
5572         return pytalloc_new(struct srvsvc_NetShareCtr1006, type);
5573 }
5574
5575
5576 static PyTypeObject srvsvc_NetShareCtr1006_Type = {
5577         PyObject_HEAD_INIT(NULL) 0,
5578         .tp_name = "srvsvc.NetShareCtr1006",
5579         .tp_getset = py_srvsvc_NetShareCtr1006_getsetters,
5580         .tp_methods = NULL,
5581         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5582         .tp_basicsize = sizeof(pytalloc_Object),
5583         .tp_new = py_srvsvc_NetShareCtr1006_new,
5584 };
5585
5586
5587 static PyObject *py_srvsvc_NetShareInfo1007_get_flags(PyObject *obj, void *closure)
5588 {
5589         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
5590         PyObject *py_flags;
5591         py_flags = PyInt_FromLong(object->flags);
5592         return py_flags;
5593 }
5594
5595 static int py_srvsvc_NetShareInfo1007_set_flags(PyObject *py_obj, PyObject *value, void *closure)
5596 {
5597         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
5598         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5599         object->flags = PyInt_AsLong(value);
5600         return 0;
5601 }
5602
5603 static PyObject *py_srvsvc_NetShareInfo1007_get_alternate_directory_name(PyObject *obj, void *closure)
5604 {
5605         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
5606         PyObject *py_alternate_directory_name;
5607         if (object->alternate_directory_name == NULL) {
5608                 py_alternate_directory_name = Py_None;
5609                 Py_INCREF(py_alternate_directory_name);
5610         } else {
5611                 if (object->alternate_directory_name == NULL) {
5612                         py_alternate_directory_name = Py_None;
5613                         Py_INCREF(py_alternate_directory_name);
5614                 } else {
5615                         py_alternate_directory_name = PyUnicode_Decode(object->alternate_directory_name, strlen(object->alternate_directory_name), "utf-8", "ignore");
5616                 }
5617         }
5618         return py_alternate_directory_name;
5619 }
5620
5621 static int py_srvsvc_NetShareInfo1007_set_alternate_directory_name(PyObject *py_obj, PyObject *value, void *closure)
5622 {
5623         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
5624         if (value == Py_None) {
5625                 object->alternate_directory_name = NULL;
5626         } else {
5627                 object->alternate_directory_name = NULL;
5628                 if (PyUnicode_Check(value)) {
5629                         object->alternate_directory_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5630                 } else if (PyString_Check(value)) {
5631                         object->alternate_directory_name = PyString_AS_STRING(value);
5632                 } else {
5633                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5634                         return -1;
5635                 }
5636         }
5637         return 0;
5638 }
5639
5640 static PyGetSetDef py_srvsvc_NetShareInfo1007_getsetters[] = {
5641         { discard_const_p(char, "flags"), py_srvsvc_NetShareInfo1007_get_flags, py_srvsvc_NetShareInfo1007_set_flags },
5642         { discard_const_p(char, "alternate_directory_name"), py_srvsvc_NetShareInfo1007_get_alternate_directory_name, py_srvsvc_NetShareInfo1007_set_alternate_directory_name },
5643         { NULL }
5644 };
5645
5646 static PyObject *py_srvsvc_NetShareInfo1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5647 {
5648         return pytalloc_new(struct srvsvc_NetShareInfo1007, type);
5649 }
5650
5651
5652 static PyTypeObject srvsvc_NetShareInfo1007_Type = {
5653         PyObject_HEAD_INIT(NULL) 0,
5654         .tp_name = "srvsvc.NetShareInfo1007",
5655         .tp_getset = py_srvsvc_NetShareInfo1007_getsetters,
5656         .tp_methods = NULL,
5657         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5658         .tp_basicsize = sizeof(pytalloc_Object),
5659         .tp_new = py_srvsvc_NetShareInfo1007_new,
5660 };
5661
5662
5663 static PyObject *py_srvsvc_NetShareCtr1007_get_count(PyObject *obj, void *closure)
5664 {
5665         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
5666         PyObject *py_count;
5667         py_count = PyInt_FromLong(object->count);
5668         return py_count;
5669 }
5670
5671 static int py_srvsvc_NetShareCtr1007_set_count(PyObject *py_obj, PyObject *value, void *closure)
5672 {
5673         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(py_obj);
5674         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5675         object->count = PyInt_AsLong(value);
5676         return 0;
5677 }
5678
5679 static PyObject *py_srvsvc_NetShareCtr1007_get_array(PyObject *obj, void *closure)
5680 {
5681         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
5682         PyObject *py_array;
5683         if (object->array == NULL) {
5684                 py_array = Py_None;
5685                 Py_INCREF(py_array);
5686         } else {
5687                 py_array = PyList_New(object->count);
5688                 if (py_array == NULL) {
5689                         return NULL;
5690                 }
5691                 {
5692                         int array_cntr_1;
5693                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5694                                 PyObject *py_array_1;
5695                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, object->array, &object->array[array_cntr_1]);
5696                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5697                         }
5698                 }
5699         }
5700         return py_array;
5701 }
5702
5703 static int py_srvsvc_NetShareCtr1007_set_array(PyObject *py_obj, PyObject *value, void *closure)
5704 {
5705         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(py_obj);
5706         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5707         if (value == Py_None) {
5708                 object->array = NULL;
5709         } else {
5710                 object->array = NULL;
5711                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5712                 {
5713                         int array_cntr_1;
5714                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5715                         if (!object->array) { return -1;; }
5716                         talloc_set_name_const(object->array, "ARRAY: object->array");
5717                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5718                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5719                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5720                                         PyErr_NoMemory();
5721                                         return -1;
5722                                 }
5723                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5724                         }
5725                 }
5726         }
5727         return 0;
5728 }
5729
5730 static PyGetSetDef py_srvsvc_NetShareCtr1007_getsetters[] = {
5731         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1007_get_count, py_srvsvc_NetShareCtr1007_set_count },
5732         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1007_get_array, py_srvsvc_NetShareCtr1007_set_array },
5733         { NULL }
5734 };
5735
5736 static PyObject *py_srvsvc_NetShareCtr1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5737 {
5738         return pytalloc_new(struct srvsvc_NetShareCtr1007, type);
5739 }
5740
5741
5742 static PyTypeObject srvsvc_NetShareCtr1007_Type = {
5743         PyObject_HEAD_INIT(NULL) 0,
5744         .tp_name = "srvsvc.NetShareCtr1007",
5745         .tp_getset = py_srvsvc_NetShareCtr1007_getsetters,
5746         .tp_methods = NULL,
5747         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5748         .tp_basicsize = sizeof(pytalloc_Object),
5749         .tp_new = py_srvsvc_NetShareCtr1007_new,
5750 };
5751
5752
5753 static PyObject *py_srvsvc_NetShareCtr1501_get_count(PyObject *obj, void *closure)
5754 {
5755         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
5756         PyObject *py_count;
5757         py_count = PyInt_FromLong(object->count);
5758         return py_count;
5759 }
5760
5761 static int py_srvsvc_NetShareCtr1501_set_count(PyObject *py_obj, PyObject *value, void *closure)
5762 {
5763         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(py_obj);
5764         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5765         object->count = PyInt_AsLong(value);
5766         return 0;
5767 }
5768
5769 static PyObject *py_srvsvc_NetShareCtr1501_get_array(PyObject *obj, void *closure)
5770 {
5771         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
5772         PyObject *py_array;
5773         if (object->array == NULL) {
5774                 py_array = Py_None;
5775                 Py_INCREF(py_array);
5776         } else {
5777                 py_array = PyList_New(object->count);
5778                 if (py_array == NULL) {
5779                         return NULL;
5780                 }
5781                 {
5782                         int array_cntr_1;
5783                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5784                                 PyObject *py_array_1;
5785                                 py_array_1 = pytalloc_reference_ex(sec_desc_buf_Type, object->array, &object->array[array_cntr_1]);
5786                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5787                         }
5788                 }
5789         }
5790         return py_array;
5791 }
5792
5793 static int py_srvsvc_NetShareCtr1501_set_array(PyObject *py_obj, PyObject *value, void *closure)
5794 {
5795         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(py_obj);
5796         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5797         if (value == Py_None) {
5798                 object->array = NULL;
5799         } else {
5800                 object->array = NULL;
5801                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5802                 {
5803                         int array_cntr_1;
5804                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5805                         if (!object->array) { return -1;; }
5806                         talloc_set_name_const(object->array, "ARRAY: object->array");
5807                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5808                                 PY_CHECK_TYPE(sec_desc_buf_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5809                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5810                                         PyErr_NoMemory();
5811                                         return -1;
5812                                 }
5813                                 object->array[array_cntr_1] = *(struct sec_desc_buf *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5814                         }
5815                 }
5816         }
5817         return 0;
5818 }
5819
5820 static PyGetSetDef py_srvsvc_NetShareCtr1501_getsetters[] = {
5821         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1501_get_count, py_srvsvc_NetShareCtr1501_set_count },
5822         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1501_get_array, py_srvsvc_NetShareCtr1501_set_array },
5823         { NULL }
5824 };
5825
5826 static PyObject *py_srvsvc_NetShareCtr1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5827 {
5828         return pytalloc_new(struct srvsvc_NetShareCtr1501, type);
5829 }
5830
5831
5832 static PyTypeObject srvsvc_NetShareCtr1501_Type = {
5833         PyObject_HEAD_INIT(NULL) 0,
5834         .tp_name = "srvsvc.NetShareCtr1501",
5835         .tp_getset = py_srvsvc_NetShareCtr1501_getsetters,
5836         .tp_methods = NULL,
5837         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5838         .tp_basicsize = sizeof(pytalloc_Object),
5839         .tp_new = py_srvsvc_NetShareCtr1501_new,
5840 };
5841
5842 static PyObject *py_import_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareInfo *in)
5843 {
5844         PyObject *ret;
5845
5846         switch (level) {
5847                 case 0:
5848                         if (in->info0 == NULL) {
5849                                 ret = Py_None;
5850                                 Py_INCREF(ret);
5851                         } else {
5852                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo0_Type, in->info0, in->info0);
5853                         }
5854                         return ret;
5855
5856                 case 1:
5857                         if (in->info1 == NULL) {
5858                                 ret = Py_None;
5859                                 Py_INCREF(ret);
5860                         } else {
5861                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1_Type, in->info1, in->info1);
5862                         }
5863                         return ret;
5864
5865                 case 2:
5866                         if (in->info2 == NULL) {
5867                                 ret = Py_None;
5868                                 Py_INCREF(ret);
5869                         } else {
5870                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo2_Type, in->info2, in->info2);
5871                         }
5872                         return ret;
5873
5874                 case 501:
5875                         if (in->info501 == NULL) {
5876                                 ret = Py_None;
5877                                 Py_INCREF(ret);
5878                         } else {
5879                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, in->info501, in->info501);
5880                         }
5881                         return ret;
5882
5883                 case 502:
5884                         if (in->info502 == NULL) {
5885                                 ret = Py_None;
5886                                 Py_INCREF(ret);
5887                         } else {
5888                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, in->info502, in->info502);
5889                         }
5890                         return ret;
5891
5892                 case 1004:
5893                         if (in->info1004 == NULL) {
5894                                 ret = Py_None;
5895                                 Py_INCREF(ret);
5896                         } else {
5897                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, in->info1004, in->info1004);
5898                         }
5899                         return ret;
5900
5901                 case 1005:
5902                         if (in->info1005 == NULL) {
5903                                 ret = Py_None;
5904                                 Py_INCREF(ret);
5905                         } else {
5906                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, in->info1005, in->info1005);
5907                         }
5908                         return ret;
5909
5910                 case 1006:
5911                         if (in->info1006 == NULL) {
5912                                 ret = Py_None;
5913                                 Py_INCREF(ret);
5914                         } else {
5915                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, in->info1006, in->info1006);
5916                         }
5917                         return ret;
5918
5919                 case 1007:
5920                         if (in->info1007 == NULL) {
5921                                 ret = Py_None;
5922                                 Py_INCREF(ret);
5923                         } else {
5924                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, in->info1007, in->info1007);
5925                         }
5926                         return ret;
5927
5928                 case 1501:
5929                         if (in->info1501 == NULL) {
5930                                 ret = Py_None;
5931                                 Py_INCREF(ret);
5932                         } else {
5933                                 ret = pytalloc_reference_ex(sec_desc_buf_Type, in->info1501, in->info1501);
5934                         }
5935                         return ret;
5936
5937                 default:
5938                         ret = Py_None;
5939                         Py_INCREF(ret);
5940                         return ret;
5941
5942         }
5943         PyErr_SetString(PyExc_TypeError, "unknown union level");
5944         return NULL;
5945 }
5946
5947 static union srvsvc_NetShareInfo *py_export_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5948 {
5949         union srvsvc_NetShareInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetShareInfo);
5950         switch (level) {
5951                 case 0:
5952                         if (in == Py_None) {
5953                                 ret->info0 = NULL;
5954                         } else {
5955                                 ret->info0 = NULL;
5956                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, in, talloc_free(ret); return NULL;);
5957                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5958                                         PyErr_NoMemory();
5959                                         talloc_free(ret); return NULL;
5960                                 }
5961                                 ret->info0 = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(in);
5962                         }
5963                         break;
5964
5965                 case 1:
5966                         if (in == Py_None) {
5967                                 ret->info1 = NULL;
5968                         } else {
5969                                 ret->info1 = NULL;
5970                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, in, talloc_free(ret); return NULL;);
5971                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5972                                         PyErr_NoMemory();
5973                                         talloc_free(ret); return NULL;
5974                                 }
5975                                 ret->info1 = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(in);
5976                         }
5977                         break;
5978
5979                 case 2:
5980                         if (in == Py_None) {
5981                                 ret->info2 = NULL;
5982                         } else {
5983                                 ret->info2 = NULL;
5984                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, in, talloc_free(ret); return NULL;);
5985                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5986                                         PyErr_NoMemory();
5987                                         talloc_free(ret); return NULL;
5988                                 }
5989                                 ret->info2 = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(in);
5990                         }
5991                         break;
5992
5993                 case 501:
5994                         if (in == Py_None) {
5995                                 ret->info501 = NULL;
5996                         } else {
5997                                 ret->info501 = NULL;
5998                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, in, talloc_free(ret); return NULL;);
5999                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6000                                         PyErr_NoMemory();
6001                                         talloc_free(ret); return NULL;
6002                                 }
6003                                 ret->info501 = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(in);
6004                         }
6005                         break;
6006
6007                 case 502:
6008                         if (in == Py_None) {
6009                                 ret->info502 = NULL;
6010                         } else {
6011                                 ret->info502 = NULL;
6012                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, in, talloc_free(ret); return NULL;);
6013                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6014                                         PyErr_NoMemory();
6015                                         talloc_free(ret); return NULL;
6016                                 }
6017                                 ret->info502 = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(in);
6018                         }
6019                         break;
6020
6021                 case 1004:
6022                         if (in == Py_None) {
6023                                 ret->info1004 = NULL;
6024                         } else {
6025                                 ret->info1004 = NULL;
6026                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, in, talloc_free(ret); return NULL;);
6027                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6028                                         PyErr_NoMemory();
6029                                         talloc_free(ret); return NULL;
6030                                 }
6031                                 ret->info1004 = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(in);
6032                         }
6033                         break;
6034
6035                 case 1005:
6036                         if (in == Py_None) {
6037                                 ret->info1005 = NULL;
6038                         } else {
6039                                 ret->info1005 = NULL;
6040                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, in, talloc_free(ret); return NULL;);
6041                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6042                                         PyErr_NoMemory();
6043                                         talloc_free(ret); return NULL;
6044                                 }
6045                                 ret->info1005 = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(in);
6046                         }
6047                         break;
6048
6049                 case 1006:
6050                         if (in == Py_None) {
6051                                 ret->info1006 = NULL;
6052                         } else {
6053                                 ret->info1006 = NULL;
6054                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, in, talloc_free(ret); return NULL;);
6055                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6056                                         PyErr_NoMemory();
6057                                         talloc_free(ret); return NULL;
6058                                 }
6059                                 ret->info1006 = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(in);
6060                         }
6061                         break;
6062
6063                 case 1007:
6064                         if (in == Py_None) {
6065                                 ret->info1007 = NULL;
6066                         } else {
6067                                 ret->info1007 = NULL;
6068                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, in, talloc_free(ret); return NULL;);
6069                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6070                                         PyErr_NoMemory();
6071                                         talloc_free(ret); return NULL;
6072                                 }
6073                                 ret->info1007 = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(in);
6074                         }
6075                         break;
6076
6077                 case 1501:
6078                         if (in == Py_None) {
6079                                 ret->info1501 = NULL;
6080                         } else {
6081                                 ret->info1501 = NULL;
6082                                 PY_CHECK_TYPE(sec_desc_buf_Type, in, talloc_free(ret); return NULL;);
6083                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6084                                         PyErr_NoMemory();
6085                                         talloc_free(ret); return NULL;
6086                                 }
6087                                 ret->info1501 = (struct sec_desc_buf *)pytalloc_get_ptr(in);
6088                         }
6089                         break;
6090
6091                 default:
6092                         break;
6093
6094         }
6095
6096         return ret;
6097 }
6098
6099 static PyObject *py_import_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareCtr *in)
6100 {
6101         PyObject *ret;
6102
6103         switch (level) {
6104                 case 0:
6105                         if (in->ctr0 == NULL) {
6106                                 ret = Py_None;
6107                                 Py_INCREF(ret);
6108                         } else {
6109                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr0_Type, in->ctr0, in->ctr0);
6110                         }
6111                         return ret;
6112
6113                 case 1:
6114                         if (in->ctr1 == NULL) {
6115                                 ret = Py_None;
6116                                 Py_INCREF(ret);
6117                         } else {
6118                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1_Type, in->ctr1, in->ctr1);
6119                         }
6120                         return ret;
6121
6122                 case 2:
6123                         if (in->ctr2 == NULL) {
6124                                 ret = Py_None;
6125                                 Py_INCREF(ret);
6126                         } else {
6127                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr2_Type, in->ctr2, in->ctr2);
6128                         }
6129                         return ret;
6130
6131                 case 501:
6132                         if (in->ctr501 == NULL) {
6133                                 ret = Py_None;
6134                                 Py_INCREF(ret);
6135                         } else {
6136                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr501_Type, in->ctr501, in->ctr501);
6137                         }
6138                         return ret;
6139
6140                 case 502:
6141                         if (in->ctr502 == NULL) {
6142                                 ret = Py_None;
6143                                 Py_INCREF(ret);
6144                         } else {
6145                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr502_Type, in->ctr502, in->ctr502);
6146                         }
6147                         return ret;
6148
6149                 case 1004:
6150                         if (in->ctr1004 == NULL) {
6151                                 ret = Py_None;
6152                                 Py_INCREF(ret);
6153                         } else {
6154                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1004_Type, in->ctr1004, in->ctr1004);
6155                         }
6156                         return ret;
6157
6158                 case 1005:
6159                         if (in->ctr1005 == NULL) {
6160                                 ret = Py_None;
6161                                 Py_INCREF(ret);
6162                         } else {
6163                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1005_Type, in->ctr1005, in->ctr1005);
6164                         }
6165                         return ret;
6166
6167                 case 1006:
6168                         if (in->ctr1006 == NULL) {
6169                                 ret = Py_None;
6170                                 Py_INCREF(ret);
6171                         } else {
6172                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1006_Type, in->ctr1006, in->ctr1006);
6173                         }
6174                         return ret;
6175
6176                 case 1007:
6177                         if (in->ctr1007 == NULL) {
6178                                 ret = Py_None;
6179                                 Py_INCREF(ret);
6180                         } else {
6181                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1007_Type, in->ctr1007, in->ctr1007);
6182                         }
6183                         return ret;
6184
6185                 case 1501:
6186                         if (in->ctr1501 == NULL) {
6187                                 ret = Py_None;
6188                                 Py_INCREF(ret);
6189                         } else {
6190                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1501_Type, in->ctr1501, in->ctr1501);
6191                         }
6192                         return ret;
6193
6194                 default:
6195                         ret = Py_None;
6196                         Py_INCREF(ret);
6197                         return ret;
6198
6199         }
6200         PyErr_SetString(PyExc_TypeError, "unknown union level");
6201         return NULL;
6202 }
6203
6204 static union srvsvc_NetShareCtr *py_export_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
6205 {
6206         union srvsvc_NetShareCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetShareCtr);
6207         switch (level) {
6208                 case 0:
6209                         if (in == Py_None) {
6210                                 ret->ctr0 = NULL;
6211                         } else {
6212                                 ret->ctr0 = NULL;
6213                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr0_Type, in, talloc_free(ret); return NULL;);
6214                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6215                                         PyErr_NoMemory();
6216                                         talloc_free(ret); return NULL;
6217                                 }
6218                                 ret->ctr0 = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(in);
6219                         }
6220                         break;
6221
6222                 case 1:
6223                         if (in == Py_None) {
6224                                 ret->ctr1 = NULL;
6225                         } else {
6226                                 ret->ctr1 = NULL;
6227                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1_Type, in, talloc_free(ret); return NULL;);
6228                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6229                                         PyErr_NoMemory();
6230                                         talloc_free(ret); return NULL;
6231                                 }
6232                                 ret->ctr1 = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(in);
6233                         }
6234                         break;
6235
6236                 case 2:
6237                         if (in == Py_None) {
6238                                 ret->ctr2 = NULL;
6239                         } else {
6240                                 ret->ctr2 = NULL;
6241                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr2_Type, in, talloc_free(ret); return NULL;);
6242                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6243                                         PyErr_NoMemory();
6244                                         talloc_free(ret); return NULL;
6245                                 }
6246                                 ret->ctr2 = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(in);
6247                         }
6248                         break;
6249
6250                 case 501:
6251                         if (in == Py_None) {
6252                                 ret->ctr501 = NULL;
6253                         } else {
6254                                 ret->ctr501 = NULL;
6255                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr501_Type, in, talloc_free(ret); return NULL;);
6256                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6257                                         PyErr_NoMemory();
6258                                         talloc_free(ret); return NULL;
6259                                 }
6260                                 ret->ctr501 = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(in);
6261                         }
6262                         break;
6263
6264                 case 502:
6265                         if (in == Py_None) {
6266                                 ret->ctr502 = NULL;
6267                         } else {
6268                                 ret->ctr502 = NULL;
6269                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr502_Type, in, talloc_free(ret); return NULL;);
6270                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6271                                         PyErr_NoMemory();
6272                                         talloc_free(ret); return NULL;
6273                                 }
6274                                 ret->ctr502 = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(in);
6275                         }
6276                         break;
6277
6278                 case 1004:
6279                         if (in == Py_None) {
6280                                 ret->ctr1004 = NULL;
6281                         } else {
6282                                 ret->ctr1004 = NULL;
6283                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1004_Type, in, talloc_free(ret); return NULL;);
6284                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6285                                         PyErr_NoMemory();
6286                                         talloc_free(ret); return NULL;
6287                                 }
6288                                 ret->ctr1004 = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(in);
6289                         }
6290                         break;
6291
6292                 case 1005:
6293                         if (in == Py_None) {
6294                                 ret->ctr1005 = NULL;
6295                         } else {
6296                                 ret->ctr1005 = NULL;
6297                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1005_Type, in, talloc_free(ret); return NULL;);
6298                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6299                                         PyErr_NoMemory();
6300                                         talloc_free(ret); return NULL;
6301                                 }
6302                                 ret->ctr1005 = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(in);
6303                         }
6304                         break;
6305
6306                 case 1006:
6307                         if (in == Py_None) {
6308                                 ret->ctr1006 = NULL;
6309                         } else {
6310                                 ret->ctr1006 = NULL;
6311                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1006_Type, in, talloc_free(ret); return NULL;);
6312                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6313                                         PyErr_NoMemory();
6314                                         talloc_free(ret); return NULL;
6315                                 }
6316                                 ret->ctr1006 = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(in);
6317                         }
6318                         break;
6319
6320                 case 1007:
6321                         if (in == Py_None) {
6322                                 ret->ctr1007 = NULL;
6323                         } else {
6324                                 ret->ctr1007 = NULL;
6325                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1007_Type, in, talloc_free(ret); return NULL;);
6326                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6327                                         PyErr_NoMemory();
6328                                         talloc_free(ret); return NULL;
6329                                 }
6330                                 ret->ctr1007 = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(in);
6331                         }
6332                         break;
6333
6334                 case 1501:
6335                         if (in == Py_None) {
6336                                 ret->ctr1501 = NULL;
6337                         } else {
6338                                 ret->ctr1501 = NULL;
6339                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1501_Type, in, talloc_free(ret); return NULL;);
6340                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6341                                         PyErr_NoMemory();
6342                                         talloc_free(ret); return NULL;
6343                                 }
6344                                 ret->ctr1501 = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(in);
6345                         }
6346                         break;
6347
6348                 default:
6349                         break;
6350
6351         }
6352
6353         return ret;
6354 }
6355
6356
6357 static PyObject *py_srvsvc_NetShareInfoCtr_get_level(PyObject *obj, void *closure)
6358 {
6359         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
6360         PyObject *py_level;
6361         py_level = PyInt_FromLong(object->level);
6362         return py_level;
6363 }
6364
6365 static int py_srvsvc_NetShareInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
6366 {
6367         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_obj);
6368         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6369         object->level = PyInt_AsLong(value);
6370         return 0;
6371 }
6372
6373 static PyObject *py_srvsvc_NetShareInfoCtr_get_ctr(PyObject *obj, void *closure)
6374 {
6375         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
6376         PyObject *py_ctr;
6377         py_ctr = py_import_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
6378         if (py_ctr == NULL) {
6379                 return NULL;
6380         }
6381         return py_ctr;
6382 }
6383
6384 static int py_srvsvc_NetShareInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
6385 {
6386         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_obj);
6387         {
6388                 union srvsvc_NetShareCtr *ctr_switch_0;
6389                 ctr_switch_0 = py_export_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
6390                 if (ctr_switch_0 == NULL) {
6391                         return -1;
6392                 }
6393                 object->ctr = *ctr_switch_0;
6394         }
6395         return 0;
6396 }
6397
6398 static PyGetSetDef py_srvsvc_NetShareInfoCtr_getsetters[] = {
6399         { discard_const_p(char, "level"), py_srvsvc_NetShareInfoCtr_get_level, py_srvsvc_NetShareInfoCtr_set_level },
6400         { discard_const_p(char, "ctr"), py_srvsvc_NetShareInfoCtr_get_ctr, py_srvsvc_NetShareInfoCtr_set_ctr },
6401         { NULL }
6402 };
6403
6404 static PyObject *py_srvsvc_NetShareInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6405 {
6406         return pytalloc_new(struct srvsvc_NetShareInfoCtr, type);
6407 }
6408
6409
6410 static PyTypeObject srvsvc_NetShareInfoCtr_Type = {
6411         PyObject_HEAD_INIT(NULL) 0,
6412         .tp_name = "srvsvc.NetShareInfoCtr",
6413         .tp_getset = py_srvsvc_NetShareInfoCtr_getsetters,
6414         .tp_methods = NULL,
6415         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6416         .tp_basicsize = sizeof(pytalloc_Object),
6417         .tp_new = py_srvsvc_NetShareInfoCtr_new,
6418 };
6419
6420
6421 static PyObject *py_srvsvc_NetSrvInfo100_get_platform_id(PyObject *obj, void *closure)
6422 {
6423         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
6424         PyObject *py_platform_id;
6425         py_platform_id = PyInt_FromLong(object->platform_id);
6426         return py_platform_id;
6427 }
6428
6429 static int py_srvsvc_NetSrvInfo100_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6430 {
6431         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6432         if (PyLong_Check(value)) {
6433                 object->platform_id = PyLong_AsLongLong(value);
6434         } else if (PyInt_Check(value)) {
6435                 object->platform_id = PyInt_AsLong(value);
6436         } else {
6437                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6438                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6439                 return -1;
6440         }
6441         return 0;
6442 }
6443
6444 static PyObject *py_srvsvc_NetSrvInfo100_get_server_name(PyObject *obj, void *closure)
6445 {
6446         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
6447         PyObject *py_server_name;
6448         if (object->server_name == NULL) {
6449                 py_server_name = Py_None;
6450                 Py_INCREF(py_server_name);
6451         } else {
6452                 if (object->server_name == NULL) {
6453                         py_server_name = Py_None;
6454                         Py_INCREF(py_server_name);
6455                 } else {
6456                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6457                 }
6458         }
6459         return py_server_name;
6460 }
6461
6462 static int py_srvsvc_NetSrvInfo100_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6463 {
6464         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6465         if (value == Py_None) {
6466                 object->server_name = NULL;
6467         } else {
6468                 object->server_name = NULL;
6469                 if (PyUnicode_Check(value)) {
6470                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6471                 } else if (PyString_Check(value)) {
6472                         object->server_name = PyString_AS_STRING(value);
6473                 } else {
6474                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6475                         return -1;
6476                 }
6477         }
6478         return 0;
6479 }
6480
6481 static PyGetSetDef py_srvsvc_NetSrvInfo100_getsetters[] = {
6482         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo100_get_platform_id, py_srvsvc_NetSrvInfo100_set_platform_id },
6483         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo100_get_server_name, py_srvsvc_NetSrvInfo100_set_server_name },
6484         { NULL }
6485 };
6486
6487 static PyObject *py_srvsvc_NetSrvInfo100_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6488 {
6489         return pytalloc_new(struct srvsvc_NetSrvInfo100, type);
6490 }
6491
6492 static PyObject *py_srvsvc_NetSrvInfo100_ndr_pack(PyObject *py_obj)
6493 {
6494         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6495         DATA_BLOB blob;
6496         enum ndr_err_code err;
6497         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo100);
6498         if (err != NDR_ERR_SUCCESS) {
6499                 PyErr_SetNdrError(err);
6500                 return NULL;
6501         }
6502
6503         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6504 }
6505
6506 static PyObject *py_srvsvc_NetSrvInfo100_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
6507 {
6508         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6509         DATA_BLOB blob;
6510         int blob_length = 0;
6511         enum ndr_err_code err;
6512         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
6513         PyObject *allow_remaining_obj = NULL;
6514         bool allow_remaining = false;
6515
6516         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
6517                 discard_const_p(char *, kwnames),
6518                 &blob.data, &blob_length,
6519                 &allow_remaining_obj)) {
6520                 return NULL;
6521         }
6522         blob.length = blob_length;
6523
6524         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
6525                 allow_remaining = true;
6526         }
6527
6528         if (allow_remaining) {
6529                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
6530         } else {
6531                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
6532         }
6533         if (err != NDR_ERR_SUCCESS) {
6534                 PyErr_SetNdrError(err);
6535                 return NULL;
6536         }
6537
6538         Py_RETURN_NONE;
6539 }
6540
6541 static PyObject *py_srvsvc_NetSrvInfo100_ndr_print(PyObject *py_obj)
6542 {
6543         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6544         PyObject *ret;
6545         char *retstr;
6546
6547         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo100, "srvsvc_NetSrvInfo100", object);
6548         ret = PyString_FromString(retstr);
6549         talloc_free(retstr);
6550
6551         return ret;
6552 }
6553
6554 static PyMethodDef py_srvsvc_NetSrvInfo100_methods[] = {
6555         { "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6556         { "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
6557         { "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6558         { NULL, NULL, 0, NULL }
6559 };
6560
6561
6562 static PyTypeObject srvsvc_NetSrvInfo100_Type = {
6563         PyObject_HEAD_INIT(NULL) 0,
6564         .tp_name = "srvsvc.NetSrvInfo100",
6565         .tp_getset = py_srvsvc_NetSrvInfo100_getsetters,
6566         .tp_methods = py_srvsvc_NetSrvInfo100_methods,
6567         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6568         .tp_basicsize = sizeof(pytalloc_Object),
6569         .tp_new = py_srvsvc_NetSrvInfo100_new,
6570 };
6571
6572
6573 static PyObject *py_srvsvc_NetSrvInfo101_get_platform_id(PyObject *obj, void *closure)
6574 {
6575         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6576         PyObject *py_platform_id;
6577         py_platform_id = PyInt_FromLong(object->platform_id);
6578         return py_platform_id;
6579 }
6580
6581 static int py_srvsvc_NetSrvInfo101_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6582 {
6583         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6584         if (PyLong_Check(value)) {
6585                 object->platform_id = PyLong_AsLongLong(value);
6586         } else if (PyInt_Check(value)) {
6587                 object->platform_id = PyInt_AsLong(value);
6588         } else {
6589                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6590                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6591                 return -1;
6592         }
6593         return 0;
6594 }
6595
6596 static PyObject *py_srvsvc_NetSrvInfo101_get_server_name(PyObject *obj, void *closure)
6597 {
6598         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6599         PyObject *py_server_name;
6600         if (object->server_name == NULL) {
6601                 py_server_name = Py_None;
6602                 Py_INCREF(py_server_name);
6603         } else {
6604                 if (object->server_name == NULL) {
6605                         py_server_name = Py_None;
6606                         Py_INCREF(py_server_name);
6607                 } else {
6608                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6609                 }
6610         }
6611         return py_server_name;
6612 }
6613
6614 static int py_srvsvc_NetSrvInfo101_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6615 {
6616         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6617         if (value == Py_None) {
6618                 object->server_name = NULL;
6619         } else {
6620                 object->server_name = NULL;
6621                 if (PyUnicode_Check(value)) {
6622                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6623                 } else if (PyString_Check(value)) {
6624                         object->server_name = PyString_AS_STRING(value);
6625                 } else {
6626                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6627                         return -1;
6628                 }
6629         }
6630         return 0;
6631 }
6632
6633 static PyObject *py_srvsvc_NetSrvInfo101_get_version_major(PyObject *obj, void *closure)
6634 {
6635         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6636         PyObject *py_version_major;
6637         py_version_major = PyInt_FromLong(object->version_major);
6638         return py_version_major;
6639 }
6640
6641 static int py_srvsvc_NetSrvInfo101_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
6642 {
6643         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6644         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6645         object->version_major = PyInt_AsLong(value);
6646         return 0;
6647 }
6648
6649 static PyObject *py_srvsvc_NetSrvInfo101_get_version_minor(PyObject *obj, void *closure)
6650 {
6651         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6652         PyObject *py_version_minor;
6653         py_version_minor = PyInt_FromLong(object->version_minor);
6654         return py_version_minor;
6655 }
6656
6657 static int py_srvsvc_NetSrvInfo101_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
6658 {
6659         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6660         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6661         object->version_minor = PyInt_AsLong(value);
6662         return 0;
6663 }
6664
6665 static PyObject *py_srvsvc_NetSrvInfo101_get_server_type(PyObject *obj, void *closure)
6666 {
6667         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6668         PyObject *py_server_type;
6669         py_server_type = PyInt_FromLong(object->server_type);
6670         return py_server_type;
6671 }
6672
6673 static int py_srvsvc_NetSrvInfo101_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
6674 {
6675         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6676         if (PyLong_Check(value)) {
6677                 object->server_type = PyLong_AsLongLong(value);
6678         } else if (PyInt_Check(value)) {
6679                 object->server_type = PyInt_AsLong(value);
6680         } else {
6681                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6682                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6683                 return -1;
6684         }
6685         return 0;
6686 }
6687
6688 static PyObject *py_srvsvc_NetSrvInfo101_get_comment(PyObject *obj, void *closure)
6689 {
6690         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6691         PyObject *py_comment;
6692         if (object->comment == NULL) {
6693                 py_comment = Py_None;
6694                 Py_INCREF(py_comment);
6695         } else {
6696                 if (object->comment == NULL) {
6697                         py_comment = Py_None;
6698                         Py_INCREF(py_comment);
6699                 } else {
6700                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
6701                 }
6702         }
6703         return py_comment;
6704 }
6705
6706 static int py_srvsvc_NetSrvInfo101_set_comment(PyObject *py_obj, PyObject *value, void *closure)
6707 {
6708         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6709         if (value == Py_None) {
6710                 object->comment = NULL;
6711         } else {
6712                 object->comment = NULL;
6713                 if (PyUnicode_Check(value)) {
6714                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6715                 } else if (PyString_Check(value)) {
6716                         object->comment = PyString_AS_STRING(value);
6717                 } else {
6718                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6719                         return -1;
6720                 }
6721         }
6722         return 0;
6723 }
6724
6725 static PyGetSetDef py_srvsvc_NetSrvInfo101_getsetters[] = {
6726         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo101_get_platform_id, py_srvsvc_NetSrvInfo101_set_platform_id },
6727         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo101_get_server_name, py_srvsvc_NetSrvInfo101_set_server_name },
6728         { discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo101_get_version_major, py_srvsvc_NetSrvInfo101_set_version_major },
6729         { discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo101_get_version_minor, py_srvsvc_NetSrvInfo101_set_version_minor },
6730         { discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo101_get_server_type, py_srvsvc_NetSrvInfo101_set_server_type },
6731         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo101_get_comment, py_srvsvc_NetSrvInfo101_set_comment },
6732         { NULL }
6733 };
6734
6735 static PyObject *py_srvsvc_NetSrvInfo101_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6736 {
6737         return pytalloc_new(struct srvsvc_NetSrvInfo101, type);
6738 }
6739
6740 static PyObject *py_srvsvc_NetSrvInfo101_ndr_pack(PyObject *py_obj)
6741 {
6742         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6743         DATA_BLOB blob;
6744         enum ndr_err_code err;
6745         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo101);
6746         if (err != NDR_ERR_SUCCESS) {
6747                 PyErr_SetNdrError(err);
6748                 return NULL;
6749         }
6750
6751         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6752 }
6753
6754 static PyObject *py_srvsvc_NetSrvInfo101_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
6755 {
6756         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6757         DATA_BLOB blob;
6758         int blob_length = 0;
6759         enum ndr_err_code err;
6760         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
6761         PyObject *allow_remaining_obj = NULL;
6762         bool allow_remaining = false;
6763
6764         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
6765                 discard_const_p(char *, kwnames),
6766                 &blob.data, &blob_length,
6767                 &allow_remaining_obj)) {
6768                 return NULL;
6769         }
6770         blob.length = blob_length;
6771
6772         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
6773                 allow_remaining = true;
6774         }
6775
6776         if (allow_remaining) {
6777                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
6778         } else {
6779                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
6780         }
6781         if (err != NDR_ERR_SUCCESS) {
6782                 PyErr_SetNdrError(err);
6783                 return NULL;
6784         }
6785
6786         Py_RETURN_NONE;
6787 }
6788
6789 static PyObject *py_srvsvc_NetSrvInfo101_ndr_print(PyObject *py_obj)
6790 {
6791         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6792         PyObject *ret;
6793         char *retstr;
6794
6795         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo101, "srvsvc_NetSrvInfo101", object);
6796         ret = PyString_FromString(retstr);
6797         talloc_free(retstr);
6798
6799         return ret;
6800 }
6801
6802 static PyMethodDef py_srvsvc_NetSrvInfo101_methods[] = {
6803         { "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6804         { "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
6805         { "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6806         { NULL, NULL, 0, NULL }
6807 };
6808
6809
6810 static PyTypeObject srvsvc_NetSrvInfo101_Type = {
6811         PyObject_HEAD_INIT(NULL) 0,
6812         .tp_name = "srvsvc.NetSrvInfo101",
6813         .tp_getset = py_srvsvc_NetSrvInfo101_getsetters,
6814         .tp_methods = py_srvsvc_NetSrvInfo101_methods,
6815         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6816         .tp_basicsize = sizeof(pytalloc_Object),
6817         .tp_new = py_srvsvc_NetSrvInfo101_new,
6818 };
6819
6820
6821 static PyObject *py_srvsvc_NetSrvInfo102_get_platform_id(PyObject *obj, void *closure)
6822 {
6823         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6824         PyObject *py_platform_id;
6825         py_platform_id = PyInt_FromLong(object->platform_id);
6826         return py_platform_id;
6827 }
6828
6829 static int py_srvsvc_NetSrvInfo102_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6830 {
6831         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6832         if (PyLong_Check(value)) {
6833                 object->platform_id = PyLong_AsLongLong(value);
6834         } else if (PyInt_Check(value)) {
6835                 object->platform_id = PyInt_AsLong(value);
6836         } else {
6837                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6838                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6839                 return -1;
6840         }
6841         return 0;
6842 }
6843
6844 static PyObject *py_srvsvc_NetSrvInfo102_get_server_name(PyObject *obj, void *closure)
6845 {
6846         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6847         PyObject *py_server_name;
6848         if (object->server_name == NULL) {
6849                 py_server_name = Py_None;
6850                 Py_INCREF(py_server_name);
6851         } else {
6852                 if (object->server_name == NULL) {
6853                         py_server_name = Py_None;
6854                         Py_INCREF(py_server_name);
6855                 } else {
6856                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6857                 }
6858         }
6859         return py_server_name;
6860 }
6861
6862 static int py_srvsvc_NetSrvInfo102_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6863 {
6864         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6865         if (value == Py_None) {
6866                 object->server_name = NULL;
6867         } else {
6868                 object->server_name = NULL;
6869                 if (PyUnicode_Check(value)) {
6870                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6871                 } else if (PyString_Check(value)) {
6872                         object->server_name = PyString_AS_STRING(value);
6873                 } else {
6874                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6875                         return -1;
6876                 }
6877         }
6878         return 0;
6879 }
6880
6881 static PyObject *py_srvsvc_NetSrvInfo102_get_version_major(PyObject *obj, void *closure)
6882 {
6883         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6884         PyObject *py_version_major;
6885         py_version_major = PyInt_FromLong(object->version_major);
6886         return py_version_major;
6887 }
6888
6889 static int py_srvsvc_NetSrvInfo102_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
6890 {
6891         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6892         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6893         object->version_major = PyInt_AsLong(value);
6894         return 0;
6895 }
6896
6897 static PyObject *py_srvsvc_NetSrvInfo102_get_version_minor(PyObject *obj, void *closure)
6898 {
6899         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6900         PyObject *py_version_minor;
6901         py_version_minor = PyInt_FromLong(object->version_minor);
6902         return py_version_minor;
6903 }
6904
6905 static int py_srvsvc_NetSrvInfo102_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
6906 {
6907         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6908         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6909         object->version_minor = PyInt_AsLong(value);
6910         return 0;
6911 }
6912
6913 static PyObject *py_srvsvc_NetSrvInfo102_get_server_type(PyObject *obj, void *closure)
6914 {
6915         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6916         PyObject *py_server_type;
6917         py_server_type = PyInt_FromLong(object->server_type);
6918         return py_server_type;
6919 }
6920
6921 static int py_srvsvc_NetSrvInfo102_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
6922 {
6923         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6924         if (PyLong_Check(value)) {
6925                 object->server_type = PyLong_AsLongLong(value);
6926         } else if (PyInt_Check(value)) {
6927                 object->server_type = PyInt_AsLong(value);
6928         } else {
6929                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6930                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6931                 return -1;
6932         }
6933         return 0;
6934 }
6935
6936 static PyObject *py_srvsvc_NetSrvInfo102_get_comment(PyObject *obj, void *closure)
6937 {
6938         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6939         PyObject *py_comment;
6940         if (object->comment == NULL) {
6941                 py_comment = Py_None;
6942                 Py_INCREF(py_comment);
6943         } else {
6944                 if (object->comment == NULL) {
6945                         py_comment = Py_None;
6946                         Py_INCREF(py_comment);
6947                 } else {
6948                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
6949                 }
6950         }
6951         return py_comment;
6952 }
6953
6954 static int py_srvsvc_NetSrvInfo102_set_comment(PyObject *py_obj, PyObject *value, void *closure)
6955 {
6956         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6957         if (value == Py_None) {
6958                 object->comment = NULL;
6959         } else {
6960                 object->comment = NULL;
6961                 if (PyUnicode_Check(value)) {
6962                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6963                 } else if (PyString_Check(value)) {
6964                         object->comment = PyString_AS_STRING(value);
6965                 } else {
6966                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6967                         return -1;
6968                 }
6969         }
6970         return 0;
6971 }
6972
6973 static PyObject *py_srvsvc_NetSrvInfo102_get_users(PyObject *obj, void *closure)
6974 {
6975         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6976         PyObject *py_users;
6977         py_users = PyInt_FromLong(object->users);
6978         return py_users;
6979 }
6980
6981 static int py_srvsvc_NetSrvInfo102_set_users(PyObject *py_obj, PyObject *value, void *closure)
6982 {
6983         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6984         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6985         object->users = PyInt_AsLong(value);
6986         return 0;
6987 }
6988
6989 static PyObject *py_srvsvc_NetSrvInfo102_get_disc(PyObject *obj, void *closure)
6990 {
6991         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6992         PyObject *py_disc;
6993         py_disc = PyInt_FromLong(object->disc);
6994         return py_disc;
6995 }
6996
6997 static int py_srvsvc_NetSrvInfo102_set_disc(PyObject *py_obj, PyObject *value, void *closure)
6998 {
6999         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7000         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7001         object->disc = PyInt_AsLong(value);
7002         return 0;
7003 }
7004
7005 static PyObject *py_srvsvc_NetSrvInfo102_get_hidden(PyObject *obj, void *closure)
7006 {
7007         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7008         PyObject *py_hidden;
7009         py_hidden = PyInt_FromLong(object->hidden);
7010         return py_hidden;
7011 }
7012
7013 static int py_srvsvc_NetSrvInfo102_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
7014 {
7015         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7016         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7017         object->hidden = PyInt_AsLong(value);
7018         return 0;
7019 }
7020
7021 static PyObject *py_srvsvc_NetSrvInfo102_get_announce(PyObject *obj, void *closure)
7022 {
7023         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7024         PyObject *py_announce;
7025         py_announce = PyInt_FromLong(object->announce);
7026         return py_announce;
7027 }
7028
7029 static int py_srvsvc_NetSrvInfo102_set_announce(PyObject *py_obj, PyObject *value, void *closure)
7030 {
7031         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7032         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7033         object->announce = PyInt_AsLong(value);
7034         return 0;
7035 }
7036
7037 static PyObject *py_srvsvc_NetSrvInfo102_get_anndelta(PyObject *obj, void *closure)
7038 {
7039         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7040         PyObject *py_anndelta;
7041         py_anndelta = PyInt_FromLong(object->anndelta);
7042         return py_anndelta;
7043 }
7044
7045 static int py_srvsvc_NetSrvInfo102_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
7046 {
7047         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7048         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7049         object->anndelta = PyInt_AsLong(value);
7050         return 0;
7051 }
7052
7053 static PyObject *py_srvsvc_NetSrvInfo102_get_licenses(PyObject *obj, void *closure)
7054 {
7055         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7056         PyObject *py_licenses;
7057         py_licenses = PyInt_FromLong(object->licenses);
7058         return py_licenses;
7059 }
7060
7061 static int py_srvsvc_NetSrvInfo102_set_licenses(PyObject *py_obj, PyObject *value, void *closure)
7062 {
7063         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7064         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7065         object->licenses = PyInt_AsLong(value);
7066         return 0;
7067 }
7068
7069 static PyObject *py_srvsvc_NetSrvInfo102_get_userpath(PyObject *obj, void *closure)
7070 {
7071         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7072         PyObject *py_userpath;
7073         if (object->userpath == NULL) {
7074                 py_userpath = Py_None;
7075                 Py_INCREF(py_userpath);
7076         } else {
7077                 if (object->userpath == NULL) {
7078                         py_userpath = Py_None;
7079                         Py_INCREF(py_userpath);
7080                 } else {
7081                         py_userpath = PyUnicode_Decode(object->userpath, strlen(object->userpath), "utf-8", "ignore");
7082                 }
7083         }
7084         return py_userpath;
7085 }
7086
7087 static int py_srvsvc_NetSrvInfo102_set_userpath(PyObject *py_obj, PyObject *value, void *closure)
7088 {
7089         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7090         if (value == Py_None) {
7091                 object->userpath = NULL;
7092         } else {
7093                 object->userpath = NULL;
7094                 if (PyUnicode_Check(value)) {
7095                         object->userpath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7096                 } else if (PyString_Check(value)) {
7097                         object->userpath = PyString_AS_STRING(value);
7098                 } else {
7099                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7100                         return -1;
7101                 }
7102         }
7103         return 0;
7104 }
7105
7106 static PyGetSetDef py_srvsvc_NetSrvInfo102_getsetters[] = {
7107         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo102_get_platform_id, py_srvsvc_NetSrvInfo102_set_platform_id },
7108         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo102_get_server_name, py_srvsvc_NetSrvInfo102_set_server_name },
7109         { discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo102_get_version_major, py_srvsvc_NetSrvInfo102_set_version_major },
7110         { discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo102_get_version_minor, py_srvsvc_NetSrvInfo102_set_version_minor },
7111         { discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo102_get_server_type, py_srvsvc_NetSrvInfo102_set_server_type },
7112         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo102_get_comment, py_srvsvc_NetSrvInfo102_set_comment },
7113         { discard_const_p(char, "users"), py_srvsvc_NetSrvInfo102_get_users, py_srvsvc_NetSrvInfo102_set_users },
7114         { discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo102_get_disc, py_srvsvc_NetSrvInfo102_set_disc },
7115         { discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo102_get_hidden, py_srvsvc_NetSrvInfo102_set_hidden },
7116         { discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo102_get_announce, py_srvsvc_NetSrvInfo102_set_announce },
7117         { discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo102_get_anndelta, py_srvsvc_NetSrvInfo102_set_anndelta },
7118         { discard_const_p(char, "licenses"), py_srvsvc_NetSrvInfo102_get_licenses, py_srvsvc_NetSrvInfo102_set_licenses },
7119         { discard_const_p(char, "userpath"), py_srvsvc_NetSrvInfo102_get_userpath, py_srvsvc_NetSrvInfo102_set_userpath },
7120         { NULL }
7121 };
7122
7123 static PyObject *py_srvsvc_NetSrvInfo102_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
7124 {
7125         return pytalloc_new(struct srvsvc_NetSrvInfo102, type);
7126 }
7127
7128
7129 static PyTypeObject srvsvc_NetSrvInfo102_Type = {
7130         PyObject_HEAD_INIT(NULL) 0,
7131         .tp_name = "srvsvc.NetSrvInfo102",
7132         .tp_getset = py_srvsvc_NetSrvInfo102_getsetters,
7133         .tp_methods = NULL,
7134         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7135         .tp_basicsize = sizeof(pytalloc_Object),
7136         .tp_new = py_srvsvc_NetSrvInfo102_new,
7137 };
7138
7139
7140 static PyObject *py_srvsvc_NetSrvInfo402_get_ulist_mtime(PyObject *obj, void *closure)
7141 {
7142         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7143         PyObject *py_ulist_mtime;
7144         py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
7145         return py_ulist_mtime;
7146 }
7147
7148 static int py_srvsvc_NetSrvInfo402_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7149 {
7150         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7151         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7152         object->ulist_mtime = PyInt_AsLong(value);
7153         return 0;
7154 }
7155
7156 static PyObject *py_srvsvc_NetSrvInfo402_get_glist_mtime(PyObject *obj, void *closure)
7157 {
7158         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7159         PyObject *py_glist_mtime;
7160         py_glist_mtime = PyInt_FromLong(object->glist_mtime);
7161         return py_glist_mtime;
7162 }
7163
7164 static int py_srvsvc_NetSrvInfo402_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7165 {
7166         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7167         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7168         object->glist_mtime = PyInt_AsLong(value);
7169         return 0;
7170 }
7171
7172 static PyObject *py_srvsvc_NetSrvInfo402_get_alist_mtime(PyObject *obj, void *closure)
7173 {
7174         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7175         PyObject *py_alist_mtime;
7176         py_alist_mtime = PyInt_FromLong(object->alist_mtime);
7177         return py_alist_mtime;
7178 }
7179
7180 static int py_srvsvc_NetSrvInfo402_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7181 {
7182         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7183         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7184         object->alist_mtime = PyInt_AsLong(value);
7185         return 0;
7186 }
7187
7188 static PyObject *py_srvsvc_NetSrvInfo402_get_alerts(PyObject *obj, void *closure)
7189 {
7190         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7191         PyObject *py_alerts;
7192         if (object->alerts == NULL) {
7193                 py_alerts = Py_None;
7194                 Py_INCREF(py_alerts);
7195         } else {
7196                 if (object->alerts == NULL) {
7197                         py_alerts = Py_None;
7198                         Py_INCREF(py_alerts);
7199                 } else {
7200                         py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
7201                 }
7202         }
7203         return py_alerts;
7204 }
7205
7206 static int py_srvsvc_NetSrvInfo402_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
7207 {
7208         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7209         if (value == Py_None) {
7210                 object->alerts = NULL;
7211         } else {
7212                 object->alerts = NULL;
7213                 if (PyUnicode_Check(value)) {
7214                         object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7215                 } else if (PyString_Check(value)) {
7216                         object->alerts = PyString_AS_STRING(value);
7217                 } else {
7218                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7219                         return -1;
7220                 }
7221         }
7222         return 0;
7223 }
7224
7225 static PyObject *py_srvsvc_NetSrvInfo402_get_security(PyObject *obj, void *closure)
7226 {
7227         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7228         PyObject *py_security;
7229         py_security = PyInt_FromLong(object->security);
7230         return py_security;
7231 }
7232
7233 static int py_srvsvc_NetSrvInfo402_set_security(PyObject *py_obj, PyObject *value, void *closure)
7234 {
7235         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7236         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7237         object->security = PyInt_AsLong(value);
7238         return 0;
7239 }
7240
7241 static PyObject *py_srvsvc_NetSrvInfo402_get_numadmin(PyObject *obj, void *closure)
7242 {
7243         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7244         PyObject *py_numadmin;
7245         py_numadmin = PyInt_FromLong(object->numadmin);
7246         return py_numadmin;
7247 }
7248
7249 static int py_srvsvc_NetSrvInfo402_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
7250 {
7251         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7252         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7253         object->numadmin = PyInt_AsLong(value);
7254         return 0;
7255 }
7256
7257 static PyObject *py_srvsvc_NetSrvInfo402_get_lanmask(PyObject *obj, void *closure)
7258 {
7259         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7260         PyObject *py_lanmask;
7261         py_lanmask = PyInt_FromLong(object->lanmask);
7262         return py_lanmask;
7263 }
7264
7265 static int py_srvsvc_NetSrvInfo402_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
7266 {
7267         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7269         object->lanmask = PyInt_AsLong(value);
7270         return 0;
7271 }
7272
7273 static PyObject *py_srvsvc_NetSrvInfo402_get_guestaccount(PyObject *obj, void *closure)
7274 {
7275         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7276         PyObject *py_guestaccount;
7277         if (object->guestaccount == NULL) {
7278                 py_guestaccount = Py_None;
7279                 Py_INCREF(py_guestaccount);
7280         } else {
7281                 if (object->guestaccount == NULL) {
7282                         py_guestaccount = Py_None;
7283                         Py_INCREF(py_guestaccount);
7284                 } else {
7285                         py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
7286                 }
7287         }
7288         return py_guestaccount;
7289 }
7290
7291 static int py_srvsvc_NetSrvInfo402_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
7292 {
7293         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7294         if (value == Py_None) {
7295                 object->guestaccount = NULL;
7296         } else {
7297                 object->guestaccount = NULL;
7298                 if (PyUnicode_Check(value)) {
7299                         object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7300                 } else if (PyString_Check(value)) {
7301                         object->guestaccount = PyString_AS_STRING(value);
7302                 } else {
7303                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7304                         return -1;
7305                 }
7306         }
7307         return 0;
7308 }
7309
7310 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevs(PyObject *obj, void *closure)
7311 {
7312         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7313         PyObject *py_chdevs;
7314         py_chdevs = PyInt_FromLong(object->chdevs);
7315         return py_chdevs;
7316 }
7317
7318 static int py_srvsvc_NetSrvInfo402_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
7319 {
7320         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7321         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7322         object->chdevs = PyInt_AsLong(value);
7323         return 0;
7324 }
7325
7326 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevqs(PyObject *obj, void *closure)
7327 {
7328         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7329         PyObject *py_chdevqs;
7330         py_chdevqs = PyInt_FromLong(object->chdevqs);
7331         return py_chdevqs;
7332 }
7333
7334 static int py_srvsvc_NetSrvInfo402_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
7335 {
7336         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7337         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7338         object->chdevqs = PyInt_AsLong(value);
7339         return 0;
7340 }
7341
7342 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevjobs(PyObject *obj, void *closure)
7343 {
7344         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7345         PyObject *py_chdevjobs;
7346         py_chdevjobs = PyInt_FromLong(object->chdevjobs);
7347         return py_chdevjobs;
7348 }
7349
7350 static int py_srvsvc_NetSrvInfo402_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
7351 {
7352         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7353         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7354         object->chdevjobs = PyInt_AsLong(value);
7355         return 0;
7356 }
7357
7358 static PyObject *py_srvsvc_NetSrvInfo402_get_connections(PyObject *obj, void *closure)
7359 {
7360         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7361         PyObject *py_connections;
7362         py_connections = PyInt_FromLong(object->connections);
7363         return py_connections;
7364 }
7365
7366 static int py_srvsvc_NetSrvInfo402_set_connections(PyObject *py_obj, PyObject *value, void *closure)
7367 {
7368         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7369         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7370         object->connections = PyInt_AsLong(value);
7371         return 0;
7372 }
7373
7374 static PyObject *py_srvsvc_NetSrvInfo402_get_shares(PyObject *obj, void *closure)
7375 {
7376         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7377         PyObject *py_shares;
7378         py_shares = PyInt_FromLong(object->shares);
7379         return py_shares;
7380 }
7381
7382 static int py_srvsvc_NetSrvInfo402_set_shares(PyObject *py_obj, PyObject *value, void *closure)
7383 {
7384         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7385         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7386         object->shares = PyInt_AsLong(value);
7387         return 0;
7388 }
7389
7390 static PyObject *py_srvsvc_NetSrvInfo402_get_openfiles(PyObject *obj, void *closure)
7391 {
7392         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7393         PyObject *py_openfiles;
7394         py_openfiles = PyInt_FromLong(object->openfiles);
7395         return py_openfiles;
7396 }
7397
7398 static int py_srvsvc_NetSrvInfo402_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
7399 {
7400         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7401         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7402         object->openfiles = PyInt_AsLong(value);
7403         return 0;
7404 }
7405
7406 static PyObject *py_srvsvc_NetSrvInfo402_get_sessopen(PyObject *obj, void *closure)
7407 {
7408         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7409         PyObject *py_sessopen;
7410         py_sessopen = PyInt_FromLong(object->sessopen);
7411         return py_sessopen;
7412 }
7413
7414 static int py_srvsvc_NetSrvInfo402_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
7415 {
7416         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7417         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7418         object->sessopen = PyInt_AsLong(value);
7419         return 0;
7420 }
7421
7422 static PyObject *py_srvsvc_NetSrvInfo402_get_sesssvc(PyObject *obj, void *closure)
7423 {
7424         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7425         PyObject *py_sesssvc;
7426         py_sesssvc = PyInt_FromLong(object->sesssvc);
7427         return py_sesssvc;
7428 }
7429
7430 static int py_srvsvc_NetSrvInfo402_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
7431 {
7432         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7433         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7434         object->sesssvc = PyInt_AsLong(value);
7435         return 0;
7436 }
7437
7438 static PyObject *py_srvsvc_NetSrvInfo402_get_sessreqs(PyObject *obj, void *closure)
7439 {
7440         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7441         PyObject *py_sessreqs;
7442         py_sessreqs = PyInt_FromLong(object->sessreqs);
7443         return py_sessreqs;
7444 }
7445
7446 static int py_srvsvc_NetSrvInfo402_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
7447 {
7448         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7449         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7450         object->sessreqs = PyInt_AsLong(value);
7451         return 0;
7452 }
7453
7454 static PyObject *py_srvsvc_NetSrvInfo402_get_opensearch(PyObject *obj, void *closure)
7455 {
7456         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7457         PyObject *py_opensearch;
7458         py_opensearch = PyInt_FromLong(object->opensearch);
7459         return py_opensearch;
7460 }
7461
7462 static int py_srvsvc_NetSrvInfo402_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
7463 {
7464         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7465         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7466         object->opensearch = PyInt_AsLong(value);
7467         return 0;
7468 }
7469
7470 static PyObject *py_srvsvc_NetSrvInfo402_get_activelocks(PyObject *obj, void *closure)
7471 {
7472         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7473         PyObject *py_activelocks;
7474         py_activelocks = PyInt_FromLong(object->activelocks);
7475         return py_activelocks;
7476 }
7477
7478 static int py_srvsvc_NetSrvInfo402_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
7479 {
7480         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7481         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7482         object->activelocks = PyInt_AsLong(value);
7483         return 0;
7484 }
7485
7486 static PyObject *py_srvsvc_NetSrvInfo402_get_numreqbufs(PyObject *obj, void *closure)
7487 {
7488         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7489         PyObject *py_numreqbufs;
7490         py_numreqbufs = PyInt_FromLong(object->numreqbufs);
7491         return py_numreqbufs;
7492 }
7493
7494 static int py_srvsvc_NetSrvInfo402_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
7495 {
7496         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7497         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7498         object->numreqbufs = PyInt_AsLong(value);
7499         return 0;
7500 }
7501
7502 static PyObject *py_srvsvc_NetSrvInfo402_get_sizereqbufs(PyObject *obj, void *closure)
7503 {
7504         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7505         PyObject *py_sizereqbufs;
7506         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
7507         return py_sizereqbufs;
7508 }
7509
7510 static int py_srvsvc_NetSrvInfo402_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
7511 {
7512         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7513         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7514         object->sizereqbufs = PyInt_AsLong(value);
7515         return 0;
7516 }
7517
7518 static PyObject *py_srvsvc_NetSrvInfo402_get_numbigbufs(PyObject *obj, void *closure)
7519 {
7520         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7521         PyObject *py_numbigbufs;
7522         py_numbigbufs = PyInt_FromLong(object->numbigbufs);
7523         return py_numbigbufs;
7524 }
7525
7526 static int py_srvsvc_NetSrvInfo402_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
7527 {
7528         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7529         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7530         object->numbigbufs = PyInt_AsLong(value);
7531         return 0;
7532 }
7533
7534 static PyObject *py_srvsvc_NetSrvInfo402_get_numfiletasks(PyObject *obj, void *closure)
7535 {
7536         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7537         PyObject *py_numfiletasks;
7538         py_numfiletasks = PyInt_FromLong(object->numfiletasks);
7539         return py_numfiletasks;
7540 }
7541
7542 static int py_srvsvc_NetSrvInfo402_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
7543 {
7544         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7545         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7546         object->numfiletasks = PyInt_AsLong(value);
7547         return 0;
7548 }
7549
7550 static PyObject *py_srvsvc_NetSrvInfo402_get_alertsched(PyObject *obj, void *closure)
7551 {
7552         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7553         PyObject *py_alertsched;
7554         py_alertsched = PyInt_FromLong(object->alertsched);
7555         return py_alertsched;
7556 }
7557
7558 static int py_srvsvc_NetSrvInfo402_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
7559 {
7560         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7561         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7562         object->alertsched = PyInt_AsLong(value);
7563         return 0;
7564 }
7565
7566 static PyObject *py_srvsvc_NetSrvInfo402_get_erroralert(PyObject *obj, void *closure)
7567 {
7568         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7569         PyObject *py_erroralert;
7570         py_erroralert = PyInt_FromLong(object->erroralert);
7571         return py_erroralert;
7572 }
7573
7574 static int py_srvsvc_NetSrvInfo402_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
7575 {
7576         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7577         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7578         object->erroralert = PyInt_AsLong(value);
7579         return 0;
7580 }
7581
7582 static PyObject *py_srvsvc_NetSrvInfo402_get_logonalert(PyObject *obj, void *closure)
7583 {
7584         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7585         PyObject *py_logonalert;
7586         py_logonalert = PyInt_FromLong(object->logonalert);
7587         return py_logonalert;
7588 }
7589
7590 static int py_srvsvc_NetSrvInfo402_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
7591 {
7592         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7593         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7594         object->logonalert = PyInt_AsLong(value);
7595         return 0;
7596 }
7597
7598 static PyObject *py_srvsvc_NetSrvInfo402_get_accessalert(PyObject *obj, void *closure)
7599 {
7600         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7601         PyObject *py_accessalert;
7602         py_accessalert = PyInt_FromLong(object->accessalert);
7603         return py_accessalert;
7604 }
7605
7606 static int py_srvsvc_NetSrvInfo402_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
7607 {
7608         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7609         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7610         object->accessalert = PyInt_AsLong(value);
7611         return 0;
7612 }
7613
7614 static PyObject *py_srvsvc_NetSrvInfo402_get_diskalert(PyObject *obj, void *closure)
7615 {
7616         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7617         PyObject *py_diskalert;
7618         py_diskalert = PyInt_FromLong(object->diskalert);
7619         return py_diskalert;
7620 }
7621
7622 static int py_srvsvc_NetSrvInfo402_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
7623 {
7624         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7625         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7626         object->diskalert = PyInt_AsLong(value);
7627         return 0;
7628 }
7629
7630 static PyObject *py_srvsvc_NetSrvInfo402_get_netioalert(PyObject *obj, void *closure)
7631 {
7632         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7633         PyObject *py_netioalert;
7634         py_netioalert = PyInt_FromLong(object->netioalert);
7635         return py_netioalert;
7636 }
7637
7638 static int py_srvsvc_NetSrvInfo402_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
7639 {
7640         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7641         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7642         object->netioalert = PyInt_AsLong(value);
7643         return 0;
7644 }
7645
7646 static PyObject *py_srvsvc_NetSrvInfo402_get_maxaudits(PyObject *obj, void *closure)
7647 {
7648         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7649         PyObject *py_maxaudits;
7650         py_maxaudits = PyInt_FromLong(object->maxaudits);
7651         return py_maxaudits;
7652 }
7653
7654 static int py_srvsvc_NetSrvInfo402_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
7655 {
7656         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7657         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7658         object->maxaudits = PyInt_AsLong(value);
7659         return 0;
7660 }
7661
7662 static PyObject *py_srvsvc_NetSrvInfo402_get_srvheuristics(PyObject *obj, void *closure)
7663 {
7664         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7665         PyObject *py_srvheuristics;
7666         if (object->srvheuristics == NULL) {
7667                 py_srvheuristics = Py_None;
7668                 Py_INCREF(py_srvheuristics);
7669         } else {
7670                 if (object->srvheuristics == NULL) {
7671                         py_srvheuristics = Py_None;
7672                         Py_INCREF(py_srvheuristics);
7673                 } else {
7674                         py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
7675                 }
7676         }
7677         return py_srvheuristics;
7678 }
7679
7680 static int py_srvsvc_NetSrvInfo402_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
7681 {
7682         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7683         if (value == Py_None) {
7684                 object->srvheuristics = NULL;
7685         } else {
7686                 object->srvheuristics = NULL;
7687                 if (PyUnicode_Check(value)) {
7688                         object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7689                 } else if (PyString_Check(value)) {
7690                         object->srvheuristics = PyString_AS_STRING(value);
7691                 } else {
7692                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7693                         return -1;
7694                 }
7695         }
7696         return 0;
7697 }
7698
7699 static PyGetSetDef py_srvsvc_NetSrvInfo402_getsetters[] = {
7700         { discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo402_get_ulist_mtime, py_srvsvc_NetSrvInfo402_set_ulist_mtime },
7701         { discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo402_get_glist_mtime, py_srvsvc_NetSrvInfo402_set_glist_mtime },
7702         { discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo402_get_alist_mtime, py_srvsvc_NetSrvInfo402_set_alist_mtime },
7703         { discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo402_get_alerts, py_srvsvc_NetSrvInfo402_set_alerts },
7704         { discard_const_p(char, "security"), py_srvsvc_NetSrvInfo402_get_security, py_srvsvc_NetSrvInfo402_set_security },
7705         { discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo402_get_numadmin, py_srvsvc_NetSrvInfo402_set_numadmin },
7706         { discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo402_get_lanmask, py_srvsvc_NetSrvInfo402_set_lanmask },
7707         { discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo402_get_guestaccount, py_srvsvc_NetSrvInfo402_set_guestaccount },
7708         { discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo402_get_chdevs, py_srvsvc_NetSrvInfo402_set_chdevs },
7709         { discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo402_get_chdevqs, py_srvsvc_NetSrvInfo402_set_chdevqs },
7710         { discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo402_get_chdevjobs, py_srvsvc_NetSrvInfo402_set_chdevjobs },
7711         { discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo402_get_connections, py_srvsvc_NetSrvInfo402_set_connections },
7712         { discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo402_get_shares, py_srvsvc_NetSrvInfo402_set_shares },
7713         { discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo402_get_openfiles, py_srvsvc_NetSrvInfo402_set_openfiles },
7714         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo402_get_sessopen, py_srvsvc_NetSrvInfo402_set_sessopen },
7715         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo402_get_sesssvc, py_srvsvc_NetSrvInfo402_set_sesssvc },
7716         { discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo402_get_sessreqs, py_srvsvc_NetSrvInfo402_set_sessreqs },
7717         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo402_get_opensearch, py_srvsvc_NetSrvInfo402_set_opensearch },
7718         { discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo402_get_activelocks, py_srvsvc_NetSrvInfo402_set_activelocks },
7719         { discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo402_get_numreqbufs, py_srvsvc_NetSrvInfo402_set_numreqbufs },
7720         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo402_get_sizereqbufs, py_srvsvc_NetSrvInfo402_set_sizereqbufs },
7721         { discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo402_get_numbigbufs, py_srvsvc_NetSrvInfo402_set_numbigbufs },
7722         { discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo402_get_numfiletasks, py_srvsvc_NetSrvInfo402_set_numfiletasks },
7723         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo402_get_alertsched, py_srvsvc_NetSrvInfo402_set_alertsched },
7724         { discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo402_get_erroralert, py_srvsvc_NetSrvInfo402_set_erroralert },
7725         { discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo402_get_logonalert, py_srvsvc_NetSrvInfo402_set_logonalert },
7726         { discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo402_get_accessalert, py_srvsvc_NetSrvInfo402_set_accessalert },
7727         { discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo402_get_diskalert, py_srvsvc_NetSrvInfo402_set_diskalert },
7728         { discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo402_get_netioalert, py_srvsvc_NetSrvInfo402_set_netioalert },
7729         { discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo402_get_maxaudits, py_srvsvc_NetSrvInfo402_set_maxaudits },
7730         { discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo402_get_srvheuristics, py_srvsvc_NetSrvInfo402_set_srvheuristics },
7731         { NULL }
7732 };
7733
7734 static PyObject *py_srvsvc_NetSrvInfo402_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
7735 {
7736         return pytalloc_new(struct srvsvc_NetSrvInfo402, type);
7737 }
7738
7739
7740 static PyTypeObject srvsvc_NetSrvInfo402_Type = {
7741         PyObject_HEAD_INIT(NULL) 0,
7742         .tp_name = "srvsvc.NetSrvInfo402",
7743         .tp_getset = py_srvsvc_NetSrvInfo402_getsetters,
7744         .tp_methods = NULL,
7745         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7746         .tp_basicsize = sizeof(pytalloc_Object),
7747         .tp_new = py_srvsvc_NetSrvInfo402_new,
7748 };
7749
7750
7751 static PyObject *py_srvsvc_NetSrvInfo403_get_ulist_mtime(PyObject *obj, void *closure)
7752 {
7753         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7754         PyObject *py_ulist_mtime;
7755         py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
7756         return py_ulist_mtime;
7757 }
7758
7759 static int py_srvsvc_NetSrvInfo403_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7760 {
7761         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7762         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7763         object->ulist_mtime = PyInt_AsLong(value);
7764         return 0;
7765 }
7766
7767 static PyObject *py_srvsvc_NetSrvInfo403_get_glist_mtime(PyObject *obj, void *closure)
7768 {
7769         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7770         PyObject *py_glist_mtime;
7771         py_glist_mtime = PyInt_FromLong(object->glist_mtime);
7772         return py_glist_mtime;
7773 }
7774
7775 static int py_srvsvc_NetSrvInfo403_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7776 {
7777         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7778         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7779         object->glist_mtime = PyInt_AsLong(value);
7780         return 0;
7781 }
7782
7783 static PyObject *py_srvsvc_NetSrvInfo403_get_alist_mtime(PyObject *obj, void *closure)
7784 {
7785         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7786         PyObject *py_alist_mtime;
7787         py_alist_mtime = PyInt_FromLong(object->alist_mtime);
7788         return py_alist_mtime;
7789 }
7790
7791 static int py_srvsvc_NetSrvInfo403_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7792 {
7793         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7794         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7795         object->alist_mtime = PyInt_AsLong(value);
7796         return 0;
7797 }
7798
7799 static PyObject *py_srvsvc_NetSrvInfo403_get_alerts(PyObject *obj, void *closure)
7800 {
7801         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7802         PyObject *py_alerts;
7803         if (object->alerts == NULL) {
7804                 py_alerts = Py_None;
7805                 Py_INCREF(py_alerts);
7806         } else {
7807                 if (object->alerts == NULL) {
7808                         py_alerts = Py_None;
7809                         Py_INCREF(py_alerts);
7810                 } else {
7811                         py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
7812                 }
7813         }
7814         return py_alerts;
7815 }
7816
7817 static int py_srvsvc_NetSrvInfo403_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
7818 {
7819         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7820         if (value == Py_None) {
7821                 object->alerts = NULL;
7822         } else {
7823                 object->alerts = NULL;
7824                 if (PyUnicode_Check(value)) {
7825                         object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7826                 } else if (PyString_Check(value)) {
7827                         object->alerts = PyString_AS_STRING(value);
7828                 } else {
7829                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7830                         return -1;
7831                 }
7832         }
7833         return 0;
7834 }
7835
7836 static PyObject *py_srvsvc_NetSrvInfo403_get_security(PyObject *obj, void *closure)
7837 {
7838         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7839         PyObject *py_security;
7840         py_security = PyInt_FromLong(object->security);
7841         return py_security;
7842 }
7843
7844 static int py_srvsvc_NetSrvInfo403_set_security(PyObject *py_obj, PyObject *value, void *closure)
7845 {
7846         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7847         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7848         object->security = PyInt_AsLong(value);
7849         return 0;
7850 }
7851
7852 static PyObject *py_srvsvc_NetSrvInfo403_get_numadmin(PyObject *obj, void *closure)
7853 {
7854         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7855         PyObject *py_numadmin;
7856         py_numadmin = PyInt_FromLong(object->numadmin);
7857         return py_numadmin;
7858 }
7859
7860 static int py_srvsvc_NetSrvInfo403_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
7861 {
7862         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7863         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7864         object->numadmin = PyInt_AsLong(value);
7865         return 0;
7866 }
7867
7868 static PyObject *py_srvsvc_NetSrvInfo403_get_lanmask(PyObject *obj, void *closure)
7869 {
7870         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7871         PyObject *py_lanmask;
7872         py_lanmask = PyInt_FromLong(object->lanmask);
7873         return py_lanmask;
7874 }
7875
7876 static int py_srvsvc_NetSrvInfo403_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
7877 {
7878         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7879         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7880         object->lanmask = PyInt_AsLong(value);
7881         return 0;
7882 }
7883
7884 static PyObject *py_srvsvc_NetSrvInfo403_get_guestaccount(PyObject *obj, void *closure)
7885 {
7886         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7887         PyObject *py_guestaccount;
7888         if (object->guestaccount == NULL) {
7889                 py_guestaccount = Py_None;
7890                 Py_INCREF(py_guestaccount);
7891         } else {
7892                 if (object->guestaccount == NULL) {
7893                         py_guestaccount = Py_None;
7894                         Py_INCREF(py_guestaccount);
7895                 } else {
7896                         py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
7897                 }
7898         }
7899         return py_guestaccount;
7900 }
7901
7902 static int py_srvsvc_NetSrvInfo403_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
7903 {
7904         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7905         if (value == Py_None) {
7906                 object->guestaccount = NULL;
7907         } else {
7908                 object->guestaccount = NULL;
7909                 if (PyUnicode_Check(value)) {
7910                         object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7911                 } else if (PyString_Check(value)) {
7912                         object->guestaccount = PyString_AS_STRING(value);
7913                 } else {
7914                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7915                         return -1;
7916                 }
7917         }
7918         return 0;
7919 }
7920
7921 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevs(PyObject *obj, void *closure)
7922 {
7923         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7924         PyObject *py_chdevs;
7925         py_chdevs = PyInt_FromLong(object->chdevs);
7926         return py_chdevs;
7927 }
7928
7929 static int py_srvsvc_NetSrvInfo403_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
7930 {
7931         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7933         object->chdevs = PyInt_AsLong(value);
7934         return 0;
7935 }
7936
7937 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevqs(PyObject *obj, void *closure)
7938 {
7939         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7940         PyObject *py_chdevqs;
7941         py_chdevqs = PyInt_FromLong(object->chdevqs);
7942         return py_chdevqs;
7943 }
7944
7945 static int py_srvsvc_NetSrvInfo403_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
7946 {
7947         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7948         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7949         object->chdevqs = PyInt_AsLong(value);
7950         return 0;
7951 }
7952
7953 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevjobs(PyObject *obj, void *closure)
7954 {
7955         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7956         PyObject *py_chdevjobs;
7957         py_chdevjobs = PyInt_FromLong(object->chdevjobs);
7958         return py_chdevjobs;
7959 }
7960
7961 static int py_srvsvc_NetSrvInfo403_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
7962 {
7963         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7964         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7965         object->chdevjobs = PyInt_AsLong(value);
7966         return 0;
7967 }
7968
7969 static PyObject *py_srvsvc_NetSrvInfo403_get_connections(PyObject *obj, void *closure)
7970 {
7971         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7972         PyObject *py_connections;
7973         py_connections = PyInt_FromLong(object->connections);
7974         return py_connections;
7975 }
7976
7977 static int py_srvsvc_NetSrvInfo403_set_connections(PyObject *py_obj, PyObject *value, void *closure)
7978 {
7979         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7980         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7981         object->connections = PyInt_AsLong(value);
7982         return 0;
7983 }
7984
7985 static PyObject *py_srvsvc_NetSrvInfo403_get_shares(PyObject *obj, void *closure)
7986 {
7987         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7988         PyObject *py_shares;
7989         py_shares = PyInt_FromLong(object->shares);
7990         return py_shares;
7991 }
7992
7993 static int py_srvsvc_NetSrvInfo403_set_shares(PyObject *py_obj, PyObject *value, void *closure)
7994 {
7995         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7996         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7997         object->shares = PyInt_AsLong(value);
7998         return 0;
7999 }
8000
8001 static PyObject *py_srvsvc_NetSrvInfo403_get_openfiles(PyObject *obj, void *closure)
8002 {
8003         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8004         PyObject *py_openfiles;
8005         py_openfiles = PyInt_FromLong(object->openfiles);
8006         return py_openfiles;
8007 }
8008
8009 static int py_srvsvc_NetSrvInfo403_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
8010 {
8011         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8012         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8013         object->openfiles = PyInt_AsLong(value);
8014         return 0;
8015 }
8016
8017 static PyObject *py_srvsvc_NetSrvInfo403_get_sessopen(PyObject *obj, void *closure)
8018 {
8019         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8020         PyObject *py_sessopen;
8021         py_sessopen = PyInt_FromLong(object->sessopen);
8022         return py_sessopen;
8023 }
8024
8025 static int py_srvsvc_NetSrvInfo403_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8026 {
8027         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8028         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8029         object->sessopen = PyInt_AsLong(value);
8030         return 0;
8031 }
8032
8033 static PyObject *py_srvsvc_NetSrvInfo403_get_sesssvc(PyObject *obj, void *closure)
8034 {
8035         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8036         PyObject *py_sesssvc;
8037         py_sesssvc = PyInt_FromLong(object->sesssvc);
8038         return py_sesssvc;
8039 }
8040
8041 static int py_srvsvc_NetSrvInfo403_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8042 {
8043         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8044         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8045         object->sesssvc = PyInt_AsLong(value);
8046         return 0;
8047 }
8048
8049 static PyObject *py_srvsvc_NetSrvInfo403_get_sessreqs(PyObject *obj, void *closure)
8050 {
8051         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8052         PyObject *py_sessreqs;
8053         py_sessreqs = PyInt_FromLong(object->sessreqs);
8054         return py_sessreqs;
8055 }
8056
8057 static int py_srvsvc_NetSrvInfo403_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
8058 {
8059         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8060         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8061         object->sessreqs = PyInt_AsLong(value);
8062         return 0;
8063 }
8064
8065 static PyObject *py_srvsvc_NetSrvInfo403_get_opensearch(PyObject *obj, void *closure)
8066 {
8067         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8068         PyObject *py_opensearch;
8069         py_opensearch = PyInt_FromLong(object->opensearch);
8070         return py_opensearch;
8071 }
8072
8073 static int py_srvsvc_NetSrvInfo403_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8074 {
8075         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8076         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8077         object->opensearch = PyInt_AsLong(value);
8078         return 0;
8079 }
8080
8081 static PyObject *py_srvsvc_NetSrvInfo403_get_activelocks(PyObject *obj, void *closure)
8082 {
8083         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8084         PyObject *py_activelocks;
8085         py_activelocks = PyInt_FromLong(object->activelocks);
8086         return py_activelocks;
8087 }
8088
8089 static int py_srvsvc_NetSrvInfo403_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
8090 {
8091         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8092         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8093         object->activelocks = PyInt_AsLong(value);
8094         return 0;
8095 }
8096
8097 static PyObject *py_srvsvc_NetSrvInfo403_get_numreqbufs(PyObject *obj, void *closure)
8098 {
8099         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8100         PyObject *py_numreqbufs;
8101         py_numreqbufs = PyInt_FromLong(object->numreqbufs);
8102         return py_numreqbufs;
8103 }
8104
8105 static int py_srvsvc_NetSrvInfo403_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
8106 {
8107         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8108         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8109         object->numreqbufs = PyInt_AsLong(value);
8110         return 0;
8111 }
8112
8113 static PyObject *py_srvsvc_NetSrvInfo403_get_sizereqbufs(PyObject *obj, void *closure)
8114 {
8115         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8116         PyObject *py_sizereqbufs;
8117         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8118         return py_sizereqbufs;
8119 }
8120
8121 static int py_srvsvc_NetSrvInfo403_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8122 {
8123         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8124         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8125         object->sizereqbufs = PyInt_AsLong(value);
8126         return 0;
8127 }
8128
8129 static PyObject *py_srvsvc_NetSrvInfo403_get_numbigbufs(PyObject *obj, void *closure)
8130 {
8131         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8132         PyObject *py_numbigbufs;
8133         py_numbigbufs = PyInt_FromLong(object->numbigbufs);
8134         return py_numbigbufs;
8135 }
8136
8137 static int py_srvsvc_NetSrvInfo403_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
8138 {
8139         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8140         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8141         object->numbigbufs = PyInt_AsLong(value);
8142         return 0;
8143 }
8144
8145 static PyObject *py_srvsvc_NetSrvInfo403_get_numfiletasks(PyObject *obj, void *closure)
8146 {
8147         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8148         PyObject *py_numfiletasks;
8149         py_numfiletasks = PyInt_FromLong(object->numfiletasks);
8150         return py_numfiletasks;
8151 }
8152
8153 static int py_srvsvc_NetSrvInfo403_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
8154 {
8155         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8156         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8157         object->numfiletasks = PyInt_AsLong(value);
8158         return 0;
8159 }
8160
8161 static PyObject *py_srvsvc_NetSrvInfo403_get_alertsched(PyObject *obj, void *closure)
8162 {
8163         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8164         PyObject *py_alertsched;
8165         py_alertsched = PyInt_FromLong(object->alertsched);
8166         return py_alertsched;
8167 }
8168
8169 static int py_srvsvc_NetSrvInfo403_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
8170 {
8171         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8172         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8173         object->alertsched = PyInt_AsLong(value);
8174         return 0;
8175 }
8176
8177 static PyObject *py_srvsvc_NetSrvInfo403_get_erroralert(PyObject *obj, void *closure)
8178 {
8179         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8180         PyObject *py_erroralert;
8181         py_erroralert = PyInt_FromLong(object->erroralert);
8182         return py_erroralert;
8183 }
8184
8185 static int py_srvsvc_NetSrvInfo403_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
8186 {
8187         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8188         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8189         object->erroralert = PyInt_AsLong(value);
8190         return 0;
8191 }
8192
8193 static PyObject *py_srvsvc_NetSrvInfo403_get_logonalert(PyObject *obj, void *closure)
8194 {
8195         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8196         PyObject *py_logonalert;
8197         py_logonalert = PyInt_FromLong(object->logonalert);
8198         return py_logonalert;
8199 }
8200
8201 static int py_srvsvc_NetSrvInfo403_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
8202 {
8203         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8204         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8205         object->logonalert = PyInt_AsLong(value);
8206         return 0;
8207 }
8208
8209 static PyObject *py_srvsvc_NetSrvInfo403_get_accessalert(PyObject *obj, void *closure)
8210 {
8211         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8212         PyObject *py_accessalert;
8213         py_accessalert = PyInt_FromLong(object->accessalert);
8214         return py_accessalert;
8215 }
8216
8217 static int py_srvsvc_NetSrvInfo403_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
8218 {
8219         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8220         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8221         object->accessalert = PyInt_AsLong(value);
8222         return 0;
8223 }
8224
8225 static PyObject *py_srvsvc_NetSrvInfo403_get_diskalert(PyObject *obj, void *closure)
8226 {
8227         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8228         PyObject *py_diskalert;
8229         py_diskalert = PyInt_FromLong(object->diskalert);
8230         return py_diskalert;
8231 }
8232
8233 static int py_srvsvc_NetSrvInfo403_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
8234 {
8235         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8236         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8237         object->diskalert = PyInt_AsLong(value);
8238         return 0;
8239 }
8240
8241 static PyObject *py_srvsvc_NetSrvInfo403_get_netioalert(PyObject *obj, void *closure)
8242 {
8243         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8244         PyObject *py_netioalert;
8245         py_netioalert = PyInt_FromLong(object->netioalert);
8246         return py_netioalert;
8247 }
8248
8249 static int py_srvsvc_NetSrvInfo403_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
8250 {
8251         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8252         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8253         object->netioalert = PyInt_AsLong(value);
8254         return 0;
8255 }
8256
8257 static PyObject *py_srvsvc_NetSrvInfo403_get_maxaudits(PyObject *obj, void *closure)
8258 {
8259         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8260         PyObject *py_maxaudits;
8261         py_maxaudits = PyInt_FromLong(object->maxaudits);
8262         return py_maxaudits;
8263 }
8264
8265 static int py_srvsvc_NetSrvInfo403_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
8266 {
8267         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8269         object->maxaudits = PyInt_AsLong(value);
8270         return 0;
8271 }
8272
8273 static PyObject *py_srvsvc_NetSrvInfo403_get_srvheuristics(PyObject *obj, void *closure)
8274 {
8275         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8276         PyObject *py_srvheuristics;
8277         if (object->srvheuristics == NULL) {
8278                 py_srvheuristics = Py_None;
8279                 Py_INCREF(py_srvheuristics);
8280         } else {
8281                 if (object->srvheuristics == NULL) {
8282                         py_srvheuristics = Py_None;
8283                         Py_INCREF(py_srvheuristics);
8284                 } else {
8285                         py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
8286                 }
8287         }
8288         return py_srvheuristics;
8289 }
8290
8291 static int py_srvsvc_NetSrvInfo403_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
8292 {
8293         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8294         if (value == Py_None) {
8295                 object->srvheuristics = NULL;
8296         } else {
8297                 object->srvheuristics = NULL;
8298                 if (PyUnicode_Check(value)) {
8299                         object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
8300                 } else if (PyString_Check(value)) {
8301                         object->srvheuristics = PyString_AS_STRING(value);
8302                 } else {
8303                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
8304                         return -1;
8305                 }
8306         }
8307         return 0;
8308 }
8309
8310 static PyObject *py_srvsvc_NetSrvInfo403_get_auditedevents(PyObject *obj, void *closure)
8311 {
8312         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8313         PyObject *py_auditedevents;
8314         py_auditedevents = PyInt_FromLong(object->auditedevents);
8315         return py_auditedevents;
8316 }
8317
8318 static int py_srvsvc_NetSrvInfo403_set_auditedevents(PyObject *py_obj, PyObject *value, void *closure)
8319 {
8320         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8321         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8322         object->auditedevents = PyInt_AsLong(value);
8323         return 0;
8324 }
8325
8326 static PyObject *py_srvsvc_NetSrvInfo403_get_auditprofile(PyObject *obj, void *closure)
8327 {
8328         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8329         PyObject *py_auditprofile;
8330         py_auditprofile = PyInt_FromLong(object->auditprofile);
8331         return py_auditprofile;
8332 }
8333
8334 static int py_srvsvc_NetSrvInfo403_set_auditprofile(PyObject *py_obj, PyObject *value, void *closure)
8335 {
8336         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8337         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8338         object->auditprofile = PyInt_AsLong(value);
8339         return 0;
8340 }
8341
8342 static PyObject *py_srvsvc_NetSrvInfo403_get_autopath(PyObject *obj, void *closure)
8343 {
8344         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8345         PyObject *py_autopath;
8346         if (object->autopath == NULL) {
8347                 py_autopath = Py_None;
8348                 Py_INCREF(py_autopath);
8349         } else {
8350                 if (object->autopath == NULL) {
8351                         py_autopath = Py_None;
8352                         Py_INCREF(py_autopath);
8353                 } else {
8354                         py_autopath = PyUnicode_Decode(object->autopath, strlen(object->autopath), "utf-8", "ignore");
8355                 }
8356         }
8357         return py_autopath;
8358 }
8359
8360 static int py_srvsvc_NetSrvInfo403_set_autopath(PyObject *py_obj, PyObject *value, void *closure)
8361 {
8362         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8363         if (value == Py_None) {
8364                 object->autopath = NULL;
8365         } else {
8366                 object->autopath = NULL;
8367                 if (PyUnicode_Check(value)) {
8368                         object->autopath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
8369                 } else if (PyString_Check(value)) {
8370                         object->autopath = PyString_AS_STRING(value);
8371                 } else {
8372                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
8373                         return -1;
8374                 }
8375         }
8376         return 0;
8377 }
8378
8379 static PyGetSetDef py_srvsvc_NetSrvInfo403_getsetters[] = {
8380         { discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo403_get_ulist_mtime, py_srvsvc_NetSrvInfo403_set_ulist_mtime },
8381         { discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo403_get_glist_mtime, py_srvsvc_NetSrvInfo403_set_glist_mtime },
8382         { discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo403_get_alist_mtime, py_srvsvc_NetSrvInfo403_set_alist_mtime },
8383         { discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo403_get_alerts, py_srvsvc_NetSrvInfo403_set_alerts },
8384         { discard_const_p(char, "security"), py_srvsvc_NetSrvInfo403_get_security, py_srvsvc_NetSrvInfo403_set_security },
8385         { discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo403_get_numadmin, py_srvsvc_NetSrvInfo403_set_numadmin },
8386         { discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo403_get_lanmask, py_srvsvc_NetSrvInfo403_set_lanmask },
8387         { discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo403_get_guestaccount, py_srvsvc_NetSrvInfo403_set_guestaccount },
8388         { discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo403_get_chdevs, py_srvsvc_NetSrvInfo403_set_chdevs },
8389         { discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo403_get_chdevqs, py_srvsvc_NetSrvInfo403_set_chdevqs },
8390         { discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo403_get_chdevjobs, py_srvsvc_NetSrvInfo403_set_chdevjobs },
8391         { discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo403_get_connections, py_srvsvc_NetSrvInfo403_set_connections },
8392         { discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo403_get_shares, py_srvsvc_NetSrvInfo403_set_shares },
8393         { discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo403_get_openfiles, py_srvsvc_NetSrvInfo403_set_openfiles },
8394         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo403_get_sessopen, py_srvsvc_NetSrvInfo403_set_sessopen },
8395         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo403_get_sesssvc, py_srvsvc_NetSrvInfo403_set_sesssvc },
8396         { discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo403_get_sessreqs, py_srvsvc_NetSrvInfo403_set_sessreqs },
8397         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo403_get_opensearch, py_srvsvc_NetSrvInfo403_set_opensearch },
8398         { discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo403_get_activelocks, py_srvsvc_NetSrvInfo403_set_activelocks },
8399         { discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo403_get_numreqbufs, py_srvsvc_NetSrvInfo403_set_numreqbufs },
8400         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo403_get_sizereqbufs, py_srvsvc_NetSrvInfo403_set_sizereqbufs },
8401         { discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo403_get_numbigbufs, py_srvsvc_NetSrvInfo403_set_numbigbufs },
8402         { discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo403_get_numfiletasks, py_srvsvc_NetSrvInfo403_set_numfiletasks },
8403         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo403_get_alertsched, py_srvsvc_NetSrvInfo403_set_alertsched },
8404         { discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo403_get_erroralert, py_srvsvc_NetSrvInfo403_set_erroralert },
8405         { discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo403_get_logonalert, py_srvsvc_NetSrvInfo403_set_logonalert },
8406         { discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo403_get_accessalert, py_srvsvc_NetSrvInfo403_set_accessalert },
8407         { discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo403_get_diskalert, py_srvsvc_NetSrvInfo403_set_diskalert },
8408         { discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo403_get_netioalert, py_srvsvc_NetSrvInfo403_set_netioalert },
8409         { discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo403_get_maxaudits, py_srvsvc_NetSrvInfo403_set_maxaudits },
8410         { discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo403_get_srvheuristics, py_srvsvc_NetSrvInfo403_set_srvheuristics },
8411         { discard_const_p(char, "auditedevents"), py_srvsvc_NetSrvInfo403_get_auditedevents, py_srvsvc_NetSrvInfo403_set_auditedevents },
8412         { discard_const_p(char, "auditprofile"), py_srvsvc_NetSrvInfo403_get_auditprofile, py_srvsvc_NetSrvInfo403_set_auditprofile },
8413         { discard_const_p(char, "autopath"), py_srvsvc_NetSrvInfo403_get_autopath, py_srvsvc_NetSrvInfo403_set_autopath },
8414         { NULL }
8415 };
8416
8417 static PyObject *py_srvsvc_NetSrvInfo403_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
8418 {
8419         return pytalloc_new(struct srvsvc_NetSrvInfo403, type);
8420 }
8421
8422
8423 static PyTypeObject srvsvc_NetSrvInfo403_Type = {
8424         PyObject_HEAD_INIT(NULL) 0,
8425         .tp_name = "srvsvc.NetSrvInfo403",
8426         .tp_getset = py_srvsvc_NetSrvInfo403_getsetters,
8427         .tp_methods = NULL,
8428         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
8429         .tp_basicsize = sizeof(pytalloc_Object),
8430         .tp_new = py_srvsvc_NetSrvInfo403_new,
8431 };
8432
8433
8434 static PyObject *py_srvsvc_NetSrvInfo502_get_sessopen(PyObject *obj, void *closure)
8435 {
8436         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8437         PyObject *py_sessopen;
8438         py_sessopen = PyInt_FromLong(object->sessopen);
8439         return py_sessopen;
8440 }
8441
8442 static int py_srvsvc_NetSrvInfo502_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8443 {
8444         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8445         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8446         object->sessopen = PyInt_AsLong(value);
8447         return 0;
8448 }
8449
8450 static PyObject *py_srvsvc_NetSrvInfo502_get_sesssvc(PyObject *obj, void *closure)
8451 {
8452         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8453         PyObject *py_sesssvc;
8454         py_sesssvc = PyInt_FromLong(object->sesssvc);
8455         return py_sesssvc;
8456 }
8457
8458 static int py_srvsvc_NetSrvInfo502_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8459 {
8460         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8461         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8462         object->sesssvc = PyInt_AsLong(value);
8463         return 0;
8464 }
8465
8466 static PyObject *py_srvsvc_NetSrvInfo502_get_opensearch(PyObject *obj, void *closure)
8467 {
8468         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8469         PyObject *py_opensearch;
8470         py_opensearch = PyInt_FromLong(object->opensearch);
8471         return py_opensearch;
8472 }
8473
8474 static int py_srvsvc_NetSrvInfo502_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8475 {
8476         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8477         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8478         object->opensearch = PyInt_AsLong(value);
8479         return 0;
8480 }
8481
8482 static PyObject *py_srvsvc_NetSrvInfo502_get_sizereqbufs(PyObject *obj, void *closure)
8483 {
8484         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8485         PyObject *py_sizereqbufs;
8486         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8487         return py_sizereqbufs;
8488 }
8489
8490 static int py_srvsvc_NetSrvInfo502_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8491 {
8492         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8493         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8494         object->sizereqbufs = PyInt_AsLong(value);
8495         return 0;
8496 }
8497
8498 static PyObject *py_srvsvc_NetSrvInfo502_get_initworkitems(PyObject *obj, void *closure)
8499 {
8500         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8501         PyObject *py_initworkitems;
8502         py_initworkitems = PyInt_FromLong(object->initworkitems);
8503         return py_initworkitems;
8504 }
8505
8506 static int py_srvsvc_NetSrvInfo502_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
8507 {
8508         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8509         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8510         object->initworkitems = PyInt_AsLong(value);
8511         return 0;
8512 }
8513
8514 static PyObject *py_srvsvc_NetSrvInfo502_get_maxworkitems(PyObject *obj, void *closure)
8515 {
8516         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8517         PyObject *py_maxworkitems;
8518         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
8519         return py_maxworkitems;
8520 }
8521
8522 static int py_srvsvc_NetSrvInfo502_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
8523 {
8524         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8525         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8526         object->maxworkitems = PyInt_AsLong(value);
8527         return 0;
8528 }
8529
8530 static PyObject *py_srvsvc_NetSrvInfo502_get_rawworkitems(PyObject *obj, void *closure)
8531 {
8532         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8533         PyObject *py_rawworkitems;
8534         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
8535         return py_rawworkitems;
8536 }
8537
8538 static int py_srvsvc_NetSrvInfo502_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
8539 {
8540         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8541         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8542         object->rawworkitems = PyInt_AsLong(value);
8543         return 0;
8544 }
8545
8546 static PyObject *py_srvsvc_NetSrvInfo502_get_irpstacksize(PyObject *obj, void *closure)
8547 {
8548         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8549         PyObject *py_irpstacksize;
8550         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
8551         return py_irpstacksize;
8552 }
8553
8554 static int py_srvsvc_NetSrvInfo502_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
8555 {
8556         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8557         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8558         object->irpstacksize = PyInt_AsLong(value);
8559         return 0;
8560 }
8561
8562 static PyObject *py_srvsvc_NetSrvInfo502_get_maxrawbuflen(PyObject *obj, void *closure)
8563 {
8564         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8565         PyObject *py_maxrawbuflen;
8566         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
8567         return py_maxrawbuflen;
8568 }
8569
8570 static int py_srvsvc_NetSrvInfo502_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
8571 {
8572         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8573         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8574         object->maxrawbuflen = PyInt_AsLong(value);
8575         return 0;
8576 }
8577
8578 static PyObject *py_srvsvc_NetSrvInfo502_get_sessusers(PyObject *obj, void *closure)
8579 {
8580         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8581         PyObject *py_sessusers;
8582         py_sessusers = PyInt_FromLong(object->sessusers);
8583         return py_sessusers;
8584 }
8585
8586 static int py_srvsvc_NetSrvInfo502_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
8587 {
8588         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8589         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8590         object->sessusers = PyInt_AsLong(value);
8591         return 0;
8592 }
8593
8594 static PyObject *py_srvsvc_NetSrvInfo502_get_sessconns(PyObject *obj, void *closure)
8595 {
8596         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8597         PyObject *py_sessconns;
8598         py_sessconns = PyInt_FromLong(object->sessconns);
8599         return py_sessconns;
8600 }
8601
8602 static int py_srvsvc_NetSrvInfo502_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
8603 {
8604         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8605         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8606         object->sessconns = PyInt_AsLong(value);
8607         return 0;
8608 }
8609
8610 static PyObject *py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage(PyObject *obj, void *closure)
8611 {
8612         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8613         PyObject *py_maxpagedmemoryusage;
8614         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
8615         return py_maxpagedmemoryusage;
8616 }
8617
8618 static int py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8619 {
8620         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8621         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8622         object->maxpagedmemoryusage = PyInt_AsLong(value);
8623         return 0;
8624 }
8625
8626 static PyObject *py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
8627 {
8628         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8629         PyObject *py_maxnonpagedmemoryusage;
8630         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
8631         return py_maxnonpagedmemoryusage;
8632 }
8633
8634 static int py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8635 {
8636         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8637         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8638         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
8639         return 0;
8640 }
8641
8642 static PyObject *py_srvsvc_NetSrvInfo502_get_enablesoftcompat(PyObject *obj, void *closure)
8643 {
8644         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8645         PyObject *py_enablesoftcompat;
8646         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
8647         return py_enablesoftcompat;
8648 }
8649
8650 static int py_srvsvc_NetSrvInfo502_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
8651 {
8652         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8653         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8654         object->enablesoftcompat = PyInt_AsLong(value);
8655         return 0;
8656 }
8657
8658 static PyObject *py_srvsvc_NetSrvInfo502_get_enableforcedlogoff(PyObject *obj, void *closure)
8659 {
8660         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8661         PyObject *py_enableforcedlogoff;
8662         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
8663         return py_enableforcedlogoff;
8664 }
8665
8666 static int py_srvsvc_NetSrvInfo502_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
8667 {
8668         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8669         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8670         object->enableforcedlogoff = PyInt_AsLong(value);
8671         return 0;
8672 }
8673
8674 static PyObject *py_srvsvc_NetSrvInfo502_get_timesource(PyObject *obj, void *closure)
8675 {
8676         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8677         PyObject *py_timesource;
8678         py_timesource = PyInt_FromLong(object->timesource);
8679         return py_timesource;
8680 }
8681
8682 static int py_srvsvc_NetSrvInfo502_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
8683 {
8684         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8685         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8686         object->timesource = PyInt_AsLong(value);
8687         return 0;
8688 }
8689
8690 static PyObject *py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis(PyObject *obj, void *closure)
8691 {
8692         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8693         PyObject *py_acceptdownlevelapis;
8694         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
8695         return py_acceptdownlevelapis;
8696 }
8697
8698 static int py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
8699 {
8700         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8701         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8702         object->acceptdownlevelapis = PyInt_AsLong(value);
8703         return 0;
8704 }
8705
8706 static PyObject *py_srvsvc_NetSrvInfo502_get_lmannounce(PyObject *obj, void *closure)
8707 {
8708         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8709         PyObject *py_lmannounce;
8710         py_lmannounce = PyInt_FromLong(object->lmannounce);
8711         return py_lmannounce;
8712 }
8713
8714 static int py_srvsvc_NetSrvInfo502_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
8715 {
8716         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8717         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8718         object->lmannounce = PyInt_AsLong(value);
8719         return 0;
8720 }
8721
8722 static PyGetSetDef py_srvsvc_NetSrvInfo502_getsetters[] = {
8723         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo502_get_sessopen, py_srvsvc_NetSrvInfo502_set_sessopen },
8724         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo502_get_sesssvc, py_srvsvc_NetSrvInfo502_set_sesssvc },
8725         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo502_get_opensearch, py_srvsvc_NetSrvInfo502_set_opensearch },
8726         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo502_get_sizereqbufs, py_srvsvc_NetSrvInfo502_set_sizereqbufs },
8727         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo502_get_initworkitems, py_srvsvc_NetSrvInfo502_set_initworkitems },
8728         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo502_get_maxworkitems, py_srvsvc_NetSrvInfo502_set_maxworkitems },
8729         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo502_get_rawworkitems, py_srvsvc_NetSrvInfo502_set_rawworkitems },
8730         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo502_get_irpstacksize, py_srvsvc_NetSrvInfo502_set_irpstacksize },
8731         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo502_get_maxrawbuflen, py_srvsvc_NetSrvInfo502_set_maxrawbuflen },
8732         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo502_get_sessusers, py_srvsvc_NetSrvInfo502_set_sessusers },
8733         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo502_get_sessconns, py_srvsvc_NetSrvInfo502_set_sessconns },
8734         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage },
8735         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage },
8736         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo502_get_enablesoftcompat, py_srvsvc_NetSrvInfo502_set_enablesoftcompat },
8737         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo502_get_enableforcedlogoff, py_srvsvc_NetSrvInfo502_set_enableforcedlogoff },
8738         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo502_get_timesource, py_srvsvc_NetSrvInfo502_set_timesource },
8739         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis },
8740         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo502_get_lmannounce, py_srvsvc_NetSrvInfo502_set_lmannounce },
8741         { NULL }
8742 };
8743
8744 static PyObject *py_srvsvc_NetSrvInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
8745 {
8746         return pytalloc_new(struct srvsvc_NetSrvInfo502, type);
8747 }
8748
8749
8750 static PyTypeObject srvsvc_NetSrvInfo502_Type = {
8751         PyObject_HEAD_INIT(NULL) 0,
8752         .tp_name = "srvsvc.NetSrvInfo502",
8753         .tp_getset = py_srvsvc_NetSrvInfo502_getsetters,
8754         .tp_methods = NULL,
8755         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
8756         .tp_basicsize = sizeof(pytalloc_Object),
8757         .tp_new = py_srvsvc_NetSrvInfo502_new,
8758 };
8759
8760
8761 static PyObject *py_srvsvc_NetSrvInfo503_get_sessopen(PyObject *obj, void *closure)
8762 {
8763         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8764         PyObject *py_sessopen;
8765         py_sessopen = PyInt_FromLong(object->sessopen);
8766         return py_sessopen;
8767 }
8768
8769 static int py_srvsvc_NetSrvInfo503_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8770 {
8771         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8772         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8773         object->sessopen = PyInt_AsLong(value);
8774         return 0;
8775 }
8776
8777 static PyObject *py_srvsvc_NetSrvInfo503_get_sesssvc(PyObject *obj, void *closure)
8778 {
8779         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8780         PyObject *py_sesssvc;
8781         py_sesssvc = PyInt_FromLong(object->sesssvc);
8782         return py_sesssvc;
8783 }
8784
8785 static int py_srvsvc_NetSrvInfo503_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8786 {
8787         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8788         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8789         object->sesssvc = PyInt_AsLong(value);
8790         return 0;
8791 }
8792
8793 static PyObject *py_srvsvc_NetSrvInfo503_get_opensearch(PyObject *obj, void *closure)
8794 {
8795         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8796         PyObject *py_opensearch;
8797         py_opensearch = PyInt_FromLong(object->opensearch);
8798         return py_opensearch;
8799 }
8800
8801 static int py_srvsvc_NetSrvInfo503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8802 {
8803         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8804         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8805         object->opensearch = PyInt_AsLong(value);
8806         return 0;
8807 }
8808
8809 static PyObject *py_srvsvc_NetSrvInfo503_get_sizereqbufs(PyObject *obj, void *closure)
8810 {
8811         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8812         PyObject *py_sizereqbufs;
8813         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8814         return py_sizereqbufs;
8815 }
8816
8817 static int py_srvsvc_NetSrvInfo503_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8818 {
8819         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8820         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8821         object->sizereqbufs = PyInt_AsLong(value);
8822         return 0;
8823 }
8824
8825 static PyObject *py_srvsvc_NetSrvInfo503_get_initworkitems(PyObject *obj, void *closure)
8826 {
8827         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8828         PyObject *py_initworkitems;
8829         py_initworkitems = PyInt_FromLong(object->initworkitems);
8830         return py_initworkitems;
8831 }
8832
8833 static int py_srvsvc_NetSrvInfo503_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
8834 {
8835         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8836         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8837         object->initworkitems = PyInt_AsLong(value);
8838         return 0;
8839 }
8840
8841 static PyObject *py_srvsvc_NetSrvInfo503_get_maxworkitems(PyObject *obj, void *closure)
8842 {
8843         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8844         PyObject *py_maxworkitems;
8845         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
8846         return py_maxworkitems;
8847 }
8848
8849 static int py_srvsvc_NetSrvInfo503_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
8850 {
8851         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8852         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8853         object->maxworkitems = PyInt_AsLong(value);
8854         return 0;
8855 }
8856
8857 static PyObject *py_srvsvc_NetSrvInfo503_get_rawworkitems(PyObject *obj, void *closure)
8858 {
8859         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8860         PyObject *py_rawworkitems;
8861         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
8862         return py_rawworkitems;
8863 }
8864
8865 static int py_srvsvc_NetSrvInfo503_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
8866 {
8867         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8868         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8869         object->rawworkitems = PyInt_AsLong(value);
8870         return 0;
8871 }
8872
8873 static PyObject *py_srvsvc_NetSrvInfo503_get_irpstacksize(PyObject *obj, void *closure)
8874 {
8875         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8876         PyObject *py_irpstacksize;
8877         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
8878         return py_irpstacksize;
8879 }
8880
8881 static int py_srvsvc_NetSrvInfo503_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
8882 {
8883         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8884         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8885         object->irpstacksize = PyInt_AsLong(value);
8886         return 0;
8887 }
8888
8889 static PyObject *py_srvsvc_NetSrvInfo503_get_maxrawbuflen(PyObject *obj, void *closure)
8890 {
8891         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8892         PyObject *py_maxrawbuflen;
8893         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
8894         return py_maxrawbuflen;
8895 }
8896
8897 static int py_srvsvc_NetSrvInfo503_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
8898 {
8899         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8900         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8901         object->maxrawbuflen = PyInt_AsLong(value);
8902         return 0;
8903 }
8904
8905 static PyObject *py_srvsvc_NetSrvInfo503_get_sessusers(PyObject *obj, void *closure)
8906 {
8907         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8908         PyObject *py_sessusers;
8909         py_sessusers = PyInt_FromLong(object->sessusers);
8910         return py_sessusers;
8911 }
8912
8913 static int py_srvsvc_NetSrvInfo503_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
8914 {
8915         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8916         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8917         object->sessusers = PyInt_AsLong(value);
8918         return 0;
8919 }
8920
8921 static PyObject *py_srvsvc_NetSrvInfo503_get_sessconns(PyObject *obj, void *closure)
8922 {
8923         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8924         PyObject *py_sessconns;
8925         py_sessconns = PyInt_FromLong(object->sessconns);
8926         return py_sessconns;
8927 }
8928
8929 static int py_srvsvc_NetSrvInfo503_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
8930 {
8931         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8933         object->sessconns = PyInt_AsLong(value);
8934         return 0;
8935 }
8936
8937 static PyObject *py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage(PyObject *obj, void *closure)
8938 {
8939         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8940         PyObject *py_maxpagedmemoryusage;
8941         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
8942         return py_maxpagedmemoryusage;
8943 }
8944
8945 static int py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8946 {
8947         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8948         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8949         object->maxpagedmemoryusage = PyInt_AsLong(value);
8950         return 0;
8951 }
8952
8953 static PyObject *py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
8954 {
8955         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8956         PyObject *py_maxnonpagedmemoryusage;
8957         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
8958         return py_maxnonpagedmemoryusage;
8959 }
8960
8961 static int py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8962 {
8963         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8964         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8965         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
8966         return 0;
8967 }
8968
8969 static PyObject *py_srvsvc_NetSrvInfo503_get_enablesoftcompat(PyObject *obj, void *closure)
8970 {
8971         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8972         PyObject *py_enablesoftcompat;
8973         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
8974         return py_enablesoftcompat;
8975 }
8976
8977 static int py_srvsvc_NetSrvInfo503_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
8978 {
8979         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8980         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8981         object->enablesoftcompat = PyInt_AsLong(value);
8982         return 0;
8983 }
8984
8985 static PyObject *py_srvsvc_NetSrvInfo503_get_enableforcedlogoff(PyObject *obj, void *closure)
8986 {
8987         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8988         PyObject *py_enableforcedlogoff;
8989         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
8990         return py_enableforcedlogoff;
8991 }
8992
8993 static int py_srvsvc_NetSrvInfo503_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
8994 {
8995         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8996         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8997         object->enableforcedlogoff = PyInt_AsLong(value);
8998         return 0;
8999 }
9000
9001 static PyObject *py_srvsvc_NetSrvInfo503_get_timesource(PyObject *obj, void *closure)
9002 {
9003         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9004         PyObject *py_timesource;
9005         py_timesource = PyInt_FromLong(object->timesource);
9006         return py_timesource;
9007 }
9008
9009 static int py_srvsvc_NetSrvInfo503_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
9010 {
9011         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9012         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9013         object->timesource = PyInt_AsLong(value);
9014         return 0;
9015 }
9016
9017 static PyObject *py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis(PyObject *obj, void *closure)
9018 {
9019         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9020         PyObject *py_acceptdownlevelapis;
9021         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
9022         return py_acceptdownlevelapis;
9023 }
9024
9025 static int py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
9026 {
9027         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9028         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9029         object->acceptdownlevelapis = PyInt_AsLong(value);
9030         return 0;
9031 }
9032
9033 static PyObject *py_srvsvc_NetSrvInfo503_get_lmannounce(PyObject *obj, void *closure)
9034 {
9035         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9036         PyObject *py_lmannounce;
9037         py_lmannounce = PyInt_FromLong(object->lmannounce);
9038         return py_lmannounce;
9039 }
9040
9041 static int py_srvsvc_NetSrvInfo503_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
9042 {
9043         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9044         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9045         object->lmannounce = PyInt_AsLong(value);
9046         return 0;
9047 }
9048
9049 static PyObject *py_srvsvc_NetSrvInfo503_get_domain(PyObject *obj, void *closure)
9050 {
9051         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9052         PyObject *py_domain;
9053         if (object->domain == NULL) {
9054                 py_domain = Py_None;
9055                 Py_INCREF(py_domain);
9056         } else {
9057                 if (object->domain == NULL) {
9058                         py_domain = Py_None;
9059                         Py_INCREF(py_domain);
9060                 } else {
9061                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
9062                 }
9063         }
9064         return py_domain;
9065 }
9066
9067 static int py_srvsvc_NetSrvInfo503_set_domain(PyObject *py_obj, PyObject *value, void *closure)
9068 {
9069         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9070         if (value == Py_None) {
9071                 object->domain = NULL;
9072         } else {
9073                 object->domain = NULL;
9074                 if (PyUnicode_Check(value)) {
9075                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
9076                 } else if (PyString_Check(value)) {
9077                         object->domain = PyString_AS_STRING(value);
9078                 } else {
9079                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
9080                         return -1;
9081                 }
9082         }
9083         return 0;
9084 }
9085
9086 static PyObject *py_srvsvc_NetSrvInfo503_get_maxcopyreadlen(PyObject *obj, void *closure)
9087 {
9088         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9089         PyObject *py_maxcopyreadlen;
9090         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
9091         return py_maxcopyreadlen;
9092 }
9093
9094 static int py_srvsvc_NetSrvInfo503_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
9095 {
9096         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9097         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9098         object->maxcopyreadlen = PyInt_AsLong(value);
9099         return 0;
9100 }
9101
9102 static PyObject *py_srvsvc_NetSrvInfo503_get_maxcopywritelen(PyObject *obj, void *closure)
9103 {
9104         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9105         PyObject *py_maxcopywritelen;
9106         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
9107         return py_maxcopywritelen;
9108 }
9109
9110 static int py_srvsvc_NetSrvInfo503_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
9111 {
9112         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9113         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9114         object->maxcopywritelen = PyInt_AsLong(value);
9115         return 0;
9116 }
9117
9118 static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepsearch(PyObject *obj, void *closure)
9119 {
9120         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9121         PyObject *py_minkeepsearch;
9122         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
9123         return py_minkeepsearch;
9124 }
9125
9126 static int py_srvsvc_NetSrvInfo503_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9127 {
9128         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9129         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9130         object->minkeepsearch = PyInt_AsLong(value);
9131         return 0;
9132 }
9133
9134 static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepsearch(PyObject *obj, void *closure)
9135 {
9136         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9137         PyObject *py_maxkeepsearch;
9138         py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
9139         return py_maxkeepsearch;
9140 }
9141
9142 static int py_srvsvc_NetSrvInfo503_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9143 {
9144         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9145         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9146         object->maxkeepsearch = PyInt_AsLong(value);
9147         return 0;
9148 }
9149
9150 static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch(PyObject *obj, void *closure)
9151 {
9152         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9153         PyObject *py_minkeepcomplsearch;
9154         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
9155         return py_minkeepcomplsearch;
9156 }
9157
9158 static int py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9159 {
9160         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9161         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9162         object->minkeepcomplsearch = PyInt_AsLong(value);
9163         return 0;
9164 }
9165
9166 static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch(PyObject *obj, void *closure)
9167 {
9168         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9169         PyObject *py_maxkeepcomplsearch;
9170         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
9171         return py_maxkeepcomplsearch;
9172 }
9173
9174 static int py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9175 {
9176         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9177         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9178         object->maxkeepcomplsearch = PyInt_AsLong(value);
9179         return 0;
9180 }
9181
9182 static PyObject *py_srvsvc_NetSrvInfo503_get_threadcountadd(PyObject *obj, void *closure)
9183 {
9184         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9185         PyObject *py_threadcountadd;
9186         py_threadcountadd = PyInt_FromLong(object->threadcountadd);
9187         return py_threadcountadd;
9188 }
9189
9190 static int py_srvsvc_NetSrvInfo503_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
9191 {
9192         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9193         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9194         object->threadcountadd = PyInt_AsLong(value);
9195         return 0;
9196 }
9197
9198 static PyObject *py_srvsvc_NetSrvInfo503_get_numlockthreads(PyObject *obj, void *closure)
9199 {
9200         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9201         PyObject *py_numlockthreads;
9202         py_numlockthreads = PyInt_FromLong(object->numlockthreads);
9203         return py_numlockthreads;
9204 }
9205
9206 static int py_srvsvc_NetSrvInfo503_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
9207 {
9208         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9209         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9210         object->numlockthreads = PyInt_AsLong(value);
9211         return 0;
9212 }
9213
9214 static PyObject *py_srvsvc_NetSrvInfo503_get_scavtimeout(PyObject *obj, void *closure)
9215 {
9216         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9217         PyObject *py_scavtimeout;
9218         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
9219         return py_scavtimeout;
9220 }
9221
9222 static int py_srvsvc_NetSrvInfo503_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
9223 {
9224         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9225         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9226         object->scavtimeout = PyInt_AsLong(value);
9227         return 0;
9228 }
9229
9230 static PyObject *py_srvsvc_NetSrvInfo503_get_minrcvqueue(PyObject *obj, void *closure)
9231 {
9232         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9233         PyObject *py_minrcvqueue;
9234         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
9235         return py_minrcvqueue;
9236 }
9237
9238 static int py_srvsvc_NetSrvInfo503_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
9239 {
9240         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9241         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9242         object->minrcvqueue = PyInt_AsLong(value);
9243         return 0;
9244 }
9245
9246 static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeworkitems(PyObject *obj, void *closure)
9247 {
9248         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9249         PyObject *py_minfreeworkitems;
9250         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
9251         return py_minfreeworkitems;
9252 }
9253
9254 static int py_srvsvc_NetSrvInfo503_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
9255 {
9256         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9257         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9258         object->minfreeworkitems = PyInt_AsLong(value);
9259         return 0;
9260 }
9261
9262 static PyObject *py_srvsvc_NetSrvInfo503_get_xactmemsize(PyObject *obj, void *closure)
9263 {
9264         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9265         PyObject *py_xactmemsize;
9266         py_xactmemsize = PyInt_FromLong(object->xactmemsize);
9267         return py_xactmemsize;
9268 }
9269
9270 static int py_srvsvc_NetSrvInfo503_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
9271 {
9272         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9273         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9274         object->xactmemsize = PyInt_AsLong(value);
9275         return 0;
9276 }
9277
9278 static PyObject *py_srvsvc_NetSrvInfo503_get_threadpriority(PyObject *obj, void *closure)
9279 {
9280         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9281         PyObject *py_threadpriority;
9282         py_threadpriority = PyInt_FromLong(object->threadpriority);
9283         return py_threadpriority;
9284 }
9285
9286 static int py_srvsvc_NetSrvInfo503_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
9287 {
9288         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9289         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9290         object->threadpriority = PyInt_AsLong(value);
9291         return 0;
9292 }
9293
9294 static PyObject *py_srvsvc_NetSrvInfo503_get_maxmpxct(PyObject *obj, void *closure)
9295 {
9296         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9297         PyObject *py_maxmpxct;
9298         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
9299         return py_maxmpxct;
9300 }
9301
9302 static int py_srvsvc_NetSrvInfo503_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
9303 {
9304         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9305         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9306         object->maxmpxct = PyInt_AsLong(value);
9307         return 0;
9308 }
9309
9310 static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakwait(PyObject *obj, void *closure)
9311 {
9312         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9313         PyObject *py_oplockbreakwait;
9314         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
9315         return py_oplockbreakwait;
9316 }
9317
9318 static int py_srvsvc_NetSrvInfo503_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
9319 {
9320         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9321         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9322         object->oplockbreakwait = PyInt_AsLong(value);
9323         return 0;
9324 }
9325
9326 static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait(PyObject *obj, void *closure)
9327 {
9328         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9329         PyObject *py_oplockbreakresponsewait;
9330         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
9331         return py_oplockbreakresponsewait;
9332 }
9333
9334 static int py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
9335 {
9336         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9337         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9338         object->oplockbreakresponsewait = PyInt_AsLong(value);
9339         return 0;
9340 }
9341
9342 static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplocks(PyObject *obj, void *closure)
9343 {
9344         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9345         PyObject *py_enableoplocks;
9346         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
9347         return py_enableoplocks;
9348 }
9349
9350 static int py_srvsvc_NetSrvInfo503_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
9351 {
9352         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9353         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9354         object->enableoplocks = PyInt_AsLong(value);
9355         return 0;
9356 }
9357
9358 static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplockforceclose(PyObject *obj, void *closure)
9359 {
9360         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9361         PyObject *py_enableoplockforceclose;
9362         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
9363         return py_enableoplockforceclose;
9364 }
9365
9366 static int py_srvsvc_NetSrvInfo503_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
9367 {
9368         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9369         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9370         object->enableoplockforceclose = PyInt_AsLong(value);
9371         return 0;
9372 }
9373
9374 static PyObject *py_srvsvc_NetSrvInfo503_get_enablefcbopens(PyObject *obj, void *closure)
9375 {
9376         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9377         PyObject *py_enablefcbopens;
9378         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
9379         return py_enablefcbopens;
9380 }
9381
9382 static int py_srvsvc_NetSrvInfo503_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
9383 {
9384         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9385         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9386         object->enablefcbopens = PyInt_AsLong(value);
9387         return 0;
9388 }
9389
9390 static PyObject *py_srvsvc_NetSrvInfo503_get_enableraw(PyObject *obj, void *closure)
9391 {
9392         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9393         PyObject *py_enableraw;
9394         py_enableraw = PyInt_FromLong(object->enableraw);
9395         return py_enableraw;
9396 }
9397
9398 static int py_srvsvc_NetSrvInfo503_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
9399 {
9400         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9401         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9402         object->enableraw = PyInt_AsLong(value);
9403         return 0;
9404 }
9405
9406 static PyObject *py_srvsvc_NetSrvInfo503_get_enablesharednetdrives(PyObject *obj, void *closure)
9407 {
9408         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9409         PyObject *py_enablesharednetdrives;
9410         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
9411         return py_enablesharednetdrives;
9412 }
9413
9414 static int py_srvsvc_NetSrvInfo503_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
9415 {
9416         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9417         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9418         object->enablesharednetdrives = PyInt_AsLong(value);
9419         return 0;
9420 }
9421
9422 static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeconnections(PyObject *obj, void *closure)
9423 {
9424         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9425         PyObject *py_minfreeconnections;
9426         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
9427         return py_minfreeconnections;
9428 }
9429
9430 static int py_srvsvc_NetSrvInfo503_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
9431 {
9432         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9433         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9434         object->minfreeconnections = PyInt_AsLong(value);
9435         return 0;
9436 }
9437
9438 static PyObject *py_srvsvc_NetSrvInfo503_get_maxfreeconnections(PyObject *obj, void *closure)
9439 {
9440         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9441         PyObject *py_maxfreeconnections;
9442         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
9443         return py_maxfreeconnections;
9444 }
9445
9446 static int py_srvsvc_NetSrvInfo503_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
9447 {
9448         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9449         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9450         object->maxfreeconnections = PyInt_AsLong(value);
9451         return 0;
9452 }
9453
9454 static PyGetSetDef py_srvsvc_NetSrvInfo503_getsetters[] = {
9455         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo503_get_sessopen, py_srvsvc_NetSrvInfo503_set_sessopen },
9456         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo503_get_sesssvc, py_srvsvc_NetSrvInfo503_set_sesssvc },
9457         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo503_get_opensearch, py_srvsvc_NetSrvInfo503_set_opensearch },
9458         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo503_get_sizereqbufs, py_srvsvc_NetSrvInfo503_set_sizereqbufs },
9459         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo503_get_initworkitems, py_srvsvc_NetSrvInfo503_set_initworkitems },
9460         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo503_get_maxworkitems, py_srvsvc_NetSrvInfo503_set_maxworkitems },
9461         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo503_get_rawworkitems, py_srvsvc_NetSrvInfo503_set_rawworkitems },
9462         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo503_get_irpstacksize, py_srvsvc_NetSrvInfo503_set_irpstacksize },
9463         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo503_get_maxrawbuflen, py_srvsvc_NetSrvInfo503_set_maxrawbuflen },
9464         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo503_get_sessusers, py_srvsvc_NetSrvInfo503_set_sessusers },
9465         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo503_get_sessconns, py_srvsvc_NetSrvInfo503_set_sessconns },
9466         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage },
9467         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage },
9468         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo503_get_enablesoftcompat, py_srvsvc_NetSrvInfo503_set_enablesoftcompat },
9469         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo503_get_enableforcedlogoff, py_srvsvc_NetSrvInfo503_set_enableforcedlogoff },
9470         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo503_get_timesource, py_srvsvc_NetSrvInfo503_set_timesource },
9471         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis },
9472         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo503_get_lmannounce, py_srvsvc_NetSrvInfo503_set_lmannounce },
9473         { discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo503_get_domain, py_srvsvc_NetSrvInfo503_set_domain },
9474         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo503_get_maxcopyreadlen, py_srvsvc_NetSrvInfo503_set_maxcopyreadlen },
9475         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo503_get_maxcopywritelen, py_srvsvc_NetSrvInfo503_set_maxcopywritelen },
9476         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo503_get_minkeepsearch, py_srvsvc_NetSrvInfo503_set_minkeepsearch },
9477         { discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepsearch, py_srvsvc_NetSrvInfo503_set_maxkeepsearch },
9478         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch },
9479         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch },
9480         { discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo503_get_threadcountadd, py_srvsvc_NetSrvInfo503_set_threadcountadd },
9481         { discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo503_get_numlockthreads, py_srvsvc_NetSrvInfo503_set_numlockthreads },
9482         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo503_get_scavtimeout, py_srvsvc_NetSrvInfo503_set_scavtimeout },
9483         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo503_get_minrcvqueue, py_srvsvc_NetSrvInfo503_set_minrcvqueue },
9484         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo503_get_minfreeworkitems, py_srvsvc_NetSrvInfo503_set_minfreeworkitems },
9485         { discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo503_get_xactmemsize, py_srvsvc_NetSrvInfo503_set_xactmemsize },
9486         { discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo503_get_threadpriority, py_srvsvc_NetSrvInfo503_set_threadpriority },
9487         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo503_get_maxmpxct, py_srvsvc_NetSrvInfo503_set_maxmpxct },
9488         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo503_get_oplockbreakwait, py_srvsvc_NetSrvInfo503_set_oplockbreakwait },
9489         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait },
9490         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo503_get_enableoplocks, py_srvsvc_NetSrvInfo503_set_enableoplocks },
9491         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo503_get_enableoplockforceclose, py_srvsvc_NetSrvInfo503_set_enableoplockforceclose },
9492         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo503_get_enablefcbopens, py_srvsvc_NetSrvInfo503_set_enablefcbopens },
9493         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo503_get_enableraw, py_srvsvc_NetSrvInfo503_set_enableraw },
9494         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo503_get_enablesharednetdrives, py_srvsvc_NetSrvInfo503_set_enablesharednetdrives },
9495         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo503_get_minfreeconnections, py_srvsvc_NetSrvInfo503_set_minfreeconnections },
9496         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo503_get_maxfreeconnections, py_srvsvc_NetSrvInfo503_set_maxfreeconnections },
9497         { NULL }
9498 };
9499
9500 static PyObject *py_srvsvc_NetSrvInfo503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
9501 {
9502         return pytalloc_new(struct srvsvc_NetSrvInfo503, type);
9503 }
9504
9505
9506 static PyTypeObject srvsvc_NetSrvInfo503_Type = {
9507         PyObject_HEAD_INIT(NULL) 0,
9508         .tp_name = "srvsvc.NetSrvInfo503",
9509         .tp_getset = py_srvsvc_NetSrvInfo503_getsetters,
9510         .tp_methods = NULL,
9511         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
9512         .tp_basicsize = sizeof(pytalloc_Object),
9513         .tp_new = py_srvsvc_NetSrvInfo503_new,
9514 };
9515
9516
9517 static PyObject *py_srvsvc_NetSrvInfo599_get_sessopen(PyObject *obj, void *closure)
9518 {
9519         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9520         PyObject *py_sessopen;
9521         py_sessopen = PyInt_FromLong(object->sessopen);
9522         return py_sessopen;
9523 }
9524
9525 static int py_srvsvc_NetSrvInfo599_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
9526 {
9527         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9528         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9529         object->sessopen = PyInt_AsLong(value);
9530         return 0;
9531 }
9532
9533 static PyObject *py_srvsvc_NetSrvInfo599_get_sesssvc(PyObject *obj, void *closure)
9534 {
9535         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9536         PyObject *py_sesssvc;
9537         py_sesssvc = PyInt_FromLong(object->sesssvc);
9538         return py_sesssvc;
9539 }
9540
9541 static int py_srvsvc_NetSrvInfo599_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
9542 {
9543         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9544         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9545         object->sesssvc = PyInt_AsLong(value);
9546         return 0;
9547 }
9548
9549 static PyObject *py_srvsvc_NetSrvInfo599_get_opensearch(PyObject *obj, void *closure)
9550 {
9551         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9552         PyObject *py_opensearch;
9553         py_opensearch = PyInt_FromLong(object->opensearch);
9554         return py_opensearch;
9555 }
9556
9557 static int py_srvsvc_NetSrvInfo599_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
9558 {
9559         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9560         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9561         object->opensearch = PyInt_AsLong(value);
9562         return 0;
9563 }
9564
9565 static PyObject *py_srvsvc_NetSrvInfo599_get_sizereqbufs(PyObject *obj, void *closure)
9566 {
9567         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9568         PyObject *py_sizereqbufs;
9569         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
9570         return py_sizereqbufs;
9571 }
9572
9573 static int py_srvsvc_NetSrvInfo599_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
9574 {
9575         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9576         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9577         object->sizereqbufs = PyInt_AsLong(value);
9578         return 0;
9579 }
9580
9581 static PyObject *py_srvsvc_NetSrvInfo599_get_initworkitems(PyObject *obj, void *closure)
9582 {
9583         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9584         PyObject *py_initworkitems;
9585         py_initworkitems = PyInt_FromLong(object->initworkitems);
9586         return py_initworkitems;
9587 }
9588
9589 static int py_srvsvc_NetSrvInfo599_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
9590 {
9591         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9592         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9593         object->initworkitems = PyInt_AsLong(value);
9594         return 0;
9595 }
9596
9597 static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitems(PyObject *obj, void *closure)
9598 {
9599         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9600         PyObject *py_maxworkitems;
9601         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
9602         return py_maxworkitems;
9603 }
9604
9605 static int py_srvsvc_NetSrvInfo599_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
9606 {
9607         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9608         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9609         object->maxworkitems = PyInt_AsLong(value);
9610         return 0;
9611 }
9612
9613 static PyObject *py_srvsvc_NetSrvInfo599_get_rawworkitems(PyObject *obj, void *closure)
9614 {
9615         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9616         PyObject *py_rawworkitems;
9617         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
9618         return py_rawworkitems;
9619 }
9620
9621 static int py_srvsvc_NetSrvInfo599_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
9622 {
9623         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9624         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9625         object->rawworkitems = PyInt_AsLong(value);
9626         return 0;
9627 }
9628
9629 static PyObject *py_srvsvc_NetSrvInfo599_get_irpstacksize(PyObject *obj, void *closure)
9630 {
9631         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9632         PyObject *py_irpstacksize;
9633         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
9634         return py_irpstacksize;
9635 }
9636
9637 static int py_srvsvc_NetSrvInfo599_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
9638 {
9639         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9640         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9641         object->irpstacksize = PyInt_AsLong(value);
9642         return 0;
9643 }
9644
9645 static PyObject *py_srvsvc_NetSrvInfo599_get_maxrawbuflen(PyObject *obj, void *closure)
9646 {
9647         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9648         PyObject *py_maxrawbuflen;
9649         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
9650         return py_maxrawbuflen;
9651 }
9652
9653 static int py_srvsvc_NetSrvInfo599_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
9654 {
9655         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9656         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9657         object->maxrawbuflen = PyInt_AsLong(value);
9658         return 0;
9659 }
9660
9661 static PyObject *py_srvsvc_NetSrvInfo599_get_sessusers(PyObject *obj, void *closure)
9662 {
9663         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9664         PyObject *py_sessusers;
9665         py_sessusers = PyInt_FromLong(object->sessusers);
9666         return py_sessusers;
9667 }
9668
9669 static int py_srvsvc_NetSrvInfo599_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
9670 {
9671         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9672         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9673         object->sessusers = PyInt_AsLong(value);
9674         return 0;
9675 }
9676
9677 static PyObject *py_srvsvc_NetSrvInfo599_get_sessconns(PyObject *obj, void *closure)
9678 {
9679         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9680         PyObject *py_sessconns;
9681         py_sessconns = PyInt_FromLong(object->sessconns);
9682         return py_sessconns;
9683 }
9684
9685 static int py_srvsvc_NetSrvInfo599_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
9686 {
9687         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9688         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9689         object->sessconns = PyInt_AsLong(value);
9690         return 0;
9691 }
9692
9693 static PyObject *py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage(PyObject *obj, void *closure)
9694 {
9695         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9696         PyObject *py_maxpagedmemoryusage;
9697         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
9698         return py_maxpagedmemoryusage;
9699 }
9700
9701 static int py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
9702 {
9703         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9704         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9705         object->maxpagedmemoryusage = PyInt_AsLong(value);
9706         return 0;
9707 }
9708
9709 static PyObject *py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
9710 {
9711         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9712         PyObject *py_maxnonpagedmemoryusage;
9713         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
9714         return py_maxnonpagedmemoryusage;
9715 }
9716
9717 static int py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
9718 {
9719         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9720         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9721         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
9722         return 0;
9723 }
9724
9725 static PyObject *py_srvsvc_NetSrvInfo599_get_enablesoftcompat(PyObject *obj, void *closure)
9726 {
9727         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9728         PyObject *py_enablesoftcompat;
9729         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
9730         return py_enablesoftcompat;
9731 }
9732
9733 static int py_srvsvc_NetSrvInfo599_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
9734 {
9735         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9736         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9737         object->enablesoftcompat = PyInt_AsLong(value);
9738         return 0;
9739 }
9740
9741 static PyObject *py_srvsvc_NetSrvInfo599_get_enableforcedlogoff(PyObject *obj, void *closure)
9742 {
9743         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9744         PyObject *py_enableforcedlogoff;
9745         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
9746         return py_enableforcedlogoff;
9747 }
9748
9749 static int py_srvsvc_NetSrvInfo599_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
9750 {
9751         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9752         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9753         object->enableforcedlogoff = PyInt_AsLong(value);
9754         return 0;
9755 }
9756
9757 static PyObject *py_srvsvc_NetSrvInfo599_get_timesource(PyObject *obj, void *closure)
9758 {
9759         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9760         PyObject *py_timesource;
9761         py_timesource = PyInt_FromLong(object->timesource);
9762         return py_timesource;
9763 }
9764
9765 static int py_srvsvc_NetSrvInfo599_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
9766 {
9767         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9768         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9769         object->timesource = PyInt_AsLong(value);
9770         return 0;
9771 }
9772
9773 static PyObject *py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis(PyObject *obj, void *closure)
9774 {
9775         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9776         PyObject *py_acceptdownlevelapis;
9777         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
9778         return py_acceptdownlevelapis;
9779 }
9780
9781 static int py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
9782 {
9783         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9784         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9785         object->acceptdownlevelapis = PyInt_AsLong(value);
9786         return 0;
9787 }
9788
9789 static PyObject *py_srvsvc_NetSrvInfo599_get_lmannounce(PyObject *obj, void *closure)
9790 {
9791         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9792         PyObject *py_lmannounce;
9793         py_lmannounce = PyInt_FromLong(object->lmannounce);
9794         return py_lmannounce;
9795 }
9796
9797 static int py_srvsvc_NetSrvInfo599_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
9798 {
9799         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9800         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9801         object->lmannounce = PyInt_AsLong(value);
9802         return 0;
9803 }
9804
9805 static PyObject *py_srvsvc_NetSrvInfo599_get_domain(PyObject *obj, void *closure)
9806 {
9807         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9808         PyObject *py_domain;
9809         if (object->domain == NULL) {
9810                 py_domain = Py_None;
9811                 Py_INCREF(py_domain);
9812         } else {
9813                 if (object->domain == NULL) {
9814                         py_domain = Py_None;
9815                         Py_INCREF(py_domain);
9816                 } else {
9817                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
9818                 }
9819         }
9820         return py_domain;
9821 }
9822
9823 static int py_srvsvc_NetSrvInfo599_set_domain(PyObject *py_obj, PyObject *value, void *closure)
9824 {
9825         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9826         if (value == Py_None) {
9827                 object->domain = NULL;
9828         } else {
9829                 object->domain = NULL;
9830                 if (PyUnicode_Check(value)) {
9831                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
9832                 } else if (PyString_Check(value)) {
9833                         object->domain = PyString_AS_STRING(value);
9834                 } else {
9835                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
9836                         return -1;
9837                 }
9838         }
9839         return 0;
9840 }
9841
9842 static PyObject *py_srvsvc_NetSrvInfo599_get_maxcopyreadlen(PyObject *obj, void *closure)
9843 {
9844         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9845         PyObject *py_maxcopyreadlen;
9846         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
9847         return py_maxcopyreadlen;
9848 }
9849
9850 static int py_srvsvc_NetSrvInfo599_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
9851 {
9852         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9853         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9854         object->maxcopyreadlen = PyInt_AsLong(value);
9855         return 0;
9856 }
9857
9858 static PyObject *py_srvsvc_NetSrvInfo599_get_maxcopywritelen(PyObject *obj, void *closure)
9859 {
9860         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9861         PyObject *py_maxcopywritelen;
9862         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
9863         return py_maxcopywritelen;
9864 }
9865
9866 static int py_srvsvc_NetSrvInfo599_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
9867 {
9868         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9869         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9870         object->maxcopywritelen = PyInt_AsLong(value);
9871         return 0;
9872 }
9873
9874 static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepsearch(PyObject *obj, void *closure)
9875 {
9876         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9877         PyObject *py_minkeepsearch;
9878         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
9879         return py_minkeepsearch;
9880 }
9881
9882 static int py_srvsvc_NetSrvInfo599_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9883 {
9884         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9885         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9886         object->minkeepsearch = PyInt_AsLong(value);
9887         return 0;
9888 }
9889
9890 static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch(PyObject *obj, void *closure)
9891 {
9892         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9893         PyObject *py_minkeepcomplsearch;
9894         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
9895         return py_minkeepcomplsearch;
9896 }
9897
9898 static int py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9899 {
9900         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9901         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9902         object->minkeepcomplsearch = PyInt_AsLong(value);
9903         return 0;
9904 }
9905
9906 static PyObject *py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch(PyObject *obj, void *closure)
9907 {
9908         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9909         PyObject *py_maxkeepcomplsearch;
9910         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
9911         return py_maxkeepcomplsearch;
9912 }
9913
9914 static int py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9915 {
9916         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9917         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9918         object->maxkeepcomplsearch = PyInt_AsLong(value);
9919         return 0;
9920 }
9921
9922 static PyObject *py_srvsvc_NetSrvInfo599_get_threadcountadd(PyObject *obj, void *closure)
9923 {
9924         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9925         PyObject *py_threadcountadd;
9926         py_threadcountadd = PyInt_FromLong(object->threadcountadd);
9927         return py_threadcountadd;
9928 }
9929
9930 static int py_srvsvc_NetSrvInfo599_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
9931 {
9932         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9933         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9934         object->threadcountadd = PyInt_AsLong(value);
9935         return 0;
9936 }
9937
9938 static PyObject *py_srvsvc_NetSrvInfo599_get_numlockthreads(PyObject *obj, void *closure)
9939 {
9940         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9941         PyObject *py_numlockthreads;
9942         py_numlockthreads = PyInt_FromLong(object->numlockthreads);
9943         return py_numlockthreads;
9944 }
9945
9946 static int py_srvsvc_NetSrvInfo599_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
9947 {
9948         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9949         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9950         object->numlockthreads = PyInt_AsLong(value);
9951         return 0;
9952 }
9953
9954 static PyObject *py_srvsvc_NetSrvInfo599_get_scavtimeout(PyObject *obj, void *closure)
9955 {
9956         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9957         PyObject *py_scavtimeout;
9958         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
9959         return py_scavtimeout;
9960 }
9961
9962 static int py_srvsvc_NetSrvInfo599_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
9963 {
9964         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9965         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9966         object->scavtimeout = PyInt_AsLong(value);
9967         return 0;
9968 }
9969
9970 static PyObject *py_srvsvc_NetSrvInfo599_get_minrcvqueue(PyObject *obj, void *closure)
9971 {
9972         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9973         PyObject *py_minrcvqueue;
9974         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
9975         return py_minrcvqueue;
9976 }
9977
9978 static int py_srvsvc_NetSrvInfo599_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
9979 {
9980         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9981         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9982         object->minrcvqueue = PyInt_AsLong(value);
9983         return 0;
9984 }
9985
9986 static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeworkitems(PyObject *obj, void *closure)
9987 {
9988         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9989         PyObject *py_minfreeworkitems;
9990         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
9991         return py_minfreeworkitems;
9992 }
9993
9994 static int py_srvsvc_NetSrvInfo599_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
9995 {
9996         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9997         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9998         object->minfreeworkitems = PyInt_AsLong(value);
9999         return 0;
10000 }
10001
10002 static PyObject *py_srvsvc_NetSrvInfo599_get_xactmemsize(PyObject *obj, void *closure)
10003 {
10004         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10005         PyObject *py_xactmemsize;
10006         py_xactmemsize = PyInt_FromLong(object->xactmemsize);
10007         return py_xactmemsize;
10008 }
10009
10010 static int py_srvsvc_NetSrvInfo599_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
10011 {
10012         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10013         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10014         object->xactmemsize = PyInt_AsLong(value);
10015         return 0;
10016 }
10017
10018 static PyObject *py_srvsvc_NetSrvInfo599_get_threadpriority(PyObject *obj, void *closure)
10019 {
10020         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10021         PyObject *py_threadpriority;
10022         py_threadpriority = PyInt_FromLong(object->threadpriority);
10023         return py_threadpriority;
10024 }
10025
10026 static int py_srvsvc_NetSrvInfo599_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
10027 {
10028         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10029         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10030         object->threadpriority = PyInt_AsLong(value);
10031         return 0;
10032 }
10033
10034 static PyObject *py_srvsvc_NetSrvInfo599_get_maxmpxct(PyObject *obj, void *closure)
10035 {
10036         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10037         PyObject *py_maxmpxct;
10038         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
10039         return py_maxmpxct;
10040 }
10041
10042 static int py_srvsvc_NetSrvInfo599_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
10043 {
10044         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10045         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10046         object->maxmpxct = PyInt_AsLong(value);
10047         return 0;
10048 }
10049
10050 static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakwait(PyObject *obj, void *closure)
10051 {
10052         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10053         PyObject *py_oplockbreakwait;
10054         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
10055         return py_oplockbreakwait;
10056 }
10057
10058 static int py_srvsvc_NetSrvInfo599_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
10059 {
10060         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10061         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10062         object->oplockbreakwait = PyInt_AsLong(value);
10063         return 0;
10064 }
10065
10066 static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait(PyObject *obj, void *closure)
10067 {
10068         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10069         PyObject *py_oplockbreakresponsewait;
10070         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
10071         return py_oplockbreakresponsewait;
10072 }
10073
10074 static int py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
10075 {
10076         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10077         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10078         object->oplockbreakresponsewait = PyInt_AsLong(value);
10079         return 0;
10080 }
10081
10082 static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplocks(PyObject *obj, void *closure)
10083 {
10084         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10085         PyObject *py_enableoplocks;
10086         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
10087         return py_enableoplocks;
10088 }
10089
10090 static int py_srvsvc_NetSrvInfo599_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
10091 {
10092         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10093         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10094         object->enableoplocks = PyInt_AsLong(value);
10095         return 0;
10096 }
10097
10098 static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplockforceclose(PyObject *obj, void *closure)
10099 {
10100         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10101         PyObject *py_enableoplockforceclose;
10102         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
10103         return py_enableoplockforceclose;
10104 }
10105
10106 static int py_srvsvc_NetSrvInfo599_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
10107 {
10108         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10109         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10110         object->enableoplockforceclose = PyInt_AsLong(value);
10111         return 0;
10112 }
10113
10114 static PyObject *py_srvsvc_NetSrvInfo599_get_enablefcbopens(PyObject *obj, void *closure)
10115 {
10116         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10117         PyObject *py_enablefcbopens;
10118         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
10119         return py_enablefcbopens;
10120 }
10121
10122 static int py_srvsvc_NetSrvInfo599_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
10123 {
10124         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10125         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10126         object->enablefcbopens = PyInt_AsLong(value);
10127         return 0;
10128 }
10129
10130 static PyObject *py_srvsvc_NetSrvInfo599_get_enableraw(PyObject *obj, void *closure)
10131 {
10132         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10133         PyObject *py_enableraw;
10134         py_enableraw = PyInt_FromLong(object->enableraw);
10135         return py_enableraw;
10136 }
10137
10138 static int py_srvsvc_NetSrvInfo599_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
10139 {
10140         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10141         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10142         object->enableraw = PyInt_AsLong(value);
10143         return 0;
10144 }
10145
10146 static PyObject *py_srvsvc_NetSrvInfo599_get_enablesharednetdrives(PyObject *obj, void *closure)
10147 {
10148         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10149         PyObject *py_enablesharednetdrives;
10150         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
10151         return py_enablesharednetdrives;
10152 }
10153
10154 static int py_srvsvc_NetSrvInfo599_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
10155 {
10156         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10157         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10158         object->enablesharednetdrives = PyInt_AsLong(value);
10159         return 0;
10160 }
10161
10162 static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeconnections(PyObject *obj, void *closure)
10163 {
10164         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10165         PyObject *py_minfreeconnections;
10166         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
10167         return py_minfreeconnections;
10168 }
10169
10170 static int py_srvsvc_NetSrvInfo599_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
10171 {
10172         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10173         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10174         object->minfreeconnections = PyInt_AsLong(value);
10175         return 0;
10176 }
10177
10178 static PyObject *py_srvsvc_NetSrvInfo599_get_maxfreeconnections(PyObject *obj, void *closure)
10179 {
10180         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10181         PyObject *py_maxfreeconnections;
10182         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
10183         return py_maxfreeconnections;
10184 }
10185
10186 static int py_srvsvc_NetSrvInfo599_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
10187 {
10188         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10189         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10190         object->maxfreeconnections = PyInt_AsLong(value);
10191         return 0;
10192 }
10193
10194 static PyObject *py_srvsvc_NetSrvInfo599_get_initsesstable(PyObject *obj, void *closure)
10195 {
10196         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10197         PyObject *py_initsesstable;
10198         py_initsesstable = PyInt_FromLong(object->initsesstable);
10199         return py_initsesstable;
10200 }
10201
10202 static int py_srvsvc_NetSrvInfo599_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
10203 {
10204         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10205         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10206         object->initsesstable = PyInt_AsLong(value);
10207         return 0;
10208 }
10209
10210 static PyObject *py_srvsvc_NetSrvInfo599_get_initconntable(PyObject *obj, void *closure)
10211 {
10212         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10213         PyObject *py_initconntable;
10214         py_initconntable = PyInt_FromLong(object->initconntable);
10215         return py_initconntable;
10216 }
10217
10218 static int py_srvsvc_NetSrvInfo599_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
10219 {
10220         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10221         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10222         object->initconntable = PyInt_AsLong(value);
10223         return 0;
10224 }
10225
10226 static PyObject *py_srvsvc_NetSrvInfo599_get_initfiletable(PyObject *obj, void *closure)
10227 {
10228         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10229         PyObject *py_initfiletable;
10230         py_initfiletable = PyInt_FromLong(object->initfiletable);
10231         return py_initfiletable;
10232 }
10233
10234 static int py_srvsvc_NetSrvInfo599_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
10235 {
10236         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10237         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10238         object->initfiletable = PyInt_AsLong(value);
10239         return 0;
10240 }
10241
10242 static PyObject *py_srvsvc_NetSrvInfo599_get_initsearchtable(PyObject *obj, void *closure)
10243 {
10244         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10245         PyObject *py_initsearchtable;
10246         py_initsearchtable = PyInt_FromLong(object->initsearchtable);
10247         return py_initsearchtable;
10248 }
10249
10250 static int py_srvsvc_NetSrvInfo599_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
10251 {
10252         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10253         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10254         object->initsearchtable = PyInt_AsLong(value);
10255         return 0;
10256 }
10257
10258 static PyObject *py_srvsvc_NetSrvInfo599_get_alertsched(PyObject *obj, void *closure)
10259 {
10260         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10261         PyObject *py_alertsched;
10262         py_alertsched = PyInt_FromLong(object->alertsched);
10263         return py_alertsched;
10264 }
10265
10266 static int py_srvsvc_NetSrvInfo599_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
10267 {
10268         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10269         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10270         object->alertsched = PyInt_AsLong(value);
10271         return 0;
10272 }
10273
10274 static PyObject *py_srvsvc_NetSrvInfo599_get_errortreshold(PyObject *obj, void *closure)
10275 {
10276         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10277         PyObject *py_errortreshold;
10278         py_errortreshold = PyInt_FromLong(object->errortreshold);
10279         return py_errortreshold;
10280 }
10281
10282 static int py_srvsvc_NetSrvInfo599_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
10283 {
10284         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10285         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10286         object->errortreshold = PyInt_AsLong(value);
10287         return 0;
10288 }
10289
10290 static PyObject *py_srvsvc_NetSrvInfo599_get_networkerrortreshold(PyObject *obj, void *closure)
10291 {
10292         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10293         PyObject *py_networkerrortreshold;
10294         py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
10295         return py_networkerrortreshold;
10296 }
10297
10298 static int py_srvsvc_NetSrvInfo599_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
10299 {
10300         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10301         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10302         object->networkerrortreshold = PyInt_AsLong(value);
10303         return 0;
10304 }
10305
10306 static PyObject *py_srvsvc_NetSrvInfo599_get_diskspacetreshold(PyObject *obj, void *closure)
10307 {
10308         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10309         PyObject *py_diskspacetreshold;
10310         py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
10311         return py_diskspacetreshold;
10312 }
10313
10314 static int py_srvsvc_NetSrvInfo599_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
10315 {
10316         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10317         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10318         object->diskspacetreshold = PyInt_AsLong(value);
10319         return 0;
10320 }
10321
10322 static PyObject *py_srvsvc_NetSrvInfo599_get_reserved(PyObject *obj, void *closure)
10323 {
10324         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10325         PyObject *py_reserved;
10326         py_reserved = PyInt_FromLong(object->reserved);
10327         return py_reserved;
10328 }
10329
10330 static int py_srvsvc_NetSrvInfo599_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
10331 {
10332         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10333         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10334         object->reserved = PyInt_AsLong(value);
10335         return 0;
10336 }
10337
10338 static PyObject *py_srvsvc_NetSrvInfo599_get_maxlinkdelay(PyObject *obj, void *closure)
10339 {
10340         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10341         PyObject *py_maxlinkdelay;
10342         py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
10343         return py_maxlinkdelay;
10344 }
10345
10346 static int py_srvsvc_NetSrvInfo599_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
10347 {
10348         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10349         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10350         object->maxlinkdelay = PyInt_AsLong(value);
10351         return 0;
10352 }
10353
10354 static PyObject *py_srvsvc_NetSrvInfo599_get_minlinkthroughput(PyObject *obj, void *closure)
10355 {
10356         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10357         PyObject *py_minlinkthroughput;
10358         py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
10359         return py_minlinkthroughput;
10360 }
10361
10362 static int py_srvsvc_NetSrvInfo599_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
10363 {
10364         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10365         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10366         object->minlinkthroughput = PyInt_AsLong(value);
10367         return 0;
10368 }
10369
10370 static PyObject *py_srvsvc_NetSrvInfo599_get_linkinfovalidtime(PyObject *obj, void *closure)
10371 {
10372         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10373         PyObject *py_linkinfovalidtime;
10374         py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
10375         return py_linkinfovalidtime;
10376 }
10377
10378 static int py_srvsvc_NetSrvInfo599_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
10379 {
10380         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10381         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10382         object->linkinfovalidtime = PyInt_AsLong(value);
10383         return 0;
10384 }
10385
10386 static PyObject *py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
10387 {
10388         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10389         PyObject *py_scavqosinfoupdatetime;
10390         py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
10391         return py_scavqosinfoupdatetime;
10392 }
10393
10394 static int py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
10395 {
10396         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10397         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10398         object->scavqosinfoupdatetime = PyInt_AsLong(value);
10399         return 0;
10400 }
10401
10402 static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitemidletime(PyObject *obj, void *closure)
10403 {
10404         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10405         PyObject *py_maxworkitemidletime;
10406         py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
10407         return py_maxworkitemidletime;
10408 }
10409
10410 static int py_srvsvc_NetSrvInfo599_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
10411 {
10412         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10413         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10414         object->maxworkitemidletime = PyInt_AsLong(value);
10415         return 0;
10416 }
10417
10418 static PyGetSetDef py_srvsvc_NetSrvInfo599_getsetters[] = {
10419         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo599_get_sessopen, py_srvsvc_NetSrvInfo599_set_sessopen },
10420         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo599_get_sesssvc, py_srvsvc_NetSrvInfo599_set_sesssvc },
10421         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo599_get_opensearch, py_srvsvc_NetSrvInfo599_set_opensearch },
10422         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo599_get_sizereqbufs, py_srvsvc_NetSrvInfo599_set_sizereqbufs },
10423         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo599_get_initworkitems, py_srvsvc_NetSrvInfo599_set_initworkitems },
10424         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo599_get_maxworkitems, py_srvsvc_NetSrvInfo599_set_maxworkitems },
10425         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo599_get_rawworkitems, py_srvsvc_NetSrvInfo599_set_rawworkitems },
10426         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo599_get_irpstacksize, py_srvsvc_NetSrvInfo599_set_irpstacksize },
10427         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo599_get_maxrawbuflen, py_srvsvc_NetSrvInfo599_set_maxrawbuflen },
10428         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo599_get_sessusers, py_srvsvc_NetSrvInfo599_set_sessusers },
10429         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo599_get_sessconns, py_srvsvc_NetSrvInfo599_set_sessconns },
10430         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage },
10431         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage },
10432         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo599_get_enablesoftcompat, py_srvsvc_NetSrvInfo599_set_enablesoftcompat },
10433         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo599_get_enableforcedlogoff, py_srvsvc_NetSrvInfo599_set_enableforcedlogoff },
10434         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo599_get_timesource, py_srvsvc_NetSrvInfo599_set_timesource },
10435         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis },
10436         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo599_get_lmannounce, py_srvsvc_NetSrvInfo599_set_lmannounce },
10437         { discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo599_get_domain, py_srvsvc_NetSrvInfo599_set_domain },
10438         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo599_get_maxcopyreadlen, py_srvsvc_NetSrvInfo599_set_maxcopyreadlen },
10439         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo599_get_maxcopywritelen, py_srvsvc_NetSrvInfo599_set_maxcopywritelen },
10440         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo599_get_minkeepsearch, py_srvsvc_NetSrvInfo599_set_minkeepsearch },
10441         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch },
10442         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch },
10443         { discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo599_get_threadcountadd, py_srvsvc_NetSrvInfo599_set_threadcountadd },
10444         { discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo599_get_numlockthreads, py_srvsvc_NetSrvInfo599_set_numlockthreads },
10445         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo599_get_scavtimeout, py_srvsvc_NetSrvInfo599_set_scavtimeout },
10446         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo599_get_minrcvqueue, py_srvsvc_NetSrvInfo599_set_minrcvqueue },
10447         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo599_get_minfreeworkitems, py_srvsvc_NetSrvInfo599_set_minfreeworkitems },
10448         { discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo599_get_xactmemsize, py_srvsvc_NetSrvInfo599_set_xactmemsize },
10449         { discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo599_get_threadpriority, py_srvsvc_NetSrvInfo599_set_threadpriority },
10450         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo599_get_maxmpxct, py_srvsvc_NetSrvInfo599_set_maxmpxct },
10451         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo599_get_oplockbreakwait, py_srvsvc_NetSrvInfo599_set_oplockbreakwait },
10452         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait },
10453         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo599_get_enableoplocks, py_srvsvc_NetSrvInfo599_set_enableoplocks },
10454         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo599_get_enableoplockforceclose, py_srvsvc_NetSrvInfo599_set_enableoplockforceclose },
10455         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo599_get_enablefcbopens, py_srvsvc_NetSrvInfo599_set_enablefcbopens },
10456         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo599_get_enableraw, py_srvsvc_NetSrvInfo599_set_enableraw },
10457         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo599_get_enablesharednetdrives, py_srvsvc_NetSrvInfo599_set_enablesharednetdrives },
10458         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo599_get_minfreeconnections, py_srvsvc_NetSrvInfo599_set_minfreeconnections },
10459         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo599_get_maxfreeconnections, py_srvsvc_NetSrvInfo599_set_maxfreeconnections },
10460         { discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo599_get_initsesstable, py_srvsvc_NetSrvInfo599_set_initsesstable },
10461         { discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo599_get_initconntable, py_srvsvc_NetSrvInfo599_set_initconntable },
10462         { discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo599_get_initfiletable, py_srvsvc_NetSrvInfo599_set_initfiletable },
10463         { discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo599_get_initsearchtable, py_srvsvc_NetSrvInfo599_set_initsearchtable },
10464         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo599_get_alertsched, py_srvsvc_NetSrvInfo599_set_alertsched },
10465         { discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo599_get_errortreshold, py_srvsvc_NetSrvInfo599_set_errortreshold },
10466         { discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo599_get_networkerrortreshold, py_srvsvc_NetSrvInfo599_set_networkerrortreshold },
10467         { discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo599_get_diskspacetreshold, py_srvsvc_NetSrvInfo599_set_diskspacetreshold },
10468         { discard_const_p(char, "reserved"), py_srvsvc_NetSrvInfo599_get_reserved, py_srvsvc_NetSrvInfo599_set_reserved },
10469         { discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo599_get_maxlinkdelay, py_srvsvc_NetSrvInfo599_set_maxlinkdelay },
10470         { discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo599_get_minlinkthroughput, py_srvsvc_NetSrvInfo599_set_minlinkthroughput },
10471         { discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo599_get_linkinfovalidtime, py_srvsvc_NetSrvInfo599_set_linkinfovalidtime },
10472         { discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime },
10473         { discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo599_get_maxworkitemidletime, py_srvsvc_NetSrvInfo599_set_maxworkitemidletime },
10474         { NULL }
10475 };
10476
10477 static PyObject *py_srvsvc_NetSrvInfo599_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10478 {
10479         return pytalloc_new(struct srvsvc_NetSrvInfo599, type);
10480 }
10481
10482
10483 static PyTypeObject srvsvc_NetSrvInfo599_Type = {
10484         PyObject_HEAD_INIT(NULL) 0,
10485         .tp_name = "srvsvc.NetSrvInfo599",
10486         .tp_getset = py_srvsvc_NetSrvInfo599_getsetters,
10487         .tp_methods = NULL,
10488         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10489         .tp_basicsize = sizeof(pytalloc_Object),
10490         .tp_new = py_srvsvc_NetSrvInfo599_new,
10491 };
10492
10493
10494 static PyObject *py_srvsvc_NetSrvInfo1005_get_comment(PyObject *obj, void *closure)
10495 {
10496         struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(obj);
10497         PyObject *py_comment;
10498         if (object->comment == NULL) {
10499                 py_comment = Py_None;
10500                 Py_INCREF(py_comment);
10501         } else {
10502                 if (object->comment == NULL) {
10503                         py_comment = Py_None;
10504                         Py_INCREF(py_comment);
10505                 } else {
10506                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
10507                 }
10508         }
10509         return py_comment;
10510 }
10511
10512 static int py_srvsvc_NetSrvInfo1005_set_comment(PyObject *py_obj, PyObject *value, void *closure)
10513 {
10514         struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(py_obj);
10515         if (value == Py_None) {
10516                 object->comment = NULL;
10517         } else {
10518                 object->comment = NULL;
10519                 if (PyUnicode_Check(value)) {
10520                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
10521                 } else if (PyString_Check(value)) {
10522                         object->comment = PyString_AS_STRING(value);
10523                 } else {
10524                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
10525                         return -1;
10526                 }
10527         }
10528         return 0;
10529 }
10530
10531 static PyGetSetDef py_srvsvc_NetSrvInfo1005_getsetters[] = {
10532         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo1005_get_comment, py_srvsvc_NetSrvInfo1005_set_comment },
10533         { NULL }
10534 };
10535
10536 static PyObject *py_srvsvc_NetSrvInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10537 {
10538         return pytalloc_new(struct srvsvc_NetSrvInfo1005, type);
10539 }
10540
10541
10542 static PyTypeObject srvsvc_NetSrvInfo1005_Type = {
10543         PyObject_HEAD_INIT(NULL) 0,
10544         .tp_name = "srvsvc.NetSrvInfo1005",
10545         .tp_getset = py_srvsvc_NetSrvInfo1005_getsetters,
10546         .tp_methods = NULL,
10547         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10548         .tp_basicsize = sizeof(pytalloc_Object),
10549         .tp_new = py_srvsvc_NetSrvInfo1005_new,
10550 };
10551
10552
10553 static PyObject *py_srvsvc_NetSrvInfo1010_get_disc(PyObject *obj, void *closure)
10554 {
10555         struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(obj);
10556         PyObject *py_disc;
10557         py_disc = PyInt_FromLong(object->disc);
10558         return py_disc;
10559 }
10560
10561 static int py_srvsvc_NetSrvInfo1010_set_disc(PyObject *py_obj, PyObject *value, void *closure)
10562 {
10563         struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(py_obj);
10564         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10565         object->disc = PyInt_AsLong(value);
10566         return 0;
10567 }
10568
10569 static PyGetSetDef py_srvsvc_NetSrvInfo1010_getsetters[] = {
10570         { discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo1010_get_disc, py_srvsvc_NetSrvInfo1010_set_disc },
10571         { NULL }
10572 };
10573
10574 static PyObject *py_srvsvc_NetSrvInfo1010_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10575 {
10576         return pytalloc_new(struct srvsvc_NetSrvInfo1010, type);
10577 }
10578
10579
10580 static PyTypeObject srvsvc_NetSrvInfo1010_Type = {
10581         PyObject_HEAD_INIT(NULL) 0,
10582         .tp_name = "srvsvc.NetSrvInfo1010",
10583         .tp_getset = py_srvsvc_NetSrvInfo1010_getsetters,
10584         .tp_methods = NULL,
10585         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10586         .tp_basicsize = sizeof(pytalloc_Object),
10587         .tp_new = py_srvsvc_NetSrvInfo1010_new,
10588 };
10589
10590
10591 static PyObject *py_srvsvc_NetSrvInfo1016_get_hidden(PyObject *obj, void *closure)
10592 {
10593         struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(obj);
10594         PyObject *py_hidden;
10595         py_hidden = PyInt_FromLong(object->hidden);
10596         return py_hidden;
10597 }
10598
10599 static int py_srvsvc_NetSrvInfo1016_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
10600 {
10601         struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(py_obj);
10602         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10603         object->hidden = PyInt_AsLong(value);
10604         return 0;
10605 }
10606
10607 static PyGetSetDef py_srvsvc_NetSrvInfo1016_getsetters[] = {
10608         { discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo1016_get_hidden, py_srvsvc_NetSrvInfo1016_set_hidden },
10609         { NULL }
10610 };
10611
10612 static PyObject *py_srvsvc_NetSrvInfo1016_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10613 {
10614         return pytalloc_new(struct srvsvc_NetSrvInfo1016, type);
10615 }
10616
10617
10618 static PyTypeObject srvsvc_NetSrvInfo1016_Type = {
10619         PyObject_HEAD_INIT(NULL) 0,
10620         .tp_name = "srvsvc.NetSrvInfo1016",
10621         .tp_getset = py_srvsvc_NetSrvInfo1016_getsetters,
10622         .tp_methods = NULL,
10623         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10624         .tp_basicsize = sizeof(pytalloc_Object),
10625         .tp_new = py_srvsvc_NetSrvInfo1016_new,
10626 };
10627
10628
10629 static PyObject *py_srvsvc_NetSrvInfo1017_get_announce(PyObject *obj, void *closure)
10630 {
10631         struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(obj);
10632         PyObject *py_announce;
10633         py_announce = PyInt_FromLong(object->announce);
10634         return py_announce;
10635 }
10636
10637 static int py_srvsvc_NetSrvInfo1017_set_announce(PyObject *py_obj, PyObject *value, void *closure)
10638 {
10639         struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(py_obj);
10640         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10641         object->announce = PyInt_AsLong(value);
10642         return 0;
10643 }
10644
10645 static PyGetSetDef py_srvsvc_NetSrvInfo1017_getsetters[] = {
10646         { discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo1017_get_announce, py_srvsvc_NetSrvInfo1017_set_announce },
10647         { NULL }
10648 };
10649
10650 static PyObject *py_srvsvc_NetSrvInfo1017_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10651 {
10652         return pytalloc_new(struct srvsvc_NetSrvInfo1017, type);
10653 }
10654
10655
10656 static PyTypeObject srvsvc_NetSrvInfo1017_Type = {
10657         PyObject_HEAD_INIT(NULL) 0,
10658         .tp_name = "srvsvc.NetSrvInfo1017",
10659         .tp_getset = py_srvsvc_NetSrvInfo1017_getsetters,
10660         .tp_methods = NULL,
10661         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10662         .tp_basicsize = sizeof(pytalloc_Object),
10663         .tp_new = py_srvsvc_NetSrvInfo1017_new,
10664 };
10665
10666
10667 static PyObject *py_srvsvc_NetSrvInfo1018_get_anndelta(PyObject *obj, void *closure)
10668 {
10669         struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(obj);
10670         PyObject *py_anndelta;
10671         py_anndelta = PyInt_FromLong(object->anndelta);
10672         return py_anndelta;
10673 }
10674
10675 static int py_srvsvc_NetSrvInfo1018_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
10676 {
10677         struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(py_obj);
10678         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10679         object->anndelta = PyInt_AsLong(value);
10680         return 0;
10681 }
10682
10683 static PyGetSetDef py_srvsvc_NetSrvInfo1018_getsetters[] = {
10684         { discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo1018_get_anndelta, py_srvsvc_NetSrvInfo1018_set_anndelta },
10685         { NULL }
10686 };
10687
10688 static PyObject *py_srvsvc_NetSrvInfo1018_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10689 {
10690         return pytalloc_new(struct srvsvc_NetSrvInfo1018, type);
10691 }
10692
10693
10694 static PyTypeObject srvsvc_NetSrvInfo1018_Type = {
10695         PyObject_HEAD_INIT(NULL) 0,
10696         .tp_name = "srvsvc.NetSrvInfo1018",
10697         .tp_getset = py_srvsvc_NetSrvInfo1018_getsetters,
10698         .tp_methods = NULL,
10699         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10700         .tp_basicsize = sizeof(pytalloc_Object),
10701         .tp_new = py_srvsvc_NetSrvInfo1018_new,
10702 };
10703
10704
10705 static PyObject *py_srvsvc_NetSrvInfo1107_get_users(PyObject *obj, void *closure)
10706 {
10707         struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(obj);
10708         PyObject *py_users;
10709         py_users = PyInt_FromLong(object->users);
10710         return py_users;
10711 }
10712
10713 static int py_srvsvc_NetSrvInfo1107_set_users(PyObject *py_obj, PyObject *value, void *closure)
10714 {
10715         struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(py_obj);
10716         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10717         object->users = PyInt_AsLong(value);
10718         return 0;
10719 }
10720
10721 static PyGetSetDef py_srvsvc_NetSrvInfo1107_getsetters[] = {
10722         { discard_const_p(char, "users"), py_srvsvc_NetSrvInfo1107_get_users, py_srvsvc_NetSrvInfo1107_set_users },
10723         { NULL }
10724 };
10725
10726 static PyObject *py_srvsvc_NetSrvInfo1107_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10727 {
10728         return pytalloc_new(struct srvsvc_NetSrvInfo1107, type);
10729 }
10730
10731
10732 static PyTypeObject srvsvc_NetSrvInfo1107_Type = {
10733         PyObject_HEAD_INIT(NULL) 0,
10734         .tp_name = "srvsvc.NetSrvInfo1107",
10735         .tp_getset = py_srvsvc_NetSrvInfo1107_getsetters,
10736         .tp_methods = NULL,
10737         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10738         .tp_basicsize = sizeof(pytalloc_Object),
10739         .tp_new = py_srvsvc_NetSrvInfo1107_new,
10740 };
10741
10742
10743 static PyObject *py_srvsvc_NetSrvInfo1501_get_sessopens(PyObject *obj, void *closure)
10744 {
10745         struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(obj);
10746         PyObject *py_sessopens;
10747         py_sessopens = PyInt_FromLong(object->sessopens);
10748         return py_sessopens;
10749 }
10750
10751 static int py_srvsvc_NetSrvInfo1501_set_sessopens(PyObject *py_obj, PyObject *value, void *closure)
10752 {
10753         struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(py_obj);
10754         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10755         object->sessopens = PyInt_AsLong(value);
10756         return 0;
10757 }
10758
10759 static PyGetSetDef py_srvsvc_NetSrvInfo1501_getsetters[] = {
10760         { discard_const_p(char, "sessopens"), py_srvsvc_NetSrvInfo1501_get_sessopens, py_srvsvc_NetSrvInfo1501_set_sessopens },
10761         { NULL }
10762 };
10763
10764 static PyObject *py_srvsvc_NetSrvInfo1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10765 {
10766         return pytalloc_new(struct srvsvc_NetSrvInfo1501, type);
10767 }
10768
10769
10770 static PyTypeObject srvsvc_NetSrvInfo1501_Type = {
10771         PyObject_HEAD_INIT(NULL) 0,
10772         .tp_name = "srvsvc.NetSrvInfo1501",
10773         .tp_getset = py_srvsvc_NetSrvInfo1501_getsetters,
10774         .tp_methods = NULL,
10775         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10776         .tp_basicsize = sizeof(pytalloc_Object),
10777         .tp_new = py_srvsvc_NetSrvInfo1501_new,
10778 };
10779
10780
10781 static PyObject *py_srvsvc_NetSrvInfo1502_get_sessvcs(PyObject *obj, void *closure)
10782 {
10783         struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(obj);
10784         PyObject *py_sessvcs;
10785         py_sessvcs = PyInt_FromLong(object->sessvcs);
10786         return py_sessvcs;
10787 }
10788
10789 static int py_srvsvc_NetSrvInfo1502_set_sessvcs(PyObject *py_obj, PyObject *value, void *closure)
10790 {
10791         struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(py_obj);
10792         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10793         object->sessvcs = PyInt_AsLong(value);
10794         return 0;
10795 }
10796
10797 static PyGetSetDef py_srvsvc_NetSrvInfo1502_getsetters[] = {
10798         { discard_const_p(char, "sessvcs"), py_srvsvc_NetSrvInfo1502_get_sessvcs, py_srvsvc_NetSrvInfo1502_set_sessvcs },
10799         { NULL }
10800 };
10801
10802 static PyObject *py_srvsvc_NetSrvInfo1502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10803 {
10804         return pytalloc_new(struct srvsvc_NetSrvInfo1502, type);
10805 }
10806
10807
10808 static PyTypeObject srvsvc_NetSrvInfo1502_Type = {
10809         PyObject_HEAD_INIT(NULL) 0,
10810         .tp_name = "srvsvc.NetSrvInfo1502",
10811         .tp_getset = py_srvsvc_NetSrvInfo1502_getsetters,
10812         .tp_methods = NULL,
10813         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10814         .tp_basicsize = sizeof(pytalloc_Object),
10815         .tp_new = py_srvsvc_NetSrvInfo1502_new,
10816 };
10817
10818
10819 static PyObject *py_srvsvc_NetSrvInfo1503_get_opensearch(PyObject *obj, void *closure)
10820 {
10821         struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(obj);
10822         PyObject *py_opensearch;
10823         py_opensearch = PyInt_FromLong(object->opensearch);
10824         return py_opensearch;
10825 }
10826
10827 static int py_srvsvc_NetSrvInfo1503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
10828 {
10829         struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(py_obj);
10830         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10831         object->opensearch = PyInt_AsLong(value);
10832         return 0;
10833 }
10834
10835 static PyGetSetDef py_srvsvc_NetSrvInfo1503_getsetters[] = {
10836         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo1503_get_opensearch, py_srvsvc_NetSrvInfo1503_set_opensearch },
10837         { NULL }
10838 };
10839
10840 static PyObject *py_srvsvc_NetSrvInfo1503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10841 {
10842         return pytalloc_new(struct srvsvc_NetSrvInfo1503, type);
10843 }
10844
10845
10846 static PyTypeObject srvsvc_NetSrvInfo1503_Type = {
10847         PyObject_HEAD_INIT(NULL) 0,
10848         .tp_name = "srvsvc.NetSrvInfo1503",
10849         .tp_getset = py_srvsvc_NetSrvInfo1503_getsetters,
10850         .tp_methods = NULL,
10851         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10852         .tp_basicsize = sizeof(pytalloc_Object),
10853         .tp_new = py_srvsvc_NetSrvInfo1503_new,
10854 };
10855
10856
10857 static PyObject *py_srvsvc_NetSrvInfo1506_get_maxworkitems(PyObject *obj, void *closure)
10858 {
10859         struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(obj);
10860         PyObject *py_maxworkitems;
10861         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
10862         return py_maxworkitems;
10863 }
10864
10865 static int py_srvsvc_NetSrvInfo1506_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
10866 {
10867         struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(py_obj);
10868         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10869         object->maxworkitems = PyInt_AsLong(value);
10870         return 0;
10871 }
10872
10873 static PyGetSetDef py_srvsvc_NetSrvInfo1506_getsetters[] = {
10874         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo1506_get_maxworkitems, py_srvsvc_NetSrvInfo1506_set_maxworkitems },
10875         { NULL }
10876 };
10877
10878 static PyObject *py_srvsvc_NetSrvInfo1506_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10879 {
10880         return pytalloc_new(struct srvsvc_NetSrvInfo1506, type);
10881 }
10882
10883
10884 static PyTypeObject srvsvc_NetSrvInfo1506_Type = {
10885         PyObject_HEAD_INIT(NULL) 0,
10886         .tp_name = "srvsvc.NetSrvInfo1506",
10887         .tp_getset = py_srvsvc_NetSrvInfo1506_getsetters,
10888         .tp_methods = NULL,
10889         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10890         .tp_basicsize = sizeof(pytalloc_Object),
10891         .tp_new = py_srvsvc_NetSrvInfo1506_new,
10892 };
10893
10894
10895 static PyObject *py_srvsvc_NetSrvInfo1509_get_maxrawbuflen(PyObject *obj, void *closure)
10896 {
10897         struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(obj);
10898         PyObject *py_maxrawbuflen;
10899         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
10900         return py_maxrawbuflen;
10901 }
10902
10903 static int py_srvsvc_NetSrvInfo1509_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
10904 {
10905         struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(py_obj);
10906         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10907         object->maxrawbuflen = PyInt_AsLong(value);
10908         return 0;
10909 }
10910
10911 static PyGetSetDef py_srvsvc_NetSrvInfo1509_getsetters[] = {
10912         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo1509_get_maxrawbuflen, py_srvsvc_NetSrvInfo1509_set_maxrawbuflen },
10913         { NULL }
10914 };
10915
10916 static PyObject *py_srvsvc_NetSrvInfo1509_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10917 {
10918         return pytalloc_new(struct srvsvc_NetSrvInfo1509, type);
10919 }
10920
10921
10922 static PyTypeObject srvsvc_NetSrvInfo1509_Type = {
10923         PyObject_HEAD_INIT(NULL) 0,
10924         .tp_name = "srvsvc.NetSrvInfo1509",
10925         .tp_getset = py_srvsvc_NetSrvInfo1509_getsetters,
10926         .tp_methods = NULL,
10927         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10928         .tp_basicsize = sizeof(pytalloc_Object),
10929         .tp_new = py_srvsvc_NetSrvInfo1509_new,
10930 };
10931
10932
10933 static PyObject *py_srvsvc_NetSrvInfo1510_get_sessusers(PyObject *obj, void *closure)
10934 {
10935         struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(obj);
10936         PyObject *py_sessusers;
10937         py_sessusers = PyInt_FromLong(object->sessusers);
10938         return py_sessusers;
10939 }
10940
10941 static int py_srvsvc_NetSrvInfo1510_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
10942 {
10943         struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(py_obj);
10944         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10945         object->sessusers = PyInt_AsLong(value);
10946         return 0;
10947 }
10948
10949 static PyGetSetDef py_srvsvc_NetSrvInfo1510_getsetters[] = {
10950         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo1510_get_sessusers, py_srvsvc_NetSrvInfo1510_set_sessusers },
10951         { NULL }
10952 };
10953
10954 static PyObject *py_srvsvc_NetSrvInfo1510_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10955 {
10956         return pytalloc_new(struct srvsvc_NetSrvInfo1510, type);
10957 }
10958
10959
10960 static PyTypeObject srvsvc_NetSrvInfo1510_Type = {
10961         PyObject_HEAD_INIT(NULL) 0,
10962         .tp_name = "srvsvc.NetSrvInfo1510",
10963         .tp_getset = py_srvsvc_NetSrvInfo1510_getsetters,
10964         .tp_methods = NULL,
10965         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10966         .tp_basicsize = sizeof(pytalloc_Object),
10967         .tp_new = py_srvsvc_NetSrvInfo1510_new,
10968 };
10969
10970
10971 static PyObject *py_srvsvc_NetSrvInfo1511_get_sesscons(PyObject *obj, void *closure)
10972 {
10973         struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(obj);
10974         PyObject *py_sesscons;
10975         py_sesscons = PyInt_FromLong(object->sesscons);
10976         return py_sesscons;
10977 }
10978
10979 static int py_srvsvc_NetSrvInfo1511_set_sesscons(PyObject *py_obj, PyObject *value, void *closure)
10980 {
10981         struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(py_obj);
10982         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10983         object->sesscons = PyInt_AsLong(value);
10984         return 0;
10985 }
10986
10987 static PyGetSetDef py_srvsvc_NetSrvInfo1511_getsetters[] = {
10988         { discard_const_p(char, "sesscons"), py_srvsvc_NetSrvInfo1511_get_sesscons, py_srvsvc_NetSrvInfo1511_set_sesscons },
10989         { NULL }
10990 };
10991
10992 static PyObject *py_srvsvc_NetSrvInfo1511_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10993 {
10994         return pytalloc_new(struct srvsvc_NetSrvInfo1511, type);
10995 }
10996
10997
10998 static PyTypeObject srvsvc_NetSrvInfo1511_Type = {
10999         PyObject_HEAD_INIT(NULL) 0,
11000         .tp_name = "srvsvc.NetSrvInfo1511",
11001         .tp_getset = py_srvsvc_NetSrvInfo1511_getsetters,
11002         .tp_methods = NULL,
11003         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11004         .tp_basicsize = sizeof(pytalloc_Object),
11005         .tp_new = py_srvsvc_NetSrvInfo1511_new,
11006 };
11007
11008
11009 static PyObject *py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
11010 {
11011         struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(obj);
11012         PyObject *py_maxnonpagedmemoryusage;
11013         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
11014         return py_maxnonpagedmemoryusage;
11015 }
11016
11017 static int py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
11018 {
11019         struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(py_obj);
11020         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11021         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
11022         return 0;
11023 }
11024
11025 static PyGetSetDef py_srvsvc_NetSrvInfo1512_getsetters[] = {
11026         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage },
11027         { NULL }
11028 };
11029
11030 static PyObject *py_srvsvc_NetSrvInfo1512_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11031 {
11032         return pytalloc_new(struct srvsvc_NetSrvInfo1512, type);
11033 }
11034
11035
11036 static PyTypeObject srvsvc_NetSrvInfo1512_Type = {
11037         PyObject_HEAD_INIT(NULL) 0,
11038         .tp_name = "srvsvc.NetSrvInfo1512",
11039         .tp_getset = py_srvsvc_NetSrvInfo1512_getsetters,
11040         .tp_methods = NULL,
11041         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11042         .tp_basicsize = sizeof(pytalloc_Object),
11043         .tp_new = py_srvsvc_NetSrvInfo1512_new,
11044 };
11045
11046
11047 static PyObject *py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage(PyObject *obj, void *closure)
11048 {
11049         struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(obj);
11050         PyObject *py_maxpagedmemoryusage;
11051         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
11052         return py_maxpagedmemoryusage;
11053 }
11054
11055 static int py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
11056 {
11057         struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(py_obj);
11058         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11059         object->maxpagedmemoryusage = PyInt_AsLong(value);
11060         return 0;
11061 }
11062
11063 static PyGetSetDef py_srvsvc_NetSrvInfo1513_getsetters[] = {
11064         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage },
11065         { NULL }
11066 };
11067
11068 static PyObject *py_srvsvc_NetSrvInfo1513_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11069 {
11070         return pytalloc_new(struct srvsvc_NetSrvInfo1513, type);
11071 }
11072
11073
11074 static PyTypeObject srvsvc_NetSrvInfo1513_Type = {
11075         PyObject_HEAD_INIT(NULL) 0,
11076         .tp_name = "srvsvc.NetSrvInfo1513",
11077         .tp_getset = py_srvsvc_NetSrvInfo1513_getsetters,
11078         .tp_methods = NULL,
11079         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11080         .tp_basicsize = sizeof(pytalloc_Object),
11081         .tp_new = py_srvsvc_NetSrvInfo1513_new,
11082 };
11083
11084
11085 static PyObject *py_srvsvc_NetSrvInfo1514_get_enablesoftcompat(PyObject *obj, void *closure)
11086 {
11087         struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(obj);
11088         PyObject *py_enablesoftcompat;
11089         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
11090         return py_enablesoftcompat;
11091 }
11092
11093 static int py_srvsvc_NetSrvInfo1514_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
11094 {
11095         struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(py_obj);
11096         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11097         object->enablesoftcompat = PyInt_AsLong(value);
11098         return 0;
11099 }
11100
11101 static PyGetSetDef py_srvsvc_NetSrvInfo1514_getsetters[] = {
11102         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo1514_get_enablesoftcompat, py_srvsvc_NetSrvInfo1514_set_enablesoftcompat },
11103         { NULL }
11104 };
11105
11106 static PyObject *py_srvsvc_NetSrvInfo1514_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11107 {
11108         return pytalloc_new(struct srvsvc_NetSrvInfo1514, type);
11109 }
11110
11111
11112 static PyTypeObject srvsvc_NetSrvInfo1514_Type = {
11113         PyObject_HEAD_INIT(NULL) 0,
11114         .tp_name = "srvsvc.NetSrvInfo1514",
11115         .tp_getset = py_srvsvc_NetSrvInfo1514_getsetters,
11116         .tp_methods = NULL,
11117         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11118         .tp_basicsize = sizeof(pytalloc_Object),
11119         .tp_new = py_srvsvc_NetSrvInfo1514_new,
11120 };
11121
11122
11123 static PyObject *py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff(PyObject *obj, void *closure)
11124 {
11125         struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(obj);
11126         PyObject *py_enableforcedlogoff;
11127         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
11128         return py_enableforcedlogoff;
11129 }
11130
11131 static int py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
11132 {
11133         struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(py_obj);
11134         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11135         object->enableforcedlogoff = PyInt_AsLong(value);
11136         return 0;
11137 }
11138
11139 static PyGetSetDef py_srvsvc_NetSrvInfo1515_getsetters[] = {
11140         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff, py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff },
11141         { NULL }
11142 };
11143
11144 static PyObject *py_srvsvc_NetSrvInfo1515_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11145 {
11146         return pytalloc_new(struct srvsvc_NetSrvInfo1515, type);
11147 }
11148
11149
11150 static PyTypeObject srvsvc_NetSrvInfo1515_Type = {
11151         PyObject_HEAD_INIT(NULL) 0,
11152         .tp_name = "srvsvc.NetSrvInfo1515",
11153         .tp_getset = py_srvsvc_NetSrvInfo1515_getsetters,
11154         .tp_methods = NULL,
11155         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11156         .tp_basicsize = sizeof(pytalloc_Object),
11157         .tp_new = py_srvsvc_NetSrvInfo1515_new,
11158 };
11159
11160
11161 static PyObject *py_srvsvc_NetSrvInfo1516_get_timesource(PyObject *obj, void *closure)
11162 {
11163         struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(obj);
11164         PyObject *py_timesource;
11165         py_timesource = PyInt_FromLong(object->timesource);
11166         return py_timesource;
11167 }
11168
11169 static int py_srvsvc_NetSrvInfo1516_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
11170 {
11171         struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(py_obj);
11172         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11173         object->timesource = PyInt_AsLong(value);
11174         return 0;
11175 }
11176
11177 static PyGetSetDef py_srvsvc_NetSrvInfo1516_getsetters[] = {
11178         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo1516_get_timesource, py_srvsvc_NetSrvInfo1516_set_timesource },
11179         { NULL }
11180 };
11181
11182 static PyObject *py_srvsvc_NetSrvInfo1516_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11183 {
11184         return pytalloc_new(struct srvsvc_NetSrvInfo1516, type);
11185 }
11186
11187
11188 static PyTypeObject srvsvc_NetSrvInfo1516_Type = {
11189         PyObject_HEAD_INIT(NULL) 0,
11190         .tp_name = "srvsvc.NetSrvInfo1516",
11191         .tp_getset = py_srvsvc_NetSrvInfo1516_getsetters,
11192         .tp_methods = NULL,
11193         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11194         .tp_basicsize = sizeof(pytalloc_Object),
11195         .tp_new = py_srvsvc_NetSrvInfo1516_new,
11196 };
11197
11198
11199 static PyObject *py_srvsvc_NetSrvInfo1518_get_lmannounce(PyObject *obj, void *closure)
11200 {
11201         struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(obj);
11202         PyObject *py_lmannounce;
11203         py_lmannounce = PyInt_FromLong(object->lmannounce);
11204         return py_lmannounce;
11205 }
11206
11207 static int py_srvsvc_NetSrvInfo1518_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
11208 {
11209         struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(py_obj);
11210         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11211         object->lmannounce = PyInt_AsLong(value);
11212         return 0;
11213 }
11214
11215 static PyGetSetDef py_srvsvc_NetSrvInfo1518_getsetters[] = {
11216         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo1518_get_lmannounce, py_srvsvc_NetSrvInfo1518_set_lmannounce },
11217         { NULL }
11218 };
11219
11220 static PyObject *py_srvsvc_NetSrvInfo1518_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11221 {
11222         return pytalloc_new(struct srvsvc_NetSrvInfo1518, type);
11223 }
11224
11225
11226 static PyTypeObject srvsvc_NetSrvInfo1518_Type = {
11227         PyObject_HEAD_INIT(NULL) 0,
11228         .tp_name = "srvsvc.NetSrvInfo1518",
11229         .tp_getset = py_srvsvc_NetSrvInfo1518_getsetters,
11230         .tp_methods = NULL,
11231         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11232         .tp_basicsize = sizeof(pytalloc_Object),
11233         .tp_new = py_srvsvc_NetSrvInfo1518_new,
11234 };
11235
11236
11237 static PyObject *py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen(PyObject *obj, void *closure)
11238 {
11239         struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(obj);
11240         PyObject *py_maxcopyreadlen;
11241         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
11242         return py_maxcopyreadlen;
11243 }
11244
11245 static int py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
11246 {
11247         struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(py_obj);
11248         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11249         object->maxcopyreadlen = PyInt_AsLong(value);
11250         return 0;
11251 }
11252
11253 static PyGetSetDef py_srvsvc_NetSrvInfo1520_getsetters[] = {
11254         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen, py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen },
11255         { NULL }
11256 };
11257
11258 static PyObject *py_srvsvc_NetSrvInfo1520_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11259 {
11260         return pytalloc_new(struct srvsvc_NetSrvInfo1520, type);
11261 }
11262
11263
11264 static PyTypeObject srvsvc_NetSrvInfo1520_Type = {
11265         PyObject_HEAD_INIT(NULL) 0,
11266         .tp_name = "srvsvc.NetSrvInfo1520",
11267         .tp_getset = py_srvsvc_NetSrvInfo1520_getsetters,
11268         .tp_methods = NULL,
11269         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11270         .tp_basicsize = sizeof(pytalloc_Object),
11271         .tp_new = py_srvsvc_NetSrvInfo1520_new,
11272 };
11273
11274
11275 static PyObject *py_srvsvc_NetSrvInfo1521_get_maxcopywritelen(PyObject *obj, void *closure)
11276 {
11277         struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(obj);
11278         PyObject *py_maxcopywritelen;
11279         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
11280         return py_maxcopywritelen;
11281 }
11282
11283 static int py_srvsvc_NetSrvInfo1521_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
11284 {
11285         struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(py_obj);
11286         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11287         object->maxcopywritelen = PyInt_AsLong(value);
11288         return 0;
11289 }
11290
11291 static PyGetSetDef py_srvsvc_NetSrvInfo1521_getsetters[] = {
11292         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo1521_get_maxcopywritelen, py_srvsvc_NetSrvInfo1521_set_maxcopywritelen },
11293         { NULL }
11294 };
11295
11296 static PyObject *py_srvsvc_NetSrvInfo1521_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11297 {
11298         return pytalloc_new(struct srvsvc_NetSrvInfo1521, type);
11299 }
11300
11301
11302 static PyTypeObject srvsvc_NetSrvInfo1521_Type = {
11303         PyObject_HEAD_INIT(NULL) 0,
11304         .tp_name = "srvsvc.NetSrvInfo1521",
11305         .tp_getset = py_srvsvc_NetSrvInfo1521_getsetters,
11306         .tp_methods = NULL,
11307         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11308         .tp_basicsize = sizeof(pytalloc_Object),
11309         .tp_new = py_srvsvc_NetSrvInfo1521_new,
11310 };
11311
11312
11313 static PyObject *py_srvsvc_NetSrvInfo1522_get_minkeepsearch(PyObject *obj, void *closure)
11314 {
11315         struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(obj);
11316         PyObject *py_minkeepsearch;
11317         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
11318         return py_minkeepsearch;
11319 }
11320
11321 static int py_srvsvc_NetSrvInfo1522_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
11322 {
11323         struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(py_obj);
11324         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11325         object->minkeepsearch = PyInt_AsLong(value);
11326         return 0;
11327 }
11328
11329 static PyGetSetDef py_srvsvc_NetSrvInfo1522_getsetters[] = {
11330         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo1522_get_minkeepsearch, py_srvsvc_NetSrvInfo1522_set_minkeepsearch },
11331         { NULL }
11332 };
11333
11334 static PyObject *py_srvsvc_NetSrvInfo1522_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11335 {
11336         return pytalloc_new(struct srvsvc_NetSrvInfo1522, type);
11337 }
11338
11339
11340 static PyTypeObject srvsvc_NetSrvInfo1522_Type = {
11341         PyObject_HEAD_INIT(NULL) 0,
11342         .tp_name = "srvsvc.NetSrvInfo1522",
11343         .tp_getset = py_srvsvc_NetSrvInfo1522_getsetters,
11344         .tp_methods = NULL,
11345         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11346         .tp_basicsize = sizeof(pytalloc_Object),
11347         .tp_new = py_srvsvc_NetSrvInfo1522_new,
11348 };
11349
11350
11351 static PyObject *py_srvsvc_NetSrvInfo1523_get_maxkeepsearch(PyObject *obj, void *closure)
11352 {
11353         struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(obj);
11354         PyObject *py_maxkeepsearch;
11355         py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
11356         return py_maxkeepsearch;
11357 }
11358
11359 static int py_srvsvc_NetSrvInfo1523_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
11360 {
11361         struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(py_obj);
11362         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11363         object->maxkeepsearch = PyInt_AsLong(value);
11364         return 0;
11365 }
11366
11367 static PyGetSetDef py_srvsvc_NetSrvInfo1523_getsetters[] = {
11368         { discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo1523_get_maxkeepsearch, py_srvsvc_NetSrvInfo1523_set_maxkeepsearch },
11369         { NULL }
11370 };
11371
11372 static PyObject *py_srvsvc_NetSrvInfo1523_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11373 {
11374         return pytalloc_new(struct srvsvc_NetSrvInfo1523, type);
11375 }
11376
11377
11378 static PyTypeObject srvsvc_NetSrvInfo1523_Type = {
11379         PyObject_HEAD_INIT(NULL) 0,
11380         .tp_name = "srvsvc.NetSrvInfo1523",
11381         .tp_getset = py_srvsvc_NetSrvInfo1523_getsetters,
11382         .tp_methods = NULL,
11383         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11384         .tp_basicsize = sizeof(pytalloc_Object),
11385         .tp_new = py_srvsvc_NetSrvInfo1523_new,
11386 };
11387
11388
11389 static PyObject *py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch(PyObject *obj, void *closure)
11390 {
11391         struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(obj);
11392         PyObject *py_minkeepcomplsearch;
11393         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
11394         return py_minkeepcomplsearch;
11395 }
11396
11397 static int py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
11398 {
11399         struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(py_obj);
11400         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11401         object->minkeepcomplsearch = PyInt_AsLong(value);
11402         return 0;
11403 }
11404
11405 static PyGetSetDef py_srvsvc_NetSrvInfo1524_getsetters[] = {
11406         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch },
11407         { NULL }
11408 };
11409
11410 static PyObject *py_srvsvc_NetSrvInfo1524_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11411 {
11412         return pytalloc_new(struct srvsvc_NetSrvInfo1524, type);
11413 }
11414
11415
11416 static PyTypeObject srvsvc_NetSrvInfo1524_Type = {
11417         PyObject_HEAD_INIT(NULL) 0,
11418         .tp_name = "srvsvc.NetSrvInfo1524",
11419         .tp_getset = py_srvsvc_NetSrvInfo1524_getsetters,
11420         .tp_methods = NULL,
11421         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11422         .tp_basicsize = sizeof(pytalloc_Object),
11423         .tp_new = py_srvsvc_NetSrvInfo1524_new,
11424 };
11425
11426
11427 static PyObject *py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch(PyObject *obj, void *closure)
11428 {
11429         struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(obj);
11430         PyObject *py_maxkeepcomplsearch;
11431         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
11432         return py_maxkeepcomplsearch;
11433 }
11434
11435 static int py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
11436 {
11437         struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(py_obj);
11438         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11439         object->maxkeepcomplsearch = PyInt_AsLong(value);
11440         return 0;
11441 }
11442
11443 static PyGetSetDef py_srvsvc_NetSrvInfo1525_getsetters[] = {
11444         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch },
11445         { NULL }
11446 };
11447
11448 static PyObject *py_srvsvc_NetSrvInfo1525_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11449 {
11450         return pytalloc_new(struct srvsvc_NetSrvInfo1525, type);
11451 }
11452
11453
11454 static PyTypeObject srvsvc_NetSrvInfo1525_Type = {
11455         PyObject_HEAD_INIT(NULL) 0,
11456         .tp_name = "srvsvc.NetSrvInfo1525",
11457         .tp_getset = py_srvsvc_NetSrvInfo1525_getsetters,
11458         .tp_methods = NULL,
11459         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11460         .tp_basicsize = sizeof(pytalloc_Object),
11461         .tp_new = py_srvsvc_NetSrvInfo1525_new,
11462 };
11463
11464
11465 static PyObject *py_srvsvc_NetSrvInfo1528_get_scavtimeout(PyObject *obj, void *closure)
11466 {
11467         struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(obj);
11468         PyObject *py_scavtimeout;
11469         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
11470         return py_scavtimeout;
11471 }
11472
11473 static int py_srvsvc_NetSrvInfo1528_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
11474 {
11475         struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(py_obj);
11476         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11477         object->scavtimeout = PyInt_AsLong(value);
11478         return 0;
11479 }
11480
11481 static PyGetSetDef py_srvsvc_NetSrvInfo1528_getsetters[] = {
11482         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo1528_get_scavtimeout, py_srvsvc_NetSrvInfo1528_set_scavtimeout },
11483         { NULL }
11484 };
11485
11486 static PyObject *py_srvsvc_NetSrvInfo1528_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11487 {
11488         return pytalloc_new(struct srvsvc_NetSrvInfo1528, type);
11489 }
11490
11491
11492 static PyTypeObject srvsvc_NetSrvInfo1528_Type = {
11493         PyObject_HEAD_INIT(NULL) 0,
11494         .tp_name = "srvsvc.NetSrvInfo1528",
11495         .tp_getset = py_srvsvc_NetSrvInfo1528_getsetters,
11496         .tp_methods = NULL,
11497         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11498         .tp_basicsize = sizeof(pytalloc_Object),
11499         .tp_new = py_srvsvc_NetSrvInfo1528_new,
11500 };
11501
11502
11503 static PyObject *py_srvsvc_NetSrvInfo1529_get_minrcvqueue(PyObject *obj, void *closure)
11504 {
11505         struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(obj);
11506         PyObject *py_minrcvqueue;
11507         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
11508         return py_minrcvqueue;
11509 }
11510
11511 static int py_srvsvc_NetSrvInfo1529_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
11512 {
11513         struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(py_obj);
11514         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11515         object->minrcvqueue = PyInt_AsLong(value);
11516         return 0;
11517 }
11518
11519 static PyGetSetDef py_srvsvc_NetSrvInfo1529_getsetters[] = {
11520         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo1529_get_minrcvqueue, py_srvsvc_NetSrvInfo1529_set_minrcvqueue },
11521         { NULL }
11522 };
11523
11524 static PyObject *py_srvsvc_NetSrvInfo1529_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11525 {
11526         return pytalloc_new(struct srvsvc_NetSrvInfo1529, type);
11527 }
11528
11529
11530 static PyTypeObject srvsvc_NetSrvInfo1529_Type = {
11531         PyObject_HEAD_INIT(NULL) 0,
11532         .tp_name = "srvsvc.NetSrvInfo1529",
11533         .tp_getset = py_srvsvc_NetSrvInfo1529_getsetters,
11534         .tp_methods = NULL,
11535         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11536         .tp_basicsize = sizeof(pytalloc_Object),
11537         .tp_new = py_srvsvc_NetSrvInfo1529_new,
11538 };
11539
11540
11541 static PyObject *py_srvsvc_NetSrvInfo1530_get_minfreeworkitems(PyObject *obj, void *closure)
11542 {
11543         struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(obj);
11544         PyObject *py_minfreeworkitems;
11545         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
11546         return py_minfreeworkitems;
11547 }
11548
11549 static int py_srvsvc_NetSrvInfo1530_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
11550 {
11551         struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(py_obj);
11552         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11553         object->minfreeworkitems = PyInt_AsLong(value);
11554         return 0;
11555 }
11556
11557 static PyGetSetDef py_srvsvc_NetSrvInfo1530_getsetters[] = {
11558         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo1530_get_minfreeworkitems, py_srvsvc_NetSrvInfo1530_set_minfreeworkitems },
11559         { NULL }
11560 };
11561
11562 static PyObject *py_srvsvc_NetSrvInfo1530_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11563 {
11564         return pytalloc_new(struct srvsvc_NetSrvInfo1530, type);
11565 }
11566
11567
11568 static PyTypeObject srvsvc_NetSrvInfo1530_Type = {
11569         PyObject_HEAD_INIT(NULL) 0,
11570         .tp_name = "srvsvc.NetSrvInfo1530",
11571         .tp_getset = py_srvsvc_NetSrvInfo1530_getsetters,
11572         .tp_methods = NULL,
11573         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11574         .tp_basicsize = sizeof(pytalloc_Object),
11575         .tp_new = py_srvsvc_NetSrvInfo1530_new,
11576 };
11577
11578
11579 static PyObject *py_srvsvc_NetSrvInfo1533_get_maxmpxct(PyObject *obj, void *closure)
11580 {
11581         struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(obj);
11582         PyObject *py_maxmpxct;
11583         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
11584         return py_maxmpxct;
11585 }
11586
11587 static int py_srvsvc_NetSrvInfo1533_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
11588 {
11589         struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(py_obj);
11590         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11591         object->maxmpxct = PyInt_AsLong(value);
11592         return 0;
11593 }
11594
11595 static PyGetSetDef py_srvsvc_NetSrvInfo1533_getsetters[] = {
11596         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo1533_get_maxmpxct, py_srvsvc_NetSrvInfo1533_set_maxmpxct },
11597         { NULL }
11598 };
11599
11600 static PyObject *py_srvsvc_NetSrvInfo1533_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11601 {
11602         return pytalloc_new(struct srvsvc_NetSrvInfo1533, type);
11603 }
11604
11605
11606 static PyTypeObject srvsvc_NetSrvInfo1533_Type = {
11607         PyObject_HEAD_INIT(NULL) 0,
11608         .tp_name = "srvsvc.NetSrvInfo1533",
11609         .tp_getset = py_srvsvc_NetSrvInfo1533_getsetters,
11610         .tp_methods = NULL,
11611         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11612         .tp_basicsize = sizeof(pytalloc_Object),
11613         .tp_new = py_srvsvc_NetSrvInfo1533_new,
11614 };
11615
11616
11617 static PyObject *py_srvsvc_NetSrvInfo1534_get_oplockbreakwait(PyObject *obj, void *closure)
11618 {
11619         struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(obj);
11620         PyObject *py_oplockbreakwait;
11621         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
11622         return py_oplockbreakwait;
11623 }
11624
11625 static int py_srvsvc_NetSrvInfo1534_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
11626 {
11627         struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(py_obj);
11628         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11629         object->oplockbreakwait = PyInt_AsLong(value);
11630         return 0;
11631 }
11632
11633 static PyGetSetDef py_srvsvc_NetSrvInfo1534_getsetters[] = {
11634         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo1534_get_oplockbreakwait, py_srvsvc_NetSrvInfo1534_set_oplockbreakwait },
11635         { NULL }
11636 };
11637
11638 static PyObject *py_srvsvc_NetSrvInfo1534_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11639 {
11640         return pytalloc_new(struct srvsvc_NetSrvInfo1534, type);
11641 }
11642
11643
11644 static PyTypeObject srvsvc_NetSrvInfo1534_Type = {
11645         PyObject_HEAD_INIT(NULL) 0,
11646         .tp_name = "srvsvc.NetSrvInfo1534",
11647         .tp_getset = py_srvsvc_NetSrvInfo1534_getsetters,
11648         .tp_methods = NULL,
11649         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11650         .tp_basicsize = sizeof(pytalloc_Object),
11651         .tp_new = py_srvsvc_NetSrvInfo1534_new,
11652 };
11653
11654
11655 static PyObject *py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait(PyObject *obj, void *closure)
11656 {
11657         struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(obj);
11658         PyObject *py_oplockbreakresponsewait;
11659         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
11660         return py_oplockbreakresponsewait;
11661 }
11662
11663 static int py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
11664 {
11665         struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(py_obj);
11666         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11667         object->oplockbreakresponsewait = PyInt_AsLong(value);
11668         return 0;
11669 }
11670
11671 static PyGetSetDef py_srvsvc_NetSrvInfo1535_getsetters[] = {
11672         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait },
11673         { NULL }
11674 };
11675
11676 static PyObject *py_srvsvc_NetSrvInfo1535_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11677 {
11678         return pytalloc_new(struct srvsvc_NetSrvInfo1535, type);
11679 }
11680
11681
11682 static PyTypeObject srvsvc_NetSrvInfo1535_Type = {
11683         PyObject_HEAD_INIT(NULL) 0,
11684         .tp_name = "srvsvc.NetSrvInfo1535",
11685         .tp_getset = py_srvsvc_NetSrvInfo1535_getsetters,
11686         .tp_methods = NULL,
11687         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11688         .tp_basicsize = sizeof(pytalloc_Object),
11689         .tp_new = py_srvsvc_NetSrvInfo1535_new,
11690 };
11691
11692
11693 static PyObject *py_srvsvc_NetSrvInfo1536_get_enableoplocks(PyObject *obj, void *closure)
11694 {
11695         struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(obj);
11696         PyObject *py_enableoplocks;
11697         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
11698         return py_enableoplocks;
11699 }
11700
11701 static int py_srvsvc_NetSrvInfo1536_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
11702 {
11703         struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(py_obj);
11704         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11705         object->enableoplocks = PyInt_AsLong(value);
11706         return 0;
11707 }
11708
11709 static PyGetSetDef py_srvsvc_NetSrvInfo1536_getsetters[] = {
11710         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo1536_get_enableoplocks, py_srvsvc_NetSrvInfo1536_set_enableoplocks },
11711         { NULL }
11712 };
11713
11714 static PyObject *py_srvsvc_NetSrvInfo1536_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11715 {
11716         return pytalloc_new(struct srvsvc_NetSrvInfo1536, type);
11717 }
11718
11719
11720 static PyTypeObject srvsvc_NetSrvInfo1536_Type = {
11721         PyObject_HEAD_INIT(NULL) 0,
11722         .tp_name = "srvsvc.NetSrvInfo1536",
11723         .tp_getset = py_srvsvc_NetSrvInfo1536_getsetters,
11724         .tp_methods = NULL,
11725         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11726         .tp_basicsize = sizeof(pytalloc_Object),
11727         .tp_new = py_srvsvc_NetSrvInfo1536_new,
11728 };
11729
11730
11731 static PyObject *py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose(PyObject *obj, void *closure)
11732 {
11733         struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(obj);
11734         PyObject *py_enableoplockforceclose;
11735         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
11736         return py_enableoplockforceclose;
11737 }
11738
11739 static int py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
11740 {
11741         struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(py_obj);
11742         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11743         object->enableoplockforceclose = PyInt_AsLong(value);
11744         return 0;
11745 }
11746
11747 static PyGetSetDef py_srvsvc_NetSrvInfo1537_getsetters[] = {
11748         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose, py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose },
11749         { NULL }
11750 };
11751
11752 static PyObject *py_srvsvc_NetSrvInfo1537_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11753 {
11754         return pytalloc_new(struct srvsvc_NetSrvInfo1537, type);
11755 }
11756
11757
11758 static PyTypeObject srvsvc_NetSrvInfo1537_Type = {
11759         PyObject_HEAD_INIT(NULL) 0,
11760         .tp_name = "srvsvc.NetSrvInfo1537",
11761         .tp_getset = py_srvsvc_NetSrvInfo1537_getsetters,
11762         .tp_methods = NULL,
11763         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11764         .tp_basicsize = sizeof(pytalloc_Object),
11765         .tp_new = py_srvsvc_NetSrvInfo1537_new,
11766 };
11767
11768
11769 static PyObject *py_srvsvc_NetSrvInfo1538_get_enablefcbopens(PyObject *obj, void *closure)
11770 {
11771         struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(obj);
11772         PyObject *py_enablefcbopens;
11773         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
11774         return py_enablefcbopens;
11775 }
11776
11777 static int py_srvsvc_NetSrvInfo1538_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
11778 {
11779         struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(py_obj);
11780         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11781         object->enablefcbopens = PyInt_AsLong(value);
11782         return 0;
11783 }
11784
11785 static PyGetSetDef py_srvsvc_NetSrvInfo1538_getsetters[] = {
11786         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo1538_get_enablefcbopens, py_srvsvc_NetSrvInfo1538_set_enablefcbopens },
11787         { NULL }
11788 };
11789
11790 static PyObject *py_srvsvc_NetSrvInfo1538_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11791 {
11792         return pytalloc_new(struct srvsvc_NetSrvInfo1538, type);
11793 }
11794
11795
11796 static PyTypeObject srvsvc_NetSrvInfo1538_Type = {
11797         PyObject_HEAD_INIT(NULL) 0,
11798         .tp_name = "srvsvc.NetSrvInfo1538",
11799         .tp_getset = py_srvsvc_NetSrvInfo1538_getsetters,
11800         .tp_methods = NULL,
11801         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11802         .tp_basicsize = sizeof(pytalloc_Object),
11803         .tp_new = py_srvsvc_NetSrvInfo1538_new,
11804 };
11805
11806
11807 static PyObject *py_srvsvc_NetSrvInfo1539_get_enableraw(PyObject *obj, void *closure)
11808 {
11809         struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(obj);
11810         PyObject *py_enableraw;
11811         py_enableraw = PyInt_FromLong(object->enableraw);
11812         return py_enableraw;
11813 }
11814
11815 static int py_srvsvc_NetSrvInfo1539_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
11816 {
11817         struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(py_obj);
11818         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11819         object->enableraw = PyInt_AsLong(value);
11820         return 0;
11821 }
11822
11823 static PyGetSetDef py_srvsvc_NetSrvInfo1539_getsetters[] = {
11824         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo1539_get_enableraw, py_srvsvc_NetSrvInfo1539_set_enableraw },
11825         { NULL }
11826 };
11827
11828 static PyObject *py_srvsvc_NetSrvInfo1539_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11829 {
11830         return pytalloc_new(struct srvsvc_NetSrvInfo1539, type);
11831 }
11832
11833
11834 static PyTypeObject srvsvc_NetSrvInfo1539_Type = {
11835         PyObject_HEAD_INIT(NULL) 0,
11836         .tp_name = "srvsvc.NetSrvInfo1539",
11837         .tp_getset = py_srvsvc_NetSrvInfo1539_getsetters,
11838         .tp_methods = NULL,
11839         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11840         .tp_basicsize = sizeof(pytalloc_Object),
11841         .tp_new = py_srvsvc_NetSrvInfo1539_new,
11842 };
11843
11844
11845 static PyObject *py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives(PyObject *obj, void *closure)
11846 {
11847         struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(obj);
11848         PyObject *py_enablesharednetdrives;
11849         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
11850         return py_enablesharednetdrives;
11851 }
11852
11853 static int py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
11854 {
11855         struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(py_obj);
11856         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11857         object->enablesharednetdrives = PyInt_AsLong(value);
11858         return 0;
11859 }
11860
11861 static PyGetSetDef py_srvsvc_NetSrvInfo1540_getsetters[] = {
11862         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives, py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives },
11863         { NULL }
11864 };
11865
11866 static PyObject *py_srvsvc_NetSrvInfo1540_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11867 {
11868         return pytalloc_new(struct srvsvc_NetSrvInfo1540, type);
11869 }
11870
11871
11872 static PyTypeObject srvsvc_NetSrvInfo1540_Type = {
11873         PyObject_HEAD_INIT(NULL) 0,
11874         .tp_name = "srvsvc.NetSrvInfo1540",
11875         .tp_getset = py_srvsvc_NetSrvInfo1540_getsetters,
11876         .tp_methods = NULL,
11877         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11878         .tp_basicsize = sizeof(pytalloc_Object),
11879         .tp_new = py_srvsvc_NetSrvInfo1540_new,
11880 };
11881
11882
11883 static PyObject *py_srvsvc_NetSrvInfo1541_get_minfreeconnections(PyObject *obj, void *closure)
11884 {
11885         struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(obj);
11886         PyObject *py_minfreeconnections;
11887         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
11888         return py_minfreeconnections;
11889 }
11890
11891 static int py_srvsvc_NetSrvInfo1541_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
11892 {
11893         struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(py_obj);
11894         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11895         object->minfreeconnections = PyInt_AsLong(value);
11896         return 0;
11897 }
11898
11899 static PyGetSetDef py_srvsvc_NetSrvInfo1541_getsetters[] = {
11900         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo1541_get_minfreeconnections, py_srvsvc_NetSrvInfo1541_set_minfreeconnections },
11901         { NULL }
11902 };
11903
11904 static PyObject *py_srvsvc_NetSrvInfo1541_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11905 {
11906         return pytalloc_new(struct srvsvc_NetSrvInfo1541, type);
11907 }
11908
11909
11910 static PyTypeObject srvsvc_NetSrvInfo1541_Type = {
11911         PyObject_HEAD_INIT(NULL) 0,
11912         .tp_name = "srvsvc.NetSrvInfo1541",
11913         .tp_getset = py_srvsvc_NetSrvInfo1541_getsetters,
11914         .tp_methods = NULL,
11915         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11916         .tp_basicsize = sizeof(pytalloc_Object),
11917         .tp_new = py_srvsvc_NetSrvInfo1541_new,
11918 };
11919
11920
11921 static PyObject *py_srvsvc_NetSrvInfo1542_get_maxfreeconnections(PyObject *obj, void *closure)
11922 {
11923         struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(obj);
11924         PyObject *py_maxfreeconnections;
11925         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
11926         return py_maxfreeconnections;
11927 }
11928
11929 static int py_srvsvc_NetSrvInfo1542_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
11930 {
11931         struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(py_obj);
11932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11933         object->maxfreeconnections = PyInt_AsLong(value);
11934         return 0;
11935 }
11936
11937 static PyGetSetDef py_srvsvc_NetSrvInfo1542_getsetters[] = {
11938         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo1542_get_maxfreeconnections, py_srvsvc_NetSrvInfo1542_set_maxfreeconnections },
11939         { NULL }
11940 };
11941
11942 static PyObject *py_srvsvc_NetSrvInfo1542_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11943 {
11944         return pytalloc_new(struct srvsvc_NetSrvInfo1542, type);
11945 }
11946
11947
11948 static PyTypeObject srvsvc_NetSrvInfo1542_Type = {
11949         PyObject_HEAD_INIT(NULL) 0,
11950         .tp_name = "srvsvc.NetSrvInfo1542",
11951         .tp_getset = py_srvsvc_NetSrvInfo1542_getsetters,
11952         .tp_methods = NULL,
11953         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11954         .tp_basicsize = sizeof(pytalloc_Object),
11955         .tp_new = py_srvsvc_NetSrvInfo1542_new,
11956 };
11957
11958
11959 static PyObject *py_srvsvc_NetSrvInfo1543_get_initsesstable(PyObject *obj, void *closure)
11960 {
11961         struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(obj);
11962         PyObject *py_initsesstable;
11963         py_initsesstable = PyInt_FromLong(object->initsesstable);
11964         return py_initsesstable;
11965 }
11966
11967 static int py_srvsvc_NetSrvInfo1543_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
11968 {
11969         struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(py_obj);
11970         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11971         object->initsesstable = PyInt_AsLong(value);
11972         return 0;
11973 }
11974
11975 static PyGetSetDef py_srvsvc_NetSrvInfo1543_getsetters[] = {
11976         { discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo1543_get_initsesstable, py_srvsvc_NetSrvInfo1543_set_initsesstable },
11977         { NULL }
11978 };
11979
11980 static PyObject *py_srvsvc_NetSrvInfo1543_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11981 {
11982         return pytalloc_new(struct srvsvc_NetSrvInfo1543, type);
11983 }
11984
11985
11986 static PyTypeObject srvsvc_NetSrvInfo1543_Type = {
11987         PyObject_HEAD_INIT(NULL) 0,
11988         .tp_name = "srvsvc.NetSrvInfo1543",
11989         .tp_getset = py_srvsvc_NetSrvInfo1543_getsetters,
11990         .tp_methods = NULL,
11991         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11992         .tp_basicsize = sizeof(pytalloc_Object),
11993         .tp_new = py_srvsvc_NetSrvInfo1543_new,
11994 };
11995
11996
11997 static PyObject *py_srvsvc_NetSrvInfo1544_get_initconntable(PyObject *obj, void *closure)
11998 {
11999         struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(obj);
12000         PyObject *py_initconntable;
12001         py_initconntable = PyInt_FromLong(object->initconntable);
12002         return py_initconntable;
12003 }
12004
12005 static int py_srvsvc_NetSrvInfo1544_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
12006 {
12007         struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(py_obj);
12008         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12009         object->initconntable = PyInt_AsLong(value);
12010         return 0;
12011 }
12012
12013 static PyGetSetDef py_srvsvc_NetSrvInfo1544_getsetters[] = {
12014         { discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo1544_get_initconntable, py_srvsvc_NetSrvInfo1544_set_initconntable },
12015         { NULL }
12016 };
12017
12018 static PyObject *py_srvsvc_NetSrvInfo1544_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12019 {
12020         return pytalloc_new(struct srvsvc_NetSrvInfo1544, type);
12021 }
12022
12023
12024 static PyTypeObject srvsvc_NetSrvInfo1544_Type = {
12025         PyObject_HEAD_INIT(NULL) 0,
12026         .tp_name = "srvsvc.NetSrvInfo1544",
12027         .tp_getset = py_srvsvc_NetSrvInfo1544_getsetters,
12028         .tp_methods = NULL,
12029         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12030         .tp_basicsize = sizeof(pytalloc_Object),
12031         .tp_new = py_srvsvc_NetSrvInfo1544_new,
12032 };
12033
12034
12035 static PyObject *py_srvsvc_NetSrvInfo1545_get_initfiletable(PyObject *obj, void *closure)
12036 {
12037         struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(obj);
12038         PyObject *py_initfiletable;
12039         py_initfiletable = PyInt_FromLong(object->initfiletable);
12040         return py_initfiletable;
12041 }
12042
12043 static int py_srvsvc_NetSrvInfo1545_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
12044 {
12045         struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(py_obj);
12046         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12047         object->initfiletable = PyInt_AsLong(value);
12048         return 0;
12049 }
12050
12051 static PyGetSetDef py_srvsvc_NetSrvInfo1545_getsetters[] = {
12052         { discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo1545_get_initfiletable, py_srvsvc_NetSrvInfo1545_set_initfiletable },
12053         { NULL }
12054 };
12055
12056 static PyObject *py_srvsvc_NetSrvInfo1545_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12057 {
12058         return pytalloc_new(struct srvsvc_NetSrvInfo1545, type);
12059 }
12060
12061
12062 static PyTypeObject srvsvc_NetSrvInfo1545_Type = {
12063         PyObject_HEAD_INIT(NULL) 0,
12064         .tp_name = "srvsvc.NetSrvInfo1545",
12065         .tp_getset = py_srvsvc_NetSrvInfo1545_getsetters,
12066         .tp_methods = NULL,
12067         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12068         .tp_basicsize = sizeof(pytalloc_Object),
12069         .tp_new = py_srvsvc_NetSrvInfo1545_new,
12070 };
12071
12072
12073 static PyObject *py_srvsvc_NetSrvInfo1546_get_initsearchtable(PyObject *obj, void *closure)
12074 {
12075         struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(obj);
12076         PyObject *py_initsearchtable;
12077         py_initsearchtable = PyInt_FromLong(object->initsearchtable);
12078         return py_initsearchtable;
12079 }
12080
12081 static int py_srvsvc_NetSrvInfo1546_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
12082 {
12083         struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(py_obj);
12084         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12085         object->initsearchtable = PyInt_AsLong(value);
12086         return 0;
12087 }
12088
12089 static PyGetSetDef py_srvsvc_NetSrvInfo1546_getsetters[] = {
12090         { discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo1546_get_initsearchtable, py_srvsvc_NetSrvInfo1546_set_initsearchtable },
12091         { NULL }
12092 };
12093
12094 static PyObject *py_srvsvc_NetSrvInfo1546_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12095 {
12096         return pytalloc_new(struct srvsvc_NetSrvInfo1546, type);
12097 }
12098
12099
12100 static PyTypeObject srvsvc_NetSrvInfo1546_Type = {
12101         PyObject_HEAD_INIT(NULL) 0,
12102         .tp_name = "srvsvc.NetSrvInfo1546",
12103         .tp_getset = py_srvsvc_NetSrvInfo1546_getsetters,
12104         .tp_methods = NULL,
12105         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12106         .tp_basicsize = sizeof(pytalloc_Object),
12107         .tp_new = py_srvsvc_NetSrvInfo1546_new,
12108 };
12109
12110
12111 static PyObject *py_srvsvc_NetSrvInfo1547_get_alertsched(PyObject *obj, void *closure)
12112 {
12113         struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(obj);
12114         PyObject *py_alertsched;
12115         py_alertsched = PyInt_FromLong(object->alertsched);
12116         return py_alertsched;
12117 }
12118
12119 static int py_srvsvc_NetSrvInfo1547_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
12120 {
12121         struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(py_obj);
12122         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12123         object->alertsched = PyInt_AsLong(value);
12124         return 0;
12125 }
12126
12127 static PyGetSetDef py_srvsvc_NetSrvInfo1547_getsetters[] = {
12128         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo1547_get_alertsched, py_srvsvc_NetSrvInfo1547_set_alertsched },
12129         { NULL }
12130 };
12131
12132 static PyObject *py_srvsvc_NetSrvInfo1547_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12133 {
12134         return pytalloc_new(struct srvsvc_NetSrvInfo1547, type);
12135 }
12136
12137
12138 static PyTypeObject srvsvc_NetSrvInfo1547_Type = {
12139         PyObject_HEAD_INIT(NULL) 0,
12140         .tp_name = "srvsvc.NetSrvInfo1547",
12141         .tp_getset = py_srvsvc_NetSrvInfo1547_getsetters,
12142         .tp_methods = NULL,
12143         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12144         .tp_basicsize = sizeof(pytalloc_Object),
12145         .tp_new = py_srvsvc_NetSrvInfo1547_new,
12146 };
12147
12148
12149 static PyObject *py_srvsvc_NetSrvInfo1548_get_errortreshold(PyObject *obj, void *closure)
12150 {
12151         struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(obj);
12152         PyObject *py_errortreshold;
12153         py_errortreshold = PyInt_FromLong(object->errortreshold);
12154         return py_errortreshold;
12155 }
12156
12157 static int py_srvsvc_NetSrvInfo1548_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
12158 {
12159         struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(py_obj);
12160         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12161         object->errortreshold = PyInt_AsLong(value);
12162         return 0;
12163 }
12164
12165 static PyGetSetDef py_srvsvc_NetSrvInfo1548_getsetters[] = {
12166         { discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo1548_get_errortreshold, py_srvsvc_NetSrvInfo1548_set_errortreshold },
12167         { NULL }
12168 };
12169
12170 static PyObject *py_srvsvc_NetSrvInfo1548_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12171 {
12172         return pytalloc_new(struct srvsvc_NetSrvInfo1548, type);
12173 }
12174
12175
12176 static PyTypeObject srvsvc_NetSrvInfo1548_Type = {
12177         PyObject_HEAD_INIT(NULL) 0,
12178         .tp_name = "srvsvc.NetSrvInfo1548",
12179         .tp_getset = py_srvsvc_NetSrvInfo1548_getsetters,
12180         .tp_methods = NULL,
12181         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12182         .tp_basicsize = sizeof(pytalloc_Object),
12183         .tp_new = py_srvsvc_NetSrvInfo1548_new,
12184 };
12185
12186
12187 static PyObject *py_srvsvc_NetSrvInfo1549_get_networkerrortreshold(PyObject *obj, void *closure)
12188 {
12189         struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(obj);
12190         PyObject *py_networkerrortreshold;
12191         py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
12192         return py_networkerrortreshold;
12193 }
12194
12195 static int py_srvsvc_NetSrvInfo1549_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
12196 {
12197         struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(py_obj);
12198         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12199         object->networkerrortreshold = PyInt_AsLong(value);
12200         return 0;
12201 }
12202
12203 static PyGetSetDef py_srvsvc_NetSrvInfo1549_getsetters[] = {
12204         { discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo1549_get_networkerrortreshold, py_srvsvc_NetSrvInfo1549_set_networkerrortreshold },
12205         { NULL }
12206 };
12207
12208 static PyObject *py_srvsvc_NetSrvInfo1549_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12209 {
12210         return pytalloc_new(struct srvsvc_NetSrvInfo1549, type);
12211 }
12212
12213
12214 static PyTypeObject srvsvc_NetSrvInfo1549_Type = {
12215         PyObject_HEAD_INIT(NULL) 0,
12216         .tp_name = "srvsvc.NetSrvInfo1549",
12217         .tp_getset = py_srvsvc_NetSrvInfo1549_getsetters,
12218         .tp_methods = NULL,
12219         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12220         .tp_basicsize = sizeof(pytalloc_Object),
12221         .tp_new = py_srvsvc_NetSrvInfo1549_new,
12222 };
12223
12224
12225 static PyObject *py_srvsvc_NetSrvInfo1550_get_diskspacetreshold(PyObject *obj, void *closure)
12226 {
12227         struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(obj);
12228         PyObject *py_diskspacetreshold;
12229         py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
12230         return py_diskspacetreshold;
12231 }
12232
12233 static int py_srvsvc_NetSrvInfo1550_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
12234 {
12235         struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(py_obj);
12236         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12237         object->diskspacetreshold = PyInt_AsLong(value);
12238         return 0;
12239 }
12240
12241 static PyGetSetDef py_srvsvc_NetSrvInfo1550_getsetters[] = {
12242         { discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo1550_get_diskspacetreshold, py_srvsvc_NetSrvInfo1550_set_diskspacetreshold },
12243         { NULL }
12244 };
12245
12246 static PyObject *py_srvsvc_NetSrvInfo1550_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12247 {
12248         return pytalloc_new(struct srvsvc_NetSrvInfo1550, type);
12249 }
12250
12251
12252 static PyTypeObject srvsvc_NetSrvInfo1550_Type = {
12253         PyObject_HEAD_INIT(NULL) 0,
12254         .tp_name = "srvsvc.NetSrvInfo1550",
12255         .tp_getset = py_srvsvc_NetSrvInfo1550_getsetters,
12256         .tp_methods = NULL,
12257         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12258         .tp_basicsize = sizeof(pytalloc_Object),
12259         .tp_new = py_srvsvc_NetSrvInfo1550_new,
12260 };
12261
12262
12263 static PyObject *py_srvsvc_NetSrvInfo1552_get_maxlinkdelay(PyObject *obj, void *closure)
12264 {
12265         struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(obj);
12266         PyObject *py_maxlinkdelay;
12267         py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
12268         return py_maxlinkdelay;
12269 }
12270
12271 static int py_srvsvc_NetSrvInfo1552_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
12272 {
12273         struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(py_obj);
12274         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12275         object->maxlinkdelay = PyInt_AsLong(value);
12276         return 0;
12277 }
12278
12279 static PyGetSetDef py_srvsvc_NetSrvInfo1552_getsetters[] = {
12280         { discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo1552_get_maxlinkdelay, py_srvsvc_NetSrvInfo1552_set_maxlinkdelay },
12281         { NULL }
12282 };
12283
12284 static PyObject *py_srvsvc_NetSrvInfo1552_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12285 {
12286         return pytalloc_new(struct srvsvc_NetSrvInfo1552, type);
12287 }
12288
12289
12290 static PyTypeObject srvsvc_NetSrvInfo1552_Type = {
12291         PyObject_HEAD_INIT(NULL) 0,
12292         .tp_name = "srvsvc.NetSrvInfo1552",
12293         .tp_getset = py_srvsvc_NetSrvInfo1552_getsetters,
12294         .tp_methods = NULL,
12295         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12296         .tp_basicsize = sizeof(pytalloc_Object),
12297         .tp_new = py_srvsvc_NetSrvInfo1552_new,
12298 };
12299
12300
12301 static PyObject *py_srvsvc_NetSrvInfo1553_get_minlinkthroughput(PyObject *obj, void *closure)
12302 {
12303         struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(obj);
12304         PyObject *py_minlinkthroughput;
12305         py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
12306         return py_minlinkthroughput;
12307 }
12308
12309 static int py_srvsvc_NetSrvInfo1553_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
12310 {
12311         struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(py_obj);
12312         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12313         object->minlinkthroughput = PyInt_AsLong(value);
12314         return 0;
12315 }
12316
12317 static PyGetSetDef py_srvsvc_NetSrvInfo1553_getsetters[] = {
12318         { discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo1553_get_minlinkthroughput, py_srvsvc_NetSrvInfo1553_set_minlinkthroughput },
12319         { NULL }
12320 };
12321
12322 static PyObject *py_srvsvc_NetSrvInfo1553_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12323 {
12324         return pytalloc_new(struct srvsvc_NetSrvInfo1553, type);
12325 }
12326
12327
12328 static PyTypeObject srvsvc_NetSrvInfo1553_Type = {
12329         PyObject_HEAD_INIT(NULL) 0,
12330         .tp_name = "srvsvc.NetSrvInfo1553",
12331         .tp_getset = py_srvsvc_NetSrvInfo1553_getsetters,
12332         .tp_methods = NULL,
12333         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12334         .tp_basicsize = sizeof(pytalloc_Object),
12335         .tp_new = py_srvsvc_NetSrvInfo1553_new,
12336 };
12337
12338
12339 static PyObject *py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime(PyObject *obj, void *closure)
12340 {
12341         struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(obj);
12342         PyObject *py_linkinfovalidtime;
12343         py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
12344         return py_linkinfovalidtime;
12345 }
12346
12347 static int py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
12348 {
12349         struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(py_obj);
12350         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12351         object->linkinfovalidtime = PyInt_AsLong(value);
12352         return 0;
12353 }
12354
12355 static PyGetSetDef py_srvsvc_NetSrvInfo1554_getsetters[] = {
12356         { discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime, py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime },
12357         { NULL }
12358 };
12359
12360 static PyObject *py_srvsvc_NetSrvInfo1554_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12361 {
12362         return pytalloc_new(struct srvsvc_NetSrvInfo1554, type);
12363 }
12364
12365
12366 static PyTypeObject srvsvc_NetSrvInfo1554_Type = {
12367         PyObject_HEAD_INIT(NULL) 0,
12368         .tp_name = "srvsvc.NetSrvInfo1554",
12369         .tp_getset = py_srvsvc_NetSrvInfo1554_getsetters,
12370         .tp_methods = NULL,
12371         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12372         .tp_basicsize = sizeof(pytalloc_Object),
12373         .tp_new = py_srvsvc_NetSrvInfo1554_new,
12374 };
12375
12376
12377 static PyObject *py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
12378 {
12379         struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(obj);
12380         PyObject *py_scavqosinfoupdatetime;
12381         py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
12382         return py_scavqosinfoupdatetime;
12383 }
12384
12385 static int py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
12386 {
12387         struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(py_obj);
12388         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12389         object->scavqosinfoupdatetime = PyInt_AsLong(value);
12390         return 0;
12391 }
12392
12393 static PyGetSetDef py_srvsvc_NetSrvInfo1555_getsetters[] = {
12394         { discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime },
12395         { NULL }
12396 };
12397
12398 static PyObject *py_srvsvc_NetSrvInfo1555_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12399 {
12400         return pytalloc_new(struct srvsvc_NetSrvInfo1555, type);
12401 }
12402
12403
12404 static PyTypeObject srvsvc_NetSrvInfo1555_Type = {
12405         PyObject_HEAD_INIT(NULL) 0,
12406         .tp_name = "srvsvc.NetSrvInfo1555",
12407         .tp_getset = py_srvsvc_NetSrvInfo1555_getsetters,
12408         .tp_methods = NULL,
12409         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12410         .tp_basicsize = sizeof(pytalloc_Object),
12411         .tp_new = py_srvsvc_NetSrvInfo1555_new,
12412 };
12413
12414
12415 static PyObject *py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime(PyObject *obj, void *closure)
12416 {
12417         struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(obj);
12418         PyObject *py_maxworkitemidletime;
12419         py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
12420         return py_maxworkitemidletime;
12421 }
12422
12423 static int py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
12424 {
12425         struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(py_obj);
12426         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12427         object->maxworkitemidletime = PyInt_AsLong(value);
12428         return 0;
12429 }
12430
12431 static PyGetSetDef py_srvsvc_NetSrvInfo1556_getsetters[] = {
12432         { discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime, py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime },
12433         { NULL }
12434 };
12435
12436 static PyObject *py_srvsvc_NetSrvInfo1556_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12437 {
12438         return pytalloc_new(struct srvsvc_NetSrvInfo1556, type);
12439 }
12440
12441
12442 static PyTypeObject srvsvc_NetSrvInfo1556_Type = {
12443         PyObject_HEAD_INIT(NULL) 0,
12444         .tp_name = "srvsvc.NetSrvInfo1556",
12445         .tp_getset = py_srvsvc_NetSrvInfo1556_getsetters,
12446         .tp_methods = NULL,
12447         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12448         .tp_basicsize = sizeof(pytalloc_Object),
12449         .tp_new = py_srvsvc_NetSrvInfo1556_new,
12450 };
12451
12452 static PyObject *py_import_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSrvInfo *in)
12453 {
12454         PyObject *ret;
12455
12456         switch (level) {
12457                 case 100:
12458                         if (in->info100 == NULL) {
12459                                 ret = Py_None;
12460                                 Py_INCREF(ret);
12461                         } else {
12462                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo100_Type, in->info100, in->info100);
12463                         }
12464                         return ret;
12465
12466                 case 101:
12467                         if (in->info101 == NULL) {
12468                                 ret = Py_None;
12469                                 Py_INCREF(ret);
12470                         } else {
12471                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo101_Type, in->info101, in->info101);
12472                         }
12473                         return ret;
12474
12475                 case 102:
12476                         if (in->info102 == NULL) {
12477                                 ret = Py_None;
12478                                 Py_INCREF(ret);
12479                         } else {
12480                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo102_Type, in->info102, in->info102);
12481                         }
12482                         return ret;
12483
12484                 case 402:
12485                         if (in->info402 == NULL) {
12486                                 ret = Py_None;
12487                                 Py_INCREF(ret);
12488                         } else {
12489                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo402_Type, in->info402, in->info402);
12490                         }
12491                         return ret;
12492
12493                 case 403:
12494                         if (in->info403 == NULL) {
12495                                 ret = Py_None;
12496                                 Py_INCREF(ret);
12497                         } else {
12498                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo403_Type, in->info403, in->info403);
12499                         }
12500                         return ret;
12501
12502                 case 502:
12503                         if (in->info502 == NULL) {
12504                                 ret = Py_None;
12505                                 Py_INCREF(ret);
12506                         } else {
12507                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo502_Type, in->info502, in->info502);
12508                         }
12509                         return ret;
12510
12511                 case 503:
12512                         if (in->info503 == NULL) {
12513                                 ret = Py_None;
12514                                 Py_INCREF(ret);
12515                         } else {
12516                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo503_Type, in->info503, in->info503);
12517                         }
12518                         return ret;
12519
12520                 case 599:
12521                         if (in->info599 == NULL) {
12522                                 ret = Py_None;
12523                                 Py_INCREF(ret);
12524                         } else {
12525                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo599_Type, in->info599, in->info599);
12526                         }
12527                         return ret;
12528
12529                 case 1005:
12530                         if (in->info1005 == NULL) {
12531                                 ret = Py_None;
12532                                 Py_INCREF(ret);
12533                         } else {
12534                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1005_Type, in->info1005, in->info1005);
12535                         }
12536                         return ret;
12537
12538                 case 1010:
12539                         if (in->info1010 == NULL) {
12540                                 ret = Py_None;
12541                                 Py_INCREF(ret);
12542                         } else {
12543                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1010_Type, in->info1010, in->info1010);
12544                         }
12545                         return ret;
12546
12547                 case 1016:
12548                         if (in->info1016 == NULL) {
12549                                 ret = Py_None;
12550                                 Py_INCREF(ret);
12551                         } else {
12552                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1016_Type, in->info1016, in->info1016);
12553                         }
12554                         return ret;
12555
12556                 case 1017:
12557                         if (in->info1017 == NULL) {
12558                                 ret = Py_None;
12559                                 Py_INCREF(ret);
12560                         } else {
12561                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1017_Type, in->info1017, in->info1017);
12562                         }
12563                         return ret;
12564
12565                 case 1018:
12566                         if (in->info1018 == NULL) {
12567                                 ret = Py_None;
12568                                 Py_INCREF(ret);
12569                         } else {
12570                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1018_Type, in->info1018, in->info1018);
12571                         }
12572                         return ret;
12573
12574                 case 1107:
12575                         if (in->info1107 == NULL) {
12576                                 ret = Py_None;
12577                                 Py_INCREF(ret);
12578                         } else {
12579                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1107_Type, in->info1107, in->info1107);
12580                         }
12581                         return ret;
12582
12583                 case 1501:
12584                         if (in->info1501 == NULL) {
12585                                 ret = Py_None;
12586                                 Py_INCREF(ret);
12587                         } else {
12588                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1501_Type, in->info1501, in->info1501);
12589                         }
12590                         return ret;
12591
12592                 case 1502:
12593                         if (in->info1502 == NULL) {
12594                                 ret = Py_None;
12595                                 Py_INCREF(ret);
12596                         } else {
12597                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1502_Type, in->info1502, in->info1502);
12598                         }
12599                         return ret;
12600
12601                 case 1503:
12602                         if (in->info1503 == NULL) {
12603                                 ret = Py_None;
12604                                 Py_INCREF(ret);
12605                         } else {
12606                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1503_Type, in->info1503, in->info1503);
12607                         }
12608                         return ret;
12609
12610                 case 1506:
12611                         if (in->info1506 == NULL) {
12612                                 ret = Py_None;
12613                                 Py_INCREF(ret);
12614                         } else {
12615                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1506_Type, in->info1506, in->info1506);
12616                         }
12617                         return ret;
12618
12619                 case 1509:
12620                         if (in->info1509 == NULL) {
12621                                 ret = Py_None;
12622                                 Py_INCREF(ret);
12623                         } else {
12624                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1509_Type, in->info1509, in->info1509);
12625                         }
12626                         return ret;
12627
12628                 case 1510:
12629                         if (in->info1510 == NULL) {
12630                                 ret = Py_None;
12631                                 Py_INCREF(ret);
12632                         } else {
12633                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1510_Type, in->info1510, in->info1510);
12634                         }
12635                         return ret;
12636
12637                 case 1511:
12638                         if (in->info1511 == NULL) {
12639                                 ret = Py_None;
12640                                 Py_INCREF(ret);
12641                         } else {
12642                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1511_Type, in->info1511, in->info1511);
12643                         }
12644                         return ret;
12645
12646                 case 1512:
12647                         if (in->info1512 == NULL) {
12648                                 ret = Py_None;
12649                                 Py_INCREF(ret);
12650                         } else {
12651                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1512_Type, in->info1512, in->info1512);
12652                         }
12653                         return ret;
12654
12655                 case 1513:
12656                         if (in->info1513 == NULL) {
12657                                 ret = Py_None;
12658                                 Py_INCREF(ret);
12659                         } else {
12660                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1513_Type, in->info1513, in->info1513);
12661                         }
12662                         return ret;
12663
12664                 case 1514:
12665                         if (in->info1514 == NULL) {
12666                                 ret = Py_None;
12667                                 Py_INCREF(ret);
12668                         } else {
12669                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1514_Type, in->info1514, in->info1514);
12670                         }
12671                         return ret;
12672
12673                 case 1515:
12674                         if (in->info1515 == NULL) {
12675                                 ret = Py_None;
12676                                 Py_INCREF(ret);
12677                         } else {
12678                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1515_Type, in->info1515, in->info1515);
12679                         }
12680                         return ret;
12681
12682                 case 1516:
12683                         if (in->info1516 == NULL) {
12684                                 ret = Py_None;
12685                                 Py_INCREF(ret);
12686                         } else {
12687                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1516_Type, in->info1516, in->info1516);
12688                         }
12689                         return ret;
12690
12691                 case 1518:
12692                         if (in->info1518 == NULL) {
12693                                 ret = Py_None;
12694                                 Py_INCREF(ret);
12695                         } else {
12696                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1518_Type, in->info1518, in->info1518);
12697                         }
12698                         return ret;
12699
12700                 case 1520:
12701                         if (in->info1520 == NULL) {
12702                                 ret = Py_None;
12703                                 Py_INCREF(ret);
12704                         } else {
12705                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1520_Type, in->info1520, in->info1520);
12706                         }
12707                         return ret;
12708
12709                 case 1521:
12710                         if (in->info1521 == NULL) {
12711                                 ret = Py_None;
12712                                 Py_INCREF(ret);
12713                         } else {
12714                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1521_Type, in->info1521, in->info1521);
12715                         }
12716                         return ret;
12717
12718                 case 1522:
12719                         if (in->info1522 == NULL) {
12720                                 ret = Py_None;
12721                                 Py_INCREF(ret);
12722                         } else {
12723                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1522_Type, in->info1522, in->info1522);
12724                         }
12725                         return ret;
12726
12727                 case 1523:
12728                         if (in->info1523 == NULL) {
12729                                 ret = Py_None;
12730                                 Py_INCREF(ret);
12731                         } else {
12732                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1523_Type, in->info1523, in->info1523);
12733                         }
12734                         return ret;
12735
12736                 case 1524:
12737                         if (in->info1524 == NULL) {
12738                                 ret = Py_None;
12739                                 Py_INCREF(ret);
12740                         } else {
12741                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1524_Type, in->info1524, in->info1524);
12742                         }
12743                         return ret;
12744
12745                 case 1525:
12746                         if (in->info1525 == NULL) {
12747                                 ret = Py_None;
12748                                 Py_INCREF(ret);
12749                         } else {
12750                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1525_Type, in->info1525, in->info1525);
12751                         }
12752                         return ret;
12753
12754                 case 1528:
12755                         if (in->info1528 == NULL) {
12756                                 ret = Py_None;
12757                                 Py_INCREF(ret);
12758                         } else {
12759                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1528_Type, in->info1528, in->info1528);
12760                         }
12761                         return ret;
12762
12763                 case 1529:
12764                         if (in->info1529 == NULL) {
12765                                 ret = Py_None;
12766                                 Py_INCREF(ret);
12767                         } else {
12768                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1529_Type, in->info1529, in->info1529);
12769                         }
12770                         return ret;
12771
12772                 case 1530:
12773                         if (in->info1530 == NULL) {
12774                                 ret = Py_None;
12775                                 Py_INCREF(ret);
12776                         } else {
12777                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1530_Type, in->info1530, in->info1530);
12778                         }
12779                         return ret;
12780
12781                 case 1533:
12782                         if (in->info1533 == NULL) {
12783                                 ret = Py_None;
12784                                 Py_INCREF(ret);
12785                         } else {
12786                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1533_Type, in->info1533, in->info1533);
12787                         }
12788                         return ret;
12789
12790                 case 1534:
12791                         if (in->info1534 == NULL) {
12792                                 ret = Py_None;
12793                                 Py_INCREF(ret);
12794                         } else {
12795                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1534_Type, in->info1534, in->info1534);
12796                         }
12797                         return ret;
12798
12799                 case 1535:
12800                         if (in->info1535 == NULL) {
12801                                 ret = Py_None;
12802                                 Py_INCREF(ret);
12803                         } else {
12804                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1535_Type, in->info1535, in->info1535);
12805                         }
12806                         return ret;
12807
12808                 case 1536:
12809                         if (in->info1536 == NULL) {
12810                                 ret = Py_None;
12811                                 Py_INCREF(ret);
12812                         } else {
12813                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1536_Type, in->info1536, in->info1536);
12814                         }
12815                         return ret;
12816
12817                 case 1537:
12818                         if (in->info1537 == NULL) {
12819                                 ret = Py_None;
12820                                 Py_INCREF(ret);
12821                         } else {
12822                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1537_Type, in->info1537, in->info1537);
12823                         }
12824                         return ret;
12825
12826                 case 1538:
12827                         if (in->info1538 == NULL) {
12828                                 ret = Py_None;
12829                                 Py_INCREF(ret);
12830                         } else {
12831                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1538_Type, in->info1538, in->info1538);
12832                         }
12833                         return ret;
12834
12835                 case 1539:
12836                         if (in->info1539 == NULL) {
12837                                 ret = Py_None;
12838                                 Py_INCREF(ret);
12839                         } else {
12840                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1539_Type, in->info1539, in->info1539);
12841                         }
12842                         return ret;
12843
12844                 case 1540:
12845                         if (in->info1540 == NULL) {
12846                                 ret = Py_None;
12847                                 Py_INCREF(ret);
12848                         } else {
12849                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1540_Type, in->info1540, in->info1540);
12850                         }
12851                         return ret;
12852
12853                 case 1541:
12854                         if (in->info1541 == NULL) {
12855                                 ret = Py_None;
12856                                 Py_INCREF(ret);
12857                         } else {
12858                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1541_Type, in->info1541, in->info1541);
12859                         }
12860                         return ret;
12861
12862                 case 1542:
12863                         if (in->info1542 == NULL) {
12864                                 ret = Py_None;
12865                                 Py_INCREF(ret);
12866                         } else {
12867                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1542_Type, in->info1542, in->info1542);
12868                         }
12869                         return ret;
12870
12871                 case 1543:
12872                         if (in->info1543 == NULL) {
12873                                 ret = Py_None;
12874                                 Py_INCREF(ret);
12875                         } else {
12876                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1543_Type, in->info1543, in->info1543);
12877                         }
12878                         return ret;
12879
12880                 case 1544:
12881                         if (in->info1544 == NULL) {
12882                                 ret = Py_None;
12883                                 Py_INCREF(ret);
12884                         } else {
12885                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1544_Type, in->info1544, in->info1544);
12886                         }
12887                         return ret;
12888
12889                 case 1545:
12890                         if (in->info1545 == NULL) {
12891                                 ret = Py_None;
12892                                 Py_INCREF(ret);
12893                         } else {
12894                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1545_Type, in->info1545, in->info1545);
12895                         }
12896                         return ret;
12897
12898                 case 1546:
12899                         if (in->info1546 == NULL) {
12900                                 ret = Py_None;
12901                                 Py_INCREF(ret);
12902                         } else {
12903                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1546_Type, in->info1546, in->info1546);
12904                         }
12905                         return ret;
12906
12907                 case 1547:
12908                         if (in->info1547 == NULL) {
12909                                 ret = Py_None;
12910                                 Py_INCREF(ret);
12911                         } else {
12912                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1547_Type, in->info1547, in->info1547);
12913                         }
12914                         return ret;
12915
12916                 case 1548:
12917                         if (in->info1548 == NULL) {
12918                                 ret = Py_None;
12919                                 Py_INCREF(ret);
12920                         } else {
12921                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1548_Type, in->info1548, in->info1548);
12922                         }
12923                         return ret;
12924
12925                 case 1549:
12926                         if (in->info1549 == NULL) {
12927                                 ret = Py_None;
12928                                 Py_INCREF(ret);
12929                         } else {
12930                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1549_Type, in->info1549, in->info1549);
12931                         }
12932                         return ret;
12933
12934                 case 1550:
12935                         if (in->info1550 == NULL) {
12936                                 ret = Py_None;
12937                                 Py_INCREF(ret);
12938                         } else {
12939                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1550_Type, in->info1550, in->info1550);
12940                         }
12941                         return ret;
12942
12943                 case 1552:
12944                         if (in->info1552 == NULL) {
12945                                 ret = Py_None;
12946                                 Py_INCREF(ret);
12947                         } else {
12948                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1552_Type, in->info1552, in->info1552);
12949                         }
12950                         return ret;
12951
12952                 case 1553:
12953                         if (in->info1553 == NULL) {
12954                                 ret = Py_None;
12955                                 Py_INCREF(ret);
12956                         } else {
12957                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1553_Type, in->info1553, in->info1553);
12958                         }
12959                         return ret;
12960
12961                 case 1554:
12962                         if (in->info1554 == NULL) {
12963                                 ret = Py_None;
12964                                 Py_INCREF(ret);
12965                         } else {
12966                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1554_Type, in->info1554, in->info1554);
12967                         }
12968                         return ret;
12969
12970                 case 1555:
12971                         if (in->info1555 == NULL) {
12972                                 ret = Py_None;
12973                                 Py_INCREF(ret);
12974                         } else {
12975                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1555_Type, in->info1555, in->info1555);
12976                         }
12977                         return ret;
12978
12979                 case 1556:
12980                         if (in->info1556 == NULL) {
12981                                 ret = Py_None;
12982                                 Py_INCREF(ret);
12983                         } else {
12984                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1556_Type, in->info1556, in->info1556);
12985                         }
12986                         return ret;
12987
12988                 default:
12989                         ret = Py_None;
12990                         Py_INCREF(ret);
12991                         return ret;
12992
12993         }
12994         PyErr_SetString(PyExc_TypeError, "unknown union level");
12995         return NULL;
12996 }
12997
12998 static union srvsvc_NetSrvInfo *py_export_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
12999 {
13000         union srvsvc_NetSrvInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetSrvInfo);
13001         switch (level) {
13002                 case 100:
13003                         if (in == Py_None) {
13004                                 ret->info100 = NULL;
13005                         } else {
13006                                 ret->info100 = NULL;
13007                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo100_Type, in, talloc_free(ret); return NULL;);
13008                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13009                                         PyErr_NoMemory();
13010                                         talloc_free(ret); return NULL;
13011                                 }
13012                                 ret->info100 = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(in);
13013                         }
13014                         break;
13015
13016                 case 101:
13017                         if (in == Py_None) {
13018                                 ret->info101 = NULL;
13019                         } else {
13020                                 ret->info101 = NULL;
13021                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo101_Type, in, talloc_free(ret); return NULL;);
13022                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13023                                         PyErr_NoMemory();
13024                                         talloc_free(ret); return NULL;
13025                                 }
13026                                 ret->info101 = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(in);
13027                         }
13028                         break;
13029
13030                 case 102:
13031                         if (in == Py_None) {
13032                                 ret->info102 = NULL;
13033                         } else {
13034                                 ret->info102 = NULL;
13035                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo102_Type, in, talloc_free(ret); return NULL;);
13036                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13037                                         PyErr_NoMemory();
13038                                         talloc_free(ret); return NULL;
13039                                 }
13040                                 ret->info102 = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(in);
13041                         }
13042                         break;
13043
13044                 case 402:
13045                         if (in == Py_None) {
13046                                 ret->info402 = NULL;
13047                         } else {
13048                                 ret->info402 = NULL;
13049                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo402_Type, in, talloc_free(ret); return NULL;);
13050                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13051                                         PyErr_NoMemory();
13052                                         talloc_free(ret); return NULL;
13053                                 }
13054                                 ret->info402 = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(in);
13055                         }
13056                         break;
13057
13058                 case 403:
13059                         if (in == Py_None) {
13060                                 ret->info403 = NULL;
13061                         } else {
13062                                 ret->info403 = NULL;
13063                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo403_Type, in, talloc_free(ret); return NULL;);
13064                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13065                                         PyErr_NoMemory();
13066                                         talloc_free(ret); return NULL;
13067                                 }
13068                                 ret->info403 = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(in);
13069                         }
13070                         break;
13071
13072                 case 502:
13073                         if (in == Py_None) {
13074                                 ret->info502 = NULL;
13075                         } else {
13076                                 ret->info502 = NULL;
13077                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo502_Type, in, talloc_free(ret); return NULL;);
13078                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13079                                         PyErr_NoMemory();
13080                                         talloc_free(ret); return NULL;
13081                                 }
13082                                 ret->info502 = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(in);
13083                         }
13084                         break;
13085
13086                 case 503:
13087                         if (in == Py_None) {
13088                                 ret->info503 = NULL;
13089                         } else {
13090                                 ret->info503 = NULL;
13091                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo503_Type, in, talloc_free(ret); return NULL;);
13092                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13093                                         PyErr_NoMemory();
13094                                         talloc_free(ret); return NULL;
13095                                 }
13096                                 ret->info503 = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(in);
13097                         }
13098                         break;
13099
13100                 case 599:
13101                         if (in == Py_None) {
13102                                 ret->info599 = NULL;
13103                         } else {
13104                                 ret->info599 = NULL;
13105                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo599_Type, in, talloc_free(ret); return NULL;);
13106                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13107                                         PyErr_NoMemory();
13108                                         talloc_free(ret); return NULL;
13109                                 }
13110                                 ret->info599 = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(in);
13111                         }
13112                         break;
13113
13114                 case 1005:
13115                         if (in == Py_None) {
13116                                 ret->info1005 = NULL;
13117                         } else {
13118                                 ret->info1005 = NULL;
13119                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1005_Type, in, talloc_free(ret); return NULL;);
13120                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13121                                         PyErr_NoMemory();
13122                                         talloc_free(ret); return NULL;
13123                                 }
13124                                 ret->info1005 = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(in);
13125                         }
13126                         break;
13127
13128                 case 1010:
13129                         if (in == Py_None) {
13130                                 ret->info1010 = NULL;
13131                         } else {
13132                                 ret->info1010 = NULL;
13133                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1010_Type, in, talloc_free(ret); return NULL;);
13134                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13135                                         PyErr_NoMemory();
13136                                         talloc_free(ret); return NULL;
13137                                 }
13138                                 ret->info1010 = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(in);
13139                         }
13140                         break;
13141
13142                 case 1016:
13143                         if (in == Py_None) {
13144                                 ret->info1016 = NULL;
13145                         } else {
13146                                 ret->info1016 = NULL;
13147                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1016_Type, in, talloc_free(ret); return NULL;);
13148                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13149                                         PyErr_NoMemory();
13150                                         talloc_free(ret); return NULL;
13151                                 }
13152                                 ret->info1016 = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(in);
13153                         }
13154                         break;
13155
13156                 case 1017:
13157                         if (in == Py_None) {
13158                                 ret->info1017 = NULL;
13159                         } else {
13160                                 ret->info1017 = NULL;
13161                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1017_Type, in, talloc_free(ret); return NULL;);
13162                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13163                                         PyErr_NoMemory();
13164                                         talloc_free(ret); return NULL;
13165                                 }
13166                                 ret->info1017 = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(in);
13167                         }
13168                         break;
13169
13170                 case 1018:
13171                         if (in == Py_None) {
13172                                 ret->info1018 = NULL;
13173                         } else {
13174                                 ret->info1018 = NULL;
13175                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1018_Type, in, talloc_free(ret); return NULL;);
13176                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13177                                         PyErr_NoMemory();
13178                                         talloc_free(ret); return NULL;
13179                                 }
13180                                 ret->info1018 = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(in);
13181                         }
13182                         break;
13183
13184                 case 1107:
13185                         if (in == Py_None) {
13186                                 ret->info1107 = NULL;
13187                         } else {
13188                                 ret->info1107 = NULL;
13189                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1107_Type, in, talloc_free(ret); return NULL;);
13190                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13191                                         PyErr_NoMemory();
13192                                         talloc_free(ret); return NULL;
13193                                 }
13194                                 ret->info1107 = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(in);
13195                         }
13196                         break;
13197
13198                 case 1501:
13199                         if (in == Py_None) {
13200                                 ret->info1501 = NULL;
13201                         } else {
13202                                 ret->info1501 = NULL;
13203                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1501_Type, in, talloc_free(ret); return NULL;);
13204                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13205                                         PyErr_NoMemory();
13206                                         talloc_free(ret); return NULL;
13207                                 }
13208                                 ret->info1501 = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(in);
13209                         }
13210                         break;
13211
13212                 case 1502:
13213                         if (in == Py_None) {
13214                                 ret->info1502 = NULL;
13215                         } else {
13216                                 ret->info1502 = NULL;
13217                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1502_Type, in, talloc_free(ret); return NULL;);
13218                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13219                                         PyErr_NoMemory();
13220                                         talloc_free(ret); return NULL;
13221                                 }
13222                                 ret->info1502 = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(in);
13223                         }
13224                         break;
13225
13226                 case 1503:
13227                         if (in == Py_None) {
13228                                 ret->info1503 = NULL;
13229                         } else {
13230                                 ret->info1503 = NULL;
13231                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1503_Type, in, talloc_free(ret); return NULL;);
13232                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13233                                         PyErr_NoMemory();
13234                                         talloc_free(ret); return NULL;
13235                                 }
13236                                 ret->info1503 = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(in);
13237                         }
13238                         break;
13239
13240                 case 1506:
13241                         if (in == Py_None) {
13242                                 ret->info1506 = NULL;
13243                         } else {
13244                                 ret->info1506 = NULL;
13245                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1506_Type, in, talloc_free(ret); return NULL;);
13246                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13247                                         PyErr_NoMemory();
13248                                         talloc_free(ret); return NULL;
13249                                 }
13250                                 ret->info1506 = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(in);
13251                         }
13252                         break;
13253
13254                 case 1509:
13255                         if (in == Py_None) {
13256                                 ret->info1509 = NULL;
13257                         } else {
13258                                 ret->info1509 = NULL;
13259                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1509_Type, in, talloc_free(ret); return NULL;);
13260                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13261                                         PyErr_NoMemory();
13262                                         talloc_free(ret); return NULL;
13263                                 }
13264                                 ret->info1509 = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(in);
13265                         }
13266                         break;
13267
13268                 case 1510:
13269                         if (in == Py_None) {
13270                                 ret->info1510 = NULL;
13271                         } else {
13272                                 ret->info1510 = NULL;
13273                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1510_Type, in, talloc_free(ret); return NULL;);
13274                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13275                                         PyErr_NoMemory();
13276                                         talloc_free(ret); return NULL;
13277                                 }
13278                                 ret->info1510 = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(in);
13279                         }
13280                         break;
13281
13282                 case 1511:
13283                         if (in == Py_None) {
13284                                 ret->info1511 = NULL;
13285                         } else {
13286                                 ret->info1511 = NULL;
13287                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1511_Type, in, talloc_free(ret); return NULL;);
13288                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13289                                         PyErr_NoMemory();
13290                                         talloc_free(ret); return NULL;
13291                                 }
13292                                 ret->info1511 = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(in);
13293                         }
13294                         break;
13295
13296                 case 1512:
13297                         if (in == Py_None) {
13298                                 ret->info1512 = NULL;
13299                         } else {
13300                                 ret->info1512 = NULL;
13301                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1512_Type, in, talloc_free(ret); return NULL;);
13302                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13303                                         PyErr_NoMemory();
13304                                         talloc_free(ret); return NULL;
13305                                 }
13306                                 ret->info1512 = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(in);
13307                         }
13308                         break;
13309
13310                 case 1513:
13311                         if (in == Py_None) {
13312                                 ret->info1513 = NULL;
13313                         } else {
13314                                 ret->info1513 = NULL;
13315                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1513_Type, in, talloc_free(ret); return NULL;);
13316                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13317                                         PyErr_NoMemory();
13318                                         talloc_free(ret); return NULL;
13319                                 }
13320                                 ret->info1513 = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(in);
13321                         }
13322                         break;
13323
13324                 case 1514:
13325                         if (in == Py_None) {
13326                                 ret->info1514 = NULL;
13327                         } else {
13328                                 ret->info1514 = NULL;
13329                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1514_Type, in, talloc_free(ret); return NULL;);
13330                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13331                                         PyErr_NoMemory();
13332                                         talloc_free(ret); return NULL;
13333                                 }
13334                                 ret->info1514 = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(in);
13335                         }
13336                         break;
13337
13338                 case 1515:
13339                         if (in == Py_None) {
13340                                 ret->info1515 = NULL;
13341                         } else {
13342                                 ret->info1515 = NULL;
13343                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1515_Type, in, talloc_free(ret); return NULL;);
13344                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13345                                         PyErr_NoMemory();
13346                                         talloc_free(ret); return NULL;
13347                                 }
13348                                 ret->info1515 = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(in);
13349                         }
13350                         break;
13351
13352                 case 1516:
13353                         if (in == Py_None) {
13354                                 ret->info1516 = NULL;
13355                         } else {
13356                                 ret->info1516 = NULL;
13357                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1516_Type, in, talloc_free(ret); return NULL;);
13358                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13359                                         PyErr_NoMemory();
13360                                         talloc_free(ret); return NULL;
13361                                 }
13362                                 ret->info1516 = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(in);
13363                         }
13364                         break;
13365
13366                 case 1518:
13367                         if (in == Py_None) {
13368                                 ret->info1518 = NULL;
13369                         } else {
13370                                 ret->info1518 = NULL;
13371                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1518_Type, in, talloc_free(ret); return NULL;);
13372                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13373                                         PyErr_NoMemory();
13374                                         talloc_free(ret); return NULL;
13375                                 }
13376                                 ret->info1518 = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(in);
13377                         }
13378                         break;
13379
13380                 case 1520:
13381                         if (in == Py_None) {
13382                                 ret->info1520 = NULL;
13383                         } else {
13384                                 ret->info1520 = NULL;
13385                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1520_Type, in, talloc_free(ret); return NULL;);
13386                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13387                                         PyErr_NoMemory();
13388                                         talloc_free(ret); return NULL;
13389                                 }
13390                                 ret->info1520 = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(in);
13391                         }
13392                         break;
13393
13394                 case 1521:
13395                         if (in == Py_None) {
13396                                 ret->info1521 = NULL;
13397                         } else {
13398                                 ret->info1521 = NULL;
13399                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1521_Type, in, talloc_free(ret); return NULL;);
13400                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13401                                         PyErr_NoMemory();
13402                                         talloc_free(ret); return NULL;
13403                                 }
13404                                 ret->info1521 = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(in);
13405                         }
13406                         break;
13407
13408                 case 1522:
13409                         if (in == Py_None) {
13410                                 ret->info1522 = NULL;
13411                         } else {
13412                                 ret->info1522 = NULL;
13413                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1522_Type, in, talloc_free(ret); return NULL;);
13414                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13415                                         PyErr_NoMemory();
13416                                         talloc_free(ret); return NULL;
13417                                 }
13418                                 ret->info1522 = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(in);
13419                         }
13420                         break;
13421
13422                 case 1523:
13423                         if (in == Py_None) {
13424                                 ret->info1523 = NULL;
13425                         } else {
13426                                 ret->info1523 = NULL;
13427                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1523_Type, in, talloc_free(ret); return NULL;);
13428                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13429                                         PyErr_NoMemory();
13430                                         talloc_free(ret); return NULL;
13431                                 }
13432                                 ret->info1523 = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(in);
13433                         }
13434                         break;
13435
13436                 case 1524:
13437                         if (in == Py_None) {
13438                                 ret->info1524 = NULL;
13439                         } else {
13440                                 ret->info1524 = NULL;
13441                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1524_Type, in, talloc_free(ret); return NULL;);
13442                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13443                                         PyErr_NoMemory();
13444                                         talloc_free(ret); return NULL;
13445                                 }
13446                                 ret->info1524 = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(in);
13447                         }
13448                         break;
13449
13450                 case 1525:
13451                         if (in == Py_None) {
13452                                 ret->info1525 = NULL;
13453                         } else {
13454                                 ret->info1525 = NULL;
13455                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1525_Type, in, talloc_free(ret); return NULL;);
13456                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13457                                         PyErr_NoMemory();
13458                                         talloc_free(ret); return NULL;
13459                                 }
13460                                 ret->info1525 = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(in);
13461                         }
13462                         break;
13463
13464                 case 1528:
13465                         if (in == Py_None) {
13466                                 ret->info1528 = NULL;
13467                         } else {
13468                                 ret->info1528 = NULL;
13469                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1528_Type, in, talloc_free(ret); return NULL;);
13470                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13471                                         PyErr_NoMemory();
13472                                         talloc_free(ret); return NULL;
13473                                 }
13474                                 ret->info1528 = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(in);
13475                         }
13476                         break;
13477
13478                 case 1529:
13479                         if (in == Py_None) {
13480                                 ret->info1529 = NULL;
13481                         } else {
13482                                 ret->info1529 = NULL;
13483                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1529_Type, in, talloc_free(ret); return NULL;);
13484                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13485                                         PyErr_NoMemory();
13486                                         talloc_free(ret); return NULL;
13487                                 }
13488                                 ret->info1529 = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(in);
13489                         }
13490                         break;
13491
13492                 case 1530:
13493                         if (in == Py_None) {
13494                                 ret->info1530 = NULL;
13495                         } else {
13496                                 ret->info1530 = NULL;
13497                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1530_Type, in, talloc_free(ret); return NULL;);
13498                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13499                                         PyErr_NoMemory();
13500                                         talloc_free(ret); return NULL;
13501                                 }
13502                                 ret->info1530 = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(in);
13503                         }
13504                         break;
13505
13506                 case 1533:
13507                         if (in == Py_None) {
13508                                 ret->info1533 = NULL;
13509                         } else {
13510                                 ret->info1533 = NULL;
13511                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1533_Type, in, talloc_free(ret); return NULL;);
13512                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13513                                         PyErr_NoMemory();
13514                                         talloc_free(ret); return NULL;
13515                                 }
13516                                 ret->info1533 = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(in);
13517                         }
13518                         break;
13519
13520                 case 1534:
13521                         if (in == Py_None) {
13522                                 ret->info1534 = NULL;
13523                         } else {
13524                                 ret->info1534 = NULL;
13525                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1534_Type, in, talloc_free(ret); return NULL;);
13526                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13527                                         PyErr_NoMemory();
13528                                         talloc_free(ret); return NULL;
13529                                 }
13530                                 ret->info1534 = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(in);
13531                         }
13532                         break;
13533
13534                 case 1535:
13535                         if (in == Py_None) {
13536                                 ret->info1535 = NULL;
13537                         } else {
13538                                 ret->info1535 = NULL;
13539                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1535_Type, in, talloc_free(ret); return NULL;);
13540                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13541                                         PyErr_NoMemory();
13542                                         talloc_free(ret); return NULL;
13543                                 }
13544                                 ret->info1535 = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(in);
13545                         }
13546                         break;
13547
13548                 case 1536:
13549                         if (in == Py_None) {
13550                                 ret->info1536 = NULL;
13551                         } else {
13552                                 ret->info1536 = NULL;
13553                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1536_Type, in, talloc_free(ret); return NULL;);
13554                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13555                                         PyErr_NoMemory();
13556                                         talloc_free(ret); return NULL;
13557                                 }
13558                                 ret->info1536 = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(in);
13559                         }
13560                         break;
13561
13562                 case 1537:
13563                         if (in == Py_None) {
13564                                 ret->info1537 = NULL;
13565                         } else {
13566                                 ret->info1537 = NULL;
13567                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1537_Type, in, talloc_free(ret); return NULL;);
13568                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13569                                         PyErr_NoMemory();
13570                                         talloc_free(ret); return NULL;
13571                                 }
13572                                 ret->info1537 = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(in);
13573                         }
13574                         break;
13575
13576                 case 1538:
13577                         if (in == Py_None) {
13578                                 ret->info1538 = NULL;
13579                         } else {
13580                                 ret->info1538 = NULL;
13581                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1538_Type, in, talloc_free(ret); return NULL;);
13582                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13583                                         PyErr_NoMemory();
13584                                         talloc_free(ret); return NULL;
13585                                 }
13586                                 ret->info1538 = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(in);
13587                         }
13588                         break;
13589
13590                 case 1539:
13591                         if (in == Py_None) {
13592                                 ret->info1539 = NULL;
13593                         } else {
13594                                 ret->info1539 = NULL;
13595                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1539_Type, in, talloc_free(ret); return NULL;);
13596                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13597                                         PyErr_NoMemory();
13598                                         talloc_free(ret); return NULL;
13599                                 }
13600                                 ret->info1539 = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(in);
13601                         }
13602                         break;
13603
13604                 case 1540:
13605                         if (in == Py_None) {
13606                                 ret->info1540 = NULL;
13607                         } else {
13608                                 ret->info1540 = NULL;
13609                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1540_Type, in, talloc_free(ret); return NULL;);
13610                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13611                                         PyErr_NoMemory();
13612                                         talloc_free(ret); return NULL;
13613                                 }
13614                                 ret->info1540 = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(in);
13615                         }
13616                         break;
13617
13618                 case 1541:
13619                         if (in == Py_None) {
13620                                 ret->info1541 = NULL;
13621                         } else {
13622                                 ret->info1541 = NULL;
13623                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1541_Type, in, talloc_free(ret); return NULL;);
13624                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13625                                         PyErr_NoMemory();
13626                                         talloc_free(ret); return NULL;
13627                                 }
13628                                 ret->info1541 = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(in);
13629                         }
13630                         break;
13631
13632                 case 1542:
13633                         if (in == Py_None) {
13634                                 ret->info1542 = NULL;
13635                         } else {
13636                                 ret->info1542 = NULL;
13637                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1542_Type, in, talloc_free(ret); return NULL;);
13638                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13639                                         PyErr_NoMemory();
13640                                         talloc_free(ret); return NULL;
13641                                 }
13642                                 ret->info1542 = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(in);
13643                         }
13644                         break;
13645
13646                 case 1543:
13647                         if (in == Py_None) {
13648                                 ret->info1543 = NULL;
13649                         } else {
13650                                 ret->info1543 = NULL;
13651                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1543_Type, in, talloc_free(ret); return NULL;);
13652                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13653                                         PyErr_NoMemory();
13654                                         talloc_free(ret); return NULL;
13655                                 }
13656                                 ret->info1543 = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(in);
13657                         }
13658                         break;
13659
13660                 case 1544:
13661                         if (in == Py_None) {
13662                                 ret->info1544 = NULL;
13663                         } else {
13664                                 ret->info1544 = NULL;
13665                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1544_Type, in, talloc_free(ret); return NULL;);
13666                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13667                                         PyErr_NoMemory();
13668                                         talloc_free(ret); return NULL;
13669                                 }
13670                                 ret->info1544 = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(in);
13671                         }
13672                         break;
13673
13674                 case 1545:
13675                         if (in == Py_None) {
13676                                 ret->info1545 = NULL;
13677                         } else {
13678                                 ret->info1545 = NULL;
13679                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1545_Type, in, talloc_free(ret); return NULL;);
13680                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13681                                         PyErr_NoMemory();
13682                                         talloc_free(ret); return NULL;
13683                                 }
13684                                 ret->info1545 = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(in);
13685                         }
13686                         break;
13687
13688                 case 1546:
13689                         if (in == Py_None) {
13690                                 ret->info1546 = NULL;
13691                         } else {
13692                                 ret->info1546 = NULL;
13693                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1546_Type, in, talloc_free(ret); return NULL;);
13694                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13695                                         PyErr_NoMemory();
13696                                         talloc_free(ret); return NULL;
13697                                 }
13698                                 ret->info1546 = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(in);
13699                         }
13700                         break;
13701
13702                 case 1547:
13703                         if (in == Py_None) {
13704                                 ret->info1547 = NULL;
13705                         } else {
13706                                 ret->info1547 = NULL;
13707                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1547_Type, in, talloc_free(ret); return NULL;);
13708                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13709                                         PyErr_NoMemory();
13710                                         talloc_free(ret); return NULL;
13711                                 }
13712                                 ret->info1547 = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(in);
13713                         }
13714                         break;
13715
13716                 case 1548:
13717                         if (in == Py_None) {
13718                                 ret->info1548 = NULL;
13719                         } else {
13720                                 ret->info1548 = NULL;
13721                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1548_Type, in, talloc_free(ret); return NULL;);
13722                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13723                                         PyErr_NoMemory();
13724                                         talloc_free(ret); return NULL;
13725                                 }
13726                                 ret->info1548 = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(in);
13727                         }
13728                         break;
13729
13730                 case 1549:
13731                         if (in == Py_None) {
13732                                 ret->info1549 = NULL;
13733                         } else {
13734                                 ret->info1549 = NULL;
13735                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1549_Type, in, talloc_free(ret); return NULL;);
13736                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13737                                         PyErr_NoMemory();
13738                                         talloc_free(ret); return NULL;
13739                                 }
13740                                 ret->info1549 = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(in);
13741                         }
13742                         break;
13743
13744                 case 1550:
13745                         if (in == Py_None) {
13746                                 ret->info1550 = NULL;
13747                         } else {
13748                                 ret->info1550 = NULL;
13749                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1550_Type, in, talloc_free(ret); return NULL;);
13750                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13751                                         PyErr_NoMemory();
13752                                         talloc_free(ret); return NULL;
13753                                 }
13754                                 ret->info1550 = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(in);
13755                         }
13756                         break;
13757
13758                 case 1552:
13759                         if (in == Py_None) {
13760                                 ret->info1552 = NULL;
13761                         } else {
13762                                 ret->info1552 = NULL;
13763                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1552_Type, in, talloc_free(ret); return NULL;);
13764                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13765                                         PyErr_NoMemory();
13766                                         talloc_free(ret); return NULL;
13767                                 }
13768                                 ret->info1552 = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(in);
13769                         }
13770                         break;
13771
13772                 case 1553:
13773                         if (in == Py_None) {
13774                                 ret->info1553 = NULL;
13775                         } else {
13776                                 ret->info1553 = NULL;
13777                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1553_Type, in, talloc_free(ret); return NULL;);
13778                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13779                                         PyErr_NoMemory();
13780                                         talloc_free(ret); return NULL;
13781                                 }
13782                                 ret->info1553 = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(in);
13783                         }
13784                         break;
13785
13786                 case 1554:
13787                         if (in == Py_None) {
13788                                 ret->info1554 = NULL;
13789                         } else {
13790                                 ret->info1554 = NULL;
13791                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1554_Type, in, talloc_free(ret); return NULL;);
13792                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13793                                         PyErr_NoMemory();
13794                                         talloc_free(ret); return NULL;
13795                                 }
13796                                 ret->info1554 = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(in);
13797                         }
13798                         break;
13799
13800                 case 1555:
13801                         if (in == Py_None) {
13802                                 ret->info1555 = NULL;
13803                         } else {
13804                                 ret->info1555 = NULL;
13805                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1555_Type, in, talloc_free(ret); return NULL;);
13806                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13807                                         PyErr_NoMemory();
13808                                         talloc_free(ret); return NULL;
13809                                 }
13810                                 ret->info1555 = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(in);
13811                         }
13812                         break;
13813
13814                 case 1556:
13815                         if (in == Py_None) {
13816                                 ret->info1556 = NULL;
13817                         } else {
13818                                 ret->info1556 = NULL;
13819                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1556_Type, in, talloc_free(ret); return NULL;);
13820                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13821                                         PyErr_NoMemory();
13822                                         talloc_free(ret); return NULL;
13823                                 }
13824                                 ret->info1556 = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(in);
13825                         }
13826                         break;
13827
13828                 default:
13829                         break;
13830
13831         }
13832
13833         return ret;
13834 }
13835
13836
13837 static PyObject *py_srvsvc_NetDiskInfo0_get___disk_offset(PyObject *obj, void *closure)
13838 {
13839         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13840         PyObject *py___disk_offset;
13841         py___disk_offset = PyInt_FromLong(object->__disk_offset);
13842         return py___disk_offset;
13843 }
13844
13845 static int py_srvsvc_NetDiskInfo0_set___disk_offset(PyObject *py_obj, PyObject *value, void *closure)
13846 {
13847         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13848         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13849         object->__disk_offset = PyInt_AsLong(value);
13850         return 0;
13851 }
13852
13853 static PyObject *py_srvsvc_NetDiskInfo0_get___disk_length(PyObject *obj, void *closure)
13854 {
13855         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13856         PyObject *py___disk_length;
13857         py___disk_length = PyInt_FromLong(object->__disk_length);
13858         return py___disk_length;
13859 }
13860
13861 static int py_srvsvc_NetDiskInfo0_set___disk_length(PyObject *py_obj, PyObject *value, void *closure)
13862 {
13863         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13864         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13865         object->__disk_length = PyInt_AsLong(value);
13866         return 0;
13867 }
13868
13869 static PyObject *py_srvsvc_NetDiskInfo0_get_disk(PyObject *obj, void *closure)
13870 {
13871         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13872         PyObject *py_disk;
13873         if (object->disk == NULL) {
13874                 py_disk = Py_None;
13875                 Py_INCREF(py_disk);
13876         } else {
13877                 py_disk = PyUnicode_Decode(object->disk, strlen(object->disk), "utf-8", "ignore");
13878         }
13879         return py_disk;
13880 }
13881
13882 static int py_srvsvc_NetDiskInfo0_set_disk(PyObject *py_obj, PyObject *value, void *closure)
13883 {
13884         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13885         if (PyUnicode_Check(value)) {
13886                 object->disk = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
13887         } else if (PyString_Check(value)) {
13888                 object->disk = PyString_AS_STRING(value);
13889         } else {
13890                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
13891                 return -1;
13892         }
13893         return 0;
13894 }
13895
13896 static PyGetSetDef py_srvsvc_NetDiskInfo0_getsetters[] = {
13897         { discard_const_p(char, "__disk_offset"), py_srvsvc_NetDiskInfo0_get___disk_offset, py_srvsvc_NetDiskInfo0_set___disk_offset },
13898         { discard_const_p(char, "__disk_length"), py_srvsvc_NetDiskInfo0_get___disk_length, py_srvsvc_NetDiskInfo0_set___disk_length },
13899         { discard_const_p(char, "disk"), py_srvsvc_NetDiskInfo0_get_disk, py_srvsvc_NetDiskInfo0_set_disk },
13900         { NULL }
13901 };
13902
13903 static PyObject *py_srvsvc_NetDiskInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
13904 {
13905         return pytalloc_new(struct srvsvc_NetDiskInfo0, type);
13906 }
13907
13908
13909 static PyTypeObject srvsvc_NetDiskInfo0_Type = {
13910         PyObject_HEAD_INIT(NULL) 0,
13911         .tp_name = "srvsvc.NetDiskInfo0",
13912         .tp_getset = py_srvsvc_NetDiskInfo0_getsetters,
13913         .tp_methods = NULL,
13914         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
13915         .tp_basicsize = sizeof(pytalloc_Object),
13916         .tp_new = py_srvsvc_NetDiskInfo0_new,
13917 };
13918
13919
13920 static PyObject *py_srvsvc_NetDiskInfo_get_count(PyObject *obj, void *closure)
13921 {
13922         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
13923         PyObject *py_count;
13924         py_count = PyInt_FromLong(object->count);
13925         return py_count;
13926 }
13927
13928 static int py_srvsvc_NetDiskInfo_set_count(PyObject *py_obj, PyObject *value, void *closure)
13929 {
13930         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_obj);
13931         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13932         object->count = PyInt_AsLong(value);
13933         return 0;
13934 }
13935
13936 static PyObject *py_srvsvc_NetDiskInfo_get_disks(PyObject *obj, void *closure)
13937 {
13938         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
13939         PyObject *py_disks;
13940         if (object->disks == NULL) {
13941                 py_disks = Py_None;
13942                 Py_INCREF(py_disks);
13943         } else {
13944                 py_disks = PyList_New(object->count);
13945                 if (py_disks == NULL) {
13946                         return NULL;
13947                 }
13948                 {
13949                         int disks_cntr_1;
13950                         for (disks_cntr_1 = 0; disks_cntr_1 < object->count; disks_cntr_1++) {
13951                                 PyObject *py_disks_1;
13952                                 py_disks_1 = pytalloc_reference_ex(&srvsvc_NetDiskInfo0_Type, object->disks, &object->disks[disks_cntr_1]);
13953                                 PyList_SetItem(py_disks, disks_cntr_1, py_disks_1);
13954                         }
13955                 }
13956         }
13957         return py_disks;
13958 }
13959
13960 static int py_srvsvc_NetDiskInfo_set_disks(PyObject *py_obj, PyObject *value, void *closure)
13961 {
13962         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_obj);
13963         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->disks);
13964         if (value == Py_None) {
13965                 object->disks = NULL;
13966         } else {
13967                 object->disks = NULL;
13968                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
13969                 {
13970                         int disks_cntr_1;
13971                         object->disks = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->disks, PyList_GET_SIZE(value));
13972                         if (!object->disks) { return -1;; }
13973                         talloc_set_name_const(object->disks, "ARRAY: object->disks");
13974                         for (disks_cntr_1 = 0; disks_cntr_1 < PyList_GET_SIZE(value); disks_cntr_1++) {
13975                                 PY_CHECK_TYPE(&srvsvc_NetDiskInfo0_Type, PyList_GET_ITEM(value, disks_cntr_1), return -1;);
13976                                 if (talloc_reference(object->disks, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, disks_cntr_1))) == NULL) {
13977                                         PyErr_NoMemory();
13978                                         return -1;
13979                                 }
13980                                 object->disks[disks_cntr_1] = *(struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, disks_cntr_1));
13981                         }
13982                 }
13983         }
13984         return 0;
13985 }
13986
13987 static PyGetSetDef py_srvsvc_NetDiskInfo_getsetters[] = {
13988         { discard_const_p(char, "count"), py_srvsvc_NetDiskInfo_get_count, py_srvsvc_NetDiskInfo_set_count },
13989         { discard_const_p(char, "disks"), py_srvsvc_NetDiskInfo_get_disks, py_srvsvc_NetDiskInfo_set_disks },
13990         { NULL }
13991 };
13992
13993 static PyObject *py_srvsvc_NetDiskInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
13994 {
13995         return pytalloc_new(struct srvsvc_NetDiskInfo, type);
13996 }
13997
13998
13999 static PyTypeObject srvsvc_NetDiskInfo_Type = {
14000         PyObject_HEAD_INIT(NULL) 0,
14001         .tp_name = "srvsvc.NetDiskInfo",
14002         .tp_getset = py_srvsvc_NetDiskInfo_getsetters,
14003         .tp_methods = NULL,
14004         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14005         .tp_basicsize = sizeof(pytalloc_Object),
14006         .tp_new = py_srvsvc_NetDiskInfo_new,
14007 };
14008
14009
14010 static PyObject *py_srvsvc_Statistics_get_start(PyObject *obj, void *closure)
14011 {
14012         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14013         PyObject *py_start;
14014         py_start = PyInt_FromLong(object->start);
14015         return py_start;
14016 }
14017
14018 static int py_srvsvc_Statistics_set_start(PyObject *py_obj, PyObject *value, void *closure)
14019 {
14020         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14021         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14022         object->start = PyInt_AsLong(value);
14023         return 0;
14024 }
14025
14026 static PyObject *py_srvsvc_Statistics_get_fopens(PyObject *obj, void *closure)
14027 {
14028         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14029         PyObject *py_fopens;
14030         py_fopens = PyInt_FromLong(object->fopens);
14031         return py_fopens;
14032 }
14033
14034 static int py_srvsvc_Statistics_set_fopens(PyObject *py_obj, PyObject *value, void *closure)
14035 {
14036         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14037         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14038         object->fopens = PyInt_AsLong(value);
14039         return 0;
14040 }
14041
14042 static PyObject *py_srvsvc_Statistics_get_devopens(PyObject *obj, void *closure)
14043 {
14044         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14045         PyObject *py_devopens;
14046         py_devopens = PyInt_FromLong(object->devopens);
14047         return py_devopens;
14048 }
14049
14050 static int py_srvsvc_Statistics_set_devopens(PyObject *py_obj, PyObject *value, void *closure)
14051 {
14052         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14053         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14054         object->devopens = PyInt_AsLong(value);
14055         return 0;
14056 }
14057
14058 static PyObject *py_srvsvc_Statistics_get_jobsqueued(PyObject *obj, void *closure)
14059 {
14060         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14061         PyObject *py_jobsqueued;
14062         py_jobsqueued = PyInt_FromLong(object->jobsqueued);
14063         return py_jobsqueued;
14064 }
14065
14066 static int py_srvsvc_Statistics_set_jobsqueued(PyObject *py_obj, PyObject *value, void *closure)
14067 {
14068         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14069         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14070         object->jobsqueued = PyInt_AsLong(value);
14071         return 0;
14072 }
14073
14074 static PyObject *py_srvsvc_Statistics_get_sopens(PyObject *obj, void *closure)
14075 {
14076         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14077         PyObject *py_sopens;
14078         py_sopens = PyInt_FromLong(object->sopens);
14079         return py_sopens;
14080 }
14081
14082 static int py_srvsvc_Statistics_set_sopens(PyObject *py_obj, PyObject *value, void *closure)
14083 {
14084         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14085         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14086         object->sopens = PyInt_AsLong(value);
14087         return 0;
14088 }
14089
14090 static PyObject *py_srvsvc_Statistics_get_stimeouts(PyObject *obj, void *closure)
14091 {
14092         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14093         PyObject *py_stimeouts;
14094         py_stimeouts = PyInt_FromLong(object->stimeouts);
14095         return py_stimeouts;
14096 }
14097
14098 static int py_srvsvc_Statistics_set_stimeouts(PyObject *py_obj, PyObject *value, void *closure)
14099 {
14100         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14101         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14102         object->stimeouts = PyInt_AsLong(value);
14103         return 0;
14104 }
14105
14106 static PyObject *py_srvsvc_Statistics_get_serrorout(PyObject *obj, void *closure)
14107 {
14108         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14109         PyObject *py_serrorout;
14110         py_serrorout = PyInt_FromLong(object->serrorout);
14111         return py_serrorout;
14112 }
14113
14114 static int py_srvsvc_Statistics_set_serrorout(PyObject *py_obj, PyObject *value, void *closure)
14115 {
14116         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14117         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14118         object->serrorout = PyInt_AsLong(value);
14119         return 0;
14120 }
14121
14122 static PyObject *py_srvsvc_Statistics_get_pwerrors(PyObject *obj, void *closure)
14123 {
14124         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14125         PyObject *py_pwerrors;
14126         py_pwerrors = PyInt_FromLong(object->pwerrors);
14127         return py_pwerrors;
14128 }
14129
14130 static int py_srvsvc_Statistics_set_pwerrors(PyObject *py_obj, PyObject *value, void *closure)
14131 {
14132         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14133         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14134         object->pwerrors = PyInt_AsLong(value);
14135         return 0;
14136 }
14137
14138 static PyObject *py_srvsvc_Statistics_get_permerrors(PyObject *obj, void *closure)
14139 {
14140         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14141         PyObject *py_permerrors;
14142         py_permerrors = PyInt_FromLong(object->permerrors);
14143         return py_permerrors;
14144 }
14145
14146 static int py_srvsvc_Statistics_set_permerrors(PyObject *py_obj, PyObject *value, void *closure)
14147 {
14148         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14149         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14150         object->permerrors = PyInt_AsLong(value);
14151         return 0;
14152 }
14153
14154 static PyObject *py_srvsvc_Statistics_get_syserrors(PyObject *obj, void *closure)
14155 {
14156         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14157         PyObject *py_syserrors;
14158         py_syserrors = PyInt_FromLong(object->syserrors);
14159         return py_syserrors;
14160 }
14161
14162 static int py_srvsvc_Statistics_set_syserrors(PyObject *py_obj, PyObject *value, void *closure)
14163 {
14164         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14165         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14166         object->syserrors = PyInt_AsLong(value);
14167         return 0;
14168 }
14169
14170 static PyObject *py_srvsvc_Statistics_get_bytessent_low(PyObject *obj, void *closure)
14171 {
14172         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14173         PyObject *py_bytessent_low;
14174         py_bytessent_low = PyInt_FromLong(object->bytessent_low);
14175         return py_bytessent_low;
14176 }
14177
14178 static int py_srvsvc_Statistics_set_bytessent_low(PyObject *py_obj, PyObject *value, void *closure)
14179 {
14180         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14181         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14182         object->bytessent_low = PyInt_AsLong(value);
14183         return 0;
14184 }
14185
14186 static PyObject *py_srvsvc_Statistics_get_bytessent_high(PyObject *obj, void *closure)
14187 {
14188         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14189         PyObject *py_bytessent_high;
14190         py_bytessent_high = PyInt_FromLong(object->bytessent_high);
14191         return py_bytessent_high;
14192 }
14193
14194 static int py_srvsvc_Statistics_set_bytessent_high(PyObject *py_obj, PyObject *value, void *closure)
14195 {
14196         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14197         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14198         object->bytessent_high = PyInt_AsLong(value);
14199         return 0;
14200 }
14201
14202 static PyObject *py_srvsvc_Statistics_get_bytesrcvd_low(PyObject *obj, void *closure)
14203 {
14204         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14205         PyObject *py_bytesrcvd_low;
14206         py_bytesrcvd_low = PyInt_FromLong(object->bytesrcvd_low);
14207         return py_bytesrcvd_low;
14208 }
14209
14210 static int py_srvsvc_Statistics_set_bytesrcvd_low(PyObject *py_obj, PyObject *value, void *closure)
14211 {
14212         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14213         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14214         object->bytesrcvd_low = PyInt_AsLong(value);
14215         return 0;
14216 }
14217
14218 static PyObject *py_srvsvc_Statistics_get_bytesrcvd_high(PyObject *obj, void *closure)
14219 {
14220         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14221         PyObject *py_bytesrcvd_high;
14222         py_bytesrcvd_high = PyInt_FromLong(object->bytesrcvd_high);
14223         return py_bytesrcvd_high;
14224 }
14225
14226 static int py_srvsvc_Statistics_set_bytesrcvd_high(PyObject *py_obj, PyObject *value, void *closure)
14227 {
14228         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14229         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14230         object->bytesrcvd_high = PyInt_AsLong(value);
14231         return 0;
14232 }
14233
14234 static PyObject *py_srvsvc_Statistics_get_avresponse(PyObject *obj, void *closure)
14235 {
14236         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14237         PyObject *py_avresponse;
14238         py_avresponse = PyInt_FromLong(object->avresponse);
14239         return py_avresponse;
14240 }
14241
14242 static int py_srvsvc_Statistics_set_avresponse(PyObject *py_obj, PyObject *value, void *closure)
14243 {
14244         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14245         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14246         object->avresponse = PyInt_AsLong(value);
14247         return 0;
14248 }
14249
14250 static PyObject *py_srvsvc_Statistics_get_reqbufneed(PyObject *obj, void *closure)
14251 {
14252         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14253         PyObject *py_reqbufneed;
14254         py_reqbufneed = PyInt_FromLong(object->reqbufneed);
14255         return py_reqbufneed;
14256 }
14257
14258 static int py_srvsvc_Statistics_set_reqbufneed(PyObject *py_obj, PyObject *value, void *closure)
14259 {
14260         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14261         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14262         object->reqbufneed = PyInt_AsLong(value);
14263         return 0;
14264 }
14265
14266 static PyObject *py_srvsvc_Statistics_get_bigbufneed(PyObject *obj, void *closure)
14267 {
14268         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14269         PyObject *py_bigbufneed;
14270         py_bigbufneed = PyInt_FromLong(object->bigbufneed);
14271         return py_bigbufneed;
14272 }
14273
14274 static int py_srvsvc_Statistics_set_bigbufneed(PyObject *py_obj, PyObject *value, void *closure)
14275 {
14276         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14277         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14278         object->bigbufneed = PyInt_AsLong(value);
14279         return 0;
14280 }
14281
14282 static PyGetSetDef py_srvsvc_Statistics_getsetters[] = {
14283         { discard_const_p(char, "start"), py_srvsvc_Statistics_get_start, py_srvsvc_Statistics_set_start },
14284         { discard_const_p(char, "fopens"), py_srvsvc_Statistics_get_fopens, py_srvsvc_Statistics_set_fopens },
14285         { discard_const_p(char, "devopens"), py_srvsvc_Statistics_get_devopens, py_srvsvc_Statistics_set_devopens },
14286         { discard_const_p(char, "jobsqueued"), py_srvsvc_Statistics_get_jobsqueued, py_srvsvc_Statistics_set_jobsqueued },
14287         { discard_const_p(char, "sopens"), py_srvsvc_Statistics_get_sopens, py_srvsvc_Statistics_set_sopens },
14288         { discard_const_p(char, "stimeouts"), py_srvsvc_Statistics_get_stimeouts, py_srvsvc_Statistics_set_stimeouts },
14289         { discard_const_p(char, "serrorout"), py_srvsvc_Statistics_get_serrorout, py_srvsvc_Statistics_set_serrorout },
14290         { discard_const_p(char, "pwerrors"), py_srvsvc_Statistics_get_pwerrors, py_srvsvc_Statistics_set_pwerrors },
14291         { discard_const_p(char, "permerrors"), py_srvsvc_Statistics_get_permerrors, py_srvsvc_Statistics_set_permerrors },
14292         { discard_const_p(char, "syserrors"), py_srvsvc_Statistics_get_syserrors, py_srvsvc_Statistics_set_syserrors },
14293         { discard_const_p(char, "bytessent_low"), py_srvsvc_Statistics_get_bytessent_low, py_srvsvc_Statistics_set_bytessent_low },
14294         { discard_const_p(char, "bytessent_high"), py_srvsvc_Statistics_get_bytessent_high, py_srvsvc_Statistics_set_bytessent_high },
14295         { discard_const_p(char, "bytesrcvd_low"), py_srvsvc_Statistics_get_bytesrcvd_low, py_srvsvc_Statistics_set_bytesrcvd_low },
14296         { discard_const_p(char, "bytesrcvd_high"), py_srvsvc_Statistics_get_bytesrcvd_high, py_srvsvc_Statistics_set_bytesrcvd_high },
14297         { discard_const_p(char, "avresponse"), py_srvsvc_Statistics_get_avresponse, py_srvsvc_Statistics_set_avresponse },
14298         { discard_const_p(char, "reqbufneed"), py_srvsvc_Statistics_get_reqbufneed, py_srvsvc_Statistics_set_reqbufneed },
14299         { discard_const_p(char, "bigbufneed"), py_srvsvc_Statistics_get_bigbufneed, py_srvsvc_Statistics_set_bigbufneed },
14300         { NULL }
14301 };
14302
14303 static PyObject *py_srvsvc_Statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14304 {
14305         return pytalloc_new(struct srvsvc_Statistics, type);
14306 }
14307
14308
14309 static PyTypeObject srvsvc_Statistics_Type = {
14310         PyObject_HEAD_INIT(NULL) 0,
14311         .tp_name = "srvsvc.Statistics",
14312         .tp_getset = py_srvsvc_Statistics_getsetters,
14313         .tp_methods = NULL,
14314         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14315         .tp_basicsize = sizeof(pytalloc_Object),
14316         .tp_new = py_srvsvc_Statistics_new,
14317 };
14318
14319
14320 static PyObject *py_srvsvc_NetTransportInfo0_get_vcs(PyObject *obj, void *closure)
14321 {
14322         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14323         PyObject *py_vcs;
14324         py_vcs = PyInt_FromLong(object->vcs);
14325         return py_vcs;
14326 }
14327
14328 static int py_srvsvc_NetTransportInfo0_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14329 {
14330         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14331         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14332         object->vcs = PyInt_AsLong(value);
14333         return 0;
14334 }
14335
14336 static PyObject *py_srvsvc_NetTransportInfo0_get_name(PyObject *obj, void *closure)
14337 {
14338         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14339         PyObject *py_name;
14340         if (object->name == NULL) {
14341                 py_name = Py_None;
14342                 Py_INCREF(py_name);
14343         } else {
14344                 if (object->name == NULL) {
14345                         py_name = Py_None;
14346                         Py_INCREF(py_name);
14347                 } else {
14348                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14349                 }
14350         }
14351         return py_name;
14352 }
14353
14354 static int py_srvsvc_NetTransportInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
14355 {
14356         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14357         if (value == Py_None) {
14358                 object->name = NULL;
14359         } else {
14360                 object->name = NULL;
14361                 if (PyUnicode_Check(value)) {
14362                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14363                 } else if (PyString_Check(value)) {
14364                         object->name = PyString_AS_STRING(value);
14365                 } else {
14366                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14367                         return -1;
14368                 }
14369         }
14370         return 0;
14371 }
14372
14373 static PyObject *py_srvsvc_NetTransportInfo0_get_addr(PyObject *obj, void *closure)
14374 {
14375         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14376         PyObject *py_addr;
14377         if (object->addr == NULL) {
14378                 py_addr = Py_None;
14379                 Py_INCREF(py_addr);
14380         } else {
14381                 py_addr = PyList_New(object->addr_len);
14382                 if (py_addr == NULL) {
14383                         return NULL;
14384                 }
14385                 {
14386                         int addr_cntr_1;
14387                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14388                                 PyObject *py_addr_1;
14389                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14390                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14391                         }
14392                 }
14393         }
14394         return py_addr;
14395 }
14396
14397 static int py_srvsvc_NetTransportInfo0_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14398 {
14399         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14400         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14401         if (value == Py_None) {
14402                 object->addr = NULL;
14403         } else {
14404                 object->addr = NULL;
14405                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14406                 {
14407                         int addr_cntr_1;
14408                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14409                         if (!object->addr) { return -1;; }
14410                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14411                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14412                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14413                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14414                         }
14415                 }
14416         }
14417         return 0;
14418 }
14419
14420 static PyObject *py_srvsvc_NetTransportInfo0_get_addr_len(PyObject *obj, void *closure)
14421 {
14422         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14423         PyObject *py_addr_len;
14424         py_addr_len = PyInt_FromLong(object->addr_len);
14425         return py_addr_len;
14426 }
14427
14428 static int py_srvsvc_NetTransportInfo0_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
14429 {
14430         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14431         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14432         object->addr_len = PyInt_AsLong(value);
14433         return 0;
14434 }
14435
14436 static PyObject *py_srvsvc_NetTransportInfo0_get_net_addr(PyObject *obj, void *closure)
14437 {
14438         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14439         PyObject *py_net_addr;
14440         if (object->net_addr == NULL) {
14441                 py_net_addr = Py_None;
14442                 Py_INCREF(py_net_addr);
14443         } else {
14444                 if (object->net_addr == NULL) {
14445                         py_net_addr = Py_None;
14446                         Py_INCREF(py_net_addr);
14447                 } else {
14448                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
14449                 }
14450         }
14451         return py_net_addr;
14452 }
14453
14454 static int py_srvsvc_NetTransportInfo0_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
14455 {
14456         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14457         if (value == Py_None) {
14458                 object->net_addr = NULL;
14459         } else {
14460                 object->net_addr = NULL;
14461                 if (PyUnicode_Check(value)) {
14462                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14463                 } else if (PyString_Check(value)) {
14464                         object->net_addr = PyString_AS_STRING(value);
14465                 } else {
14466                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14467                         return -1;
14468                 }
14469         }
14470         return 0;
14471 }
14472
14473 static PyGetSetDef py_srvsvc_NetTransportInfo0_getsetters[] = {
14474         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo0_get_vcs, py_srvsvc_NetTransportInfo0_set_vcs },
14475         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo0_get_name, py_srvsvc_NetTransportInfo0_set_name },
14476         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo0_get_addr, py_srvsvc_NetTransportInfo0_set_addr },
14477         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo0_get_addr_len, py_srvsvc_NetTransportInfo0_set_addr_len },
14478         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo0_get_net_addr, py_srvsvc_NetTransportInfo0_set_net_addr },
14479         { NULL }
14480 };
14481
14482 static PyObject *py_srvsvc_NetTransportInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14483 {
14484         return pytalloc_new(struct srvsvc_NetTransportInfo0, type);
14485 }
14486
14487
14488 static PyTypeObject srvsvc_NetTransportInfo0_Type = {
14489         PyObject_HEAD_INIT(NULL) 0,
14490         .tp_name = "srvsvc.NetTransportInfo0",
14491         .tp_getset = py_srvsvc_NetTransportInfo0_getsetters,
14492         .tp_methods = NULL,
14493         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14494         .tp_basicsize = sizeof(pytalloc_Object),
14495         .tp_new = py_srvsvc_NetTransportInfo0_new,
14496 };
14497
14498
14499 static PyObject *py_srvsvc_NetTransportCtr0_get_count(PyObject *obj, void *closure)
14500 {
14501         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
14502         PyObject *py_count;
14503         py_count = PyInt_FromLong(object->count);
14504         return py_count;
14505 }
14506
14507 static int py_srvsvc_NetTransportCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
14508 {
14509         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(py_obj);
14510         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14511         object->count = PyInt_AsLong(value);
14512         return 0;
14513 }
14514
14515 static PyObject *py_srvsvc_NetTransportCtr0_get_array(PyObject *obj, void *closure)
14516 {
14517         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
14518         PyObject *py_array;
14519         if (object->array == NULL) {
14520                 py_array = Py_None;
14521                 Py_INCREF(py_array);
14522         } else {
14523                 py_array = PyList_New(object->count);
14524                 if (py_array == NULL) {
14525                         return NULL;
14526                 }
14527                 {
14528                         int array_cntr_1;
14529                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
14530                                 PyObject *py_array_1;
14531                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, object->array, &object->array[array_cntr_1]);
14532                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
14533                         }
14534                 }
14535         }
14536         return py_array;
14537 }
14538
14539 static int py_srvsvc_NetTransportCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
14540 {
14541         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(py_obj);
14542         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
14543         if (value == Py_None) {
14544                 object->array = NULL;
14545         } else {
14546                 object->array = NULL;
14547                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14548                 {
14549                         int array_cntr_1;
14550                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
14551                         if (!object->array) { return -1;; }
14552                         talloc_set_name_const(object->array, "ARRAY: object->array");
14553                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
14554                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
14555                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
14556                                         PyErr_NoMemory();
14557                                         return -1;
14558                                 }
14559                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
14560                         }
14561                 }
14562         }
14563         return 0;
14564 }
14565
14566 static PyGetSetDef py_srvsvc_NetTransportCtr0_getsetters[] = {
14567         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr0_get_count, py_srvsvc_NetTransportCtr0_set_count },
14568         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr0_get_array, py_srvsvc_NetTransportCtr0_set_array },
14569         { NULL }
14570 };
14571
14572 static PyObject *py_srvsvc_NetTransportCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14573 {
14574         return pytalloc_new(struct srvsvc_NetTransportCtr0, type);
14575 }
14576
14577
14578 static PyTypeObject srvsvc_NetTransportCtr0_Type = {
14579         PyObject_HEAD_INIT(NULL) 0,
14580         .tp_name = "srvsvc.NetTransportCtr0",
14581         .tp_getset = py_srvsvc_NetTransportCtr0_getsetters,
14582         .tp_methods = NULL,
14583         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14584         .tp_basicsize = sizeof(pytalloc_Object),
14585         .tp_new = py_srvsvc_NetTransportCtr0_new,
14586 };
14587
14588
14589 static PyObject *py_srvsvc_NetTransportInfo1_get_vcs(PyObject *obj, void *closure)
14590 {
14591         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14592         PyObject *py_vcs;
14593         py_vcs = PyInt_FromLong(object->vcs);
14594         return py_vcs;
14595 }
14596
14597 static int py_srvsvc_NetTransportInfo1_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14598 {
14599         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14600         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14601         object->vcs = PyInt_AsLong(value);
14602         return 0;
14603 }
14604
14605 static PyObject *py_srvsvc_NetTransportInfo1_get_name(PyObject *obj, void *closure)
14606 {
14607         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14608         PyObject *py_name;
14609         if (object->name == NULL) {
14610                 py_name = Py_None;
14611                 Py_INCREF(py_name);
14612         } else {
14613                 if (object->name == NULL) {
14614                         py_name = Py_None;
14615                         Py_INCREF(py_name);
14616                 } else {
14617                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14618                 }
14619         }
14620         return py_name;
14621 }
14622
14623 static int py_srvsvc_NetTransportInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
14624 {
14625         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14626         if (value == Py_None) {
14627                 object->name = NULL;
14628         } else {
14629                 object->name = NULL;
14630                 if (PyUnicode_Check(value)) {
14631                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14632                 } else if (PyString_Check(value)) {
14633                         object->name = PyString_AS_STRING(value);
14634                 } else {
14635                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14636                         return -1;
14637                 }
14638         }
14639         return 0;
14640 }
14641
14642 static PyObject *py_srvsvc_NetTransportInfo1_get_addr(PyObject *obj, void *closure)
14643 {
14644         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14645         PyObject *py_addr;
14646         if (object->addr == NULL) {
14647                 py_addr = Py_None;
14648                 Py_INCREF(py_addr);
14649         } else {
14650                 py_addr = PyList_New(object->addr_len);
14651                 if (py_addr == NULL) {
14652                         return NULL;
14653                 }
14654                 {
14655                         int addr_cntr_1;
14656                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14657                                 PyObject *py_addr_1;
14658                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14659                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14660                         }
14661                 }
14662         }
14663         return py_addr;
14664 }
14665
14666 static int py_srvsvc_NetTransportInfo1_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14667 {
14668         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14669         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14670         if (value == Py_None) {
14671                 object->addr = NULL;
14672         } else {
14673                 object->addr = NULL;
14674                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14675                 {
14676                         int addr_cntr_1;
14677                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14678                         if (!object->addr) { return -1;; }
14679                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14680                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14681                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14682                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14683                         }
14684                 }
14685         }
14686         return 0;
14687 }
14688
14689 static PyObject *py_srvsvc_NetTransportInfo1_get_addr_len(PyObject *obj, void *closure)
14690 {
14691         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14692         PyObject *py_addr_len;
14693         py_addr_len = PyInt_FromLong(object->addr_len);
14694         return py_addr_len;
14695 }
14696
14697 static int py_srvsvc_NetTransportInfo1_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
14698 {
14699         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14700         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14701         object->addr_len = PyInt_AsLong(value);
14702         return 0;
14703 }
14704
14705 static PyObject *py_srvsvc_NetTransportInfo1_get_net_addr(PyObject *obj, void *closure)
14706 {
14707         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14708         PyObject *py_net_addr;
14709         if (object->net_addr == NULL) {
14710                 py_net_addr = Py_None;
14711                 Py_INCREF(py_net_addr);
14712         } else {
14713                 if (object->net_addr == NULL) {
14714                         py_net_addr = Py_None;
14715                         Py_INCREF(py_net_addr);
14716                 } else {
14717                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
14718                 }
14719         }
14720         return py_net_addr;
14721 }
14722
14723 static int py_srvsvc_NetTransportInfo1_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
14724 {
14725         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14726         if (value == Py_None) {
14727                 object->net_addr = NULL;
14728         } else {
14729                 object->net_addr = NULL;
14730                 if (PyUnicode_Check(value)) {
14731                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14732                 } else if (PyString_Check(value)) {
14733                         object->net_addr = PyString_AS_STRING(value);
14734                 } else {
14735                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14736                         return -1;
14737                 }
14738         }
14739         return 0;
14740 }
14741
14742 static PyObject *py_srvsvc_NetTransportInfo1_get_domain(PyObject *obj, void *closure)
14743 {
14744         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14745         PyObject *py_domain;
14746         if (object->domain == NULL) {
14747                 py_domain = Py_None;
14748                 Py_INCREF(py_domain);
14749         } else {
14750                 if (object->domain == NULL) {
14751                         py_domain = Py_None;
14752                         Py_INCREF(py_domain);
14753                 } else {
14754                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
14755                 }
14756         }
14757         return py_domain;
14758 }
14759
14760 static int py_srvsvc_NetTransportInfo1_set_domain(PyObject *py_obj, PyObject *value, void *closure)
14761 {
14762         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14763         if (value == Py_None) {
14764                 object->domain = NULL;
14765         } else {
14766                 object->domain = NULL;
14767                 if (PyUnicode_Check(value)) {
14768                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14769                 } else if (PyString_Check(value)) {
14770                         object->domain = PyString_AS_STRING(value);
14771                 } else {
14772                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14773                         return -1;
14774                 }
14775         }
14776         return 0;
14777 }
14778
14779 static PyGetSetDef py_srvsvc_NetTransportInfo1_getsetters[] = {
14780         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo1_get_vcs, py_srvsvc_NetTransportInfo1_set_vcs },
14781         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo1_get_name, py_srvsvc_NetTransportInfo1_set_name },
14782         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo1_get_addr, py_srvsvc_NetTransportInfo1_set_addr },
14783         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo1_get_addr_len, py_srvsvc_NetTransportInfo1_set_addr_len },
14784         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo1_get_net_addr, py_srvsvc_NetTransportInfo1_set_net_addr },
14785         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo1_get_domain, py_srvsvc_NetTransportInfo1_set_domain },
14786         { NULL }
14787 };
14788
14789 static PyObject *py_srvsvc_NetTransportInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14790 {
14791         return pytalloc_new(struct srvsvc_NetTransportInfo1, type);
14792 }
14793
14794
14795 static PyTypeObject srvsvc_NetTransportInfo1_Type = {
14796         PyObject_HEAD_INIT(NULL) 0,
14797         .tp_name = "srvsvc.NetTransportInfo1",
14798         .tp_getset = py_srvsvc_NetTransportInfo1_getsetters,
14799         .tp_methods = NULL,
14800         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14801         .tp_basicsize = sizeof(pytalloc_Object),
14802         .tp_new = py_srvsvc_NetTransportInfo1_new,
14803 };
14804
14805
14806 static PyObject *py_srvsvc_NetTransportCtr1_get_count(PyObject *obj, void *closure)
14807 {
14808         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
14809         PyObject *py_count;
14810         py_count = PyInt_FromLong(object->count);
14811         return py_count;
14812 }
14813
14814 static int py_srvsvc_NetTransportCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
14815 {
14816         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(py_obj);
14817         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14818         object->count = PyInt_AsLong(value);
14819         return 0;
14820 }
14821
14822 static PyObject *py_srvsvc_NetTransportCtr1_get_array(PyObject *obj, void *closure)
14823 {
14824         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
14825         PyObject *py_array;
14826         if (object->array == NULL) {
14827                 py_array = Py_None;
14828                 Py_INCREF(py_array);
14829         } else {
14830                 py_array = PyList_New(object->count);
14831                 if (py_array == NULL) {
14832                         return NULL;
14833                 }
14834                 {
14835                         int array_cntr_1;
14836                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
14837                                 PyObject *py_array_1;
14838                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, object->array, &object->array[array_cntr_1]);
14839                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
14840                         }
14841                 }
14842         }
14843         return py_array;
14844 }
14845
14846 static int py_srvsvc_NetTransportCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
14847 {
14848         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(py_obj);
14849         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
14850         if (value == Py_None) {
14851                 object->array = NULL;
14852         } else {
14853                 object->array = NULL;
14854                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14855                 {
14856                         int array_cntr_1;
14857                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
14858                         if (!object->array) { return -1;; }
14859                         talloc_set_name_const(object->array, "ARRAY: object->array");
14860                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
14861                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
14862                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
14863                                         PyErr_NoMemory();
14864                                         return -1;
14865                                 }
14866                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
14867                         }
14868                 }
14869         }
14870         return 0;
14871 }
14872
14873 static PyGetSetDef py_srvsvc_NetTransportCtr1_getsetters[] = {
14874         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr1_get_count, py_srvsvc_NetTransportCtr1_set_count },
14875         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr1_get_array, py_srvsvc_NetTransportCtr1_set_array },
14876         { NULL }
14877 };
14878
14879 static PyObject *py_srvsvc_NetTransportCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14880 {
14881         return pytalloc_new(struct srvsvc_NetTransportCtr1, type);
14882 }
14883
14884
14885 static PyTypeObject srvsvc_NetTransportCtr1_Type = {
14886         PyObject_HEAD_INIT(NULL) 0,
14887         .tp_name = "srvsvc.NetTransportCtr1",
14888         .tp_getset = py_srvsvc_NetTransportCtr1_getsetters,
14889         .tp_methods = NULL,
14890         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14891         .tp_basicsize = sizeof(pytalloc_Object),
14892         .tp_new = py_srvsvc_NetTransportCtr1_new,
14893 };
14894
14895
14896 static PyObject *py_srvsvc_NetTransportInfo2_get_vcs(PyObject *obj, void *closure)
14897 {
14898         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14899         PyObject *py_vcs;
14900         py_vcs = PyInt_FromLong(object->vcs);
14901         return py_vcs;
14902 }
14903
14904 static int py_srvsvc_NetTransportInfo2_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14905 {
14906         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14907         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14908         object->vcs = PyInt_AsLong(value);
14909         return 0;
14910 }
14911
14912 static PyObject *py_srvsvc_NetTransportInfo2_get_name(PyObject *obj, void *closure)
14913 {
14914         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14915         PyObject *py_name;
14916         if (object->name == NULL) {
14917                 py_name = Py_None;
14918                 Py_INCREF(py_name);
14919         } else {
14920                 if (object->name == NULL) {
14921                         py_name = Py_None;
14922                         Py_INCREF(py_name);
14923                 } else {
14924                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14925                 }
14926         }
14927         return py_name;
14928 }
14929
14930 static int py_srvsvc_NetTransportInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
14931 {
14932         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14933         if (value == Py_None) {
14934                 object->name = NULL;
14935         } else {
14936                 object->name = NULL;
14937                 if (PyUnicode_Check(value)) {
14938                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14939                 } else if (PyString_Check(value)) {
14940                         object->name = PyString_AS_STRING(value);
14941                 } else {
14942                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14943                         return -1;
14944                 }
14945         }
14946         return 0;
14947 }
14948
14949 static PyObject *py_srvsvc_NetTransportInfo2_get_addr(PyObject *obj, void *closure)
14950 {
14951         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14952         PyObject *py_addr;
14953         if (object->addr == NULL) {
14954                 py_addr = Py_None;
14955                 Py_INCREF(py_addr);
14956         } else {
14957                 py_addr = PyList_New(object->addr_len);
14958                 if (py_addr == NULL) {
14959                         return NULL;
14960                 }
14961                 {
14962                         int addr_cntr_1;
14963                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14964                                 PyObject *py_addr_1;
14965                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14966                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14967                         }
14968                 }
14969         }
14970         return py_addr;
14971 }
14972
14973 static int py_srvsvc_NetTransportInfo2_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14974 {
14975         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14976         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14977         if (value == Py_None) {
14978                 object->addr = NULL;
14979         } else {
14980                 object->addr = NULL;
14981                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14982                 {
14983                         int addr_cntr_1;
14984                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14985                         if (!object->addr) { return -1;; }
14986                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14987                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14988                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14989                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14990                         }
14991                 }
14992         }
14993         return 0;
14994 }
14995
14996 static PyObject *py_srvsvc_NetTransportInfo2_get_addr_len(PyObject *obj, void *closure)
14997 {
14998         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14999         PyObject *py_addr_len;
15000         py_addr_len = PyInt_FromLong(object->addr_len);
15001         return py_addr_len;
15002 }
15003
15004 static int py_srvsvc_NetTransportInfo2_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
15005 {
15006         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15007         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15008         object->addr_len = PyInt_AsLong(value);
15009         return 0;
15010 }
15011
15012 static PyObject *py_srvsvc_NetTransportInfo2_get_net_addr(PyObject *obj, void *closure)
15013 {
15014         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15015         PyObject *py_net_addr;
15016         if (object->net_addr == NULL) {
15017                 py_net_addr = Py_None;
15018                 Py_INCREF(py_net_addr);
15019         } else {
15020                 if (object->net_addr == NULL) {
15021                         py_net_addr = Py_None;
15022                         Py_INCREF(py_net_addr);
15023                 } else {
15024                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
15025                 }
15026         }
15027         return py_net_addr;
15028 }
15029
15030 static int py_srvsvc_NetTransportInfo2_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
15031 {
15032         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15033         if (value == Py_None) {
15034                 object->net_addr = NULL;
15035         } else {
15036                 object->net_addr = NULL;
15037                 if (PyUnicode_Check(value)) {
15038                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15039                 } else if (PyString_Check(value)) {
15040                         object->net_addr = PyString_AS_STRING(value);
15041                 } else {
15042                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15043                         return -1;
15044                 }
15045         }
15046         return 0;
15047 }
15048
15049 static PyObject *py_srvsvc_NetTransportInfo2_get_domain(PyObject *obj, void *closure)
15050 {
15051         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15052         PyObject *py_domain;
15053         if (object->domain == NULL) {
15054                 py_domain = Py_None;
15055                 Py_INCREF(py_domain);
15056         } else {
15057                 if (object->domain == NULL) {
15058                         py_domain = Py_None;
15059                         Py_INCREF(py_domain);
15060                 } else {
15061                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
15062                 }
15063         }
15064         return py_domain;
15065 }
15066
15067 static int py_srvsvc_NetTransportInfo2_set_domain(PyObject *py_obj, PyObject *value, void *closure)
15068 {
15069         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15070         if (value == Py_None) {
15071                 object->domain = NULL;
15072         } else {
15073                 object->domain = NULL;
15074                 if (PyUnicode_Check(value)) {
15075                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15076                 } else if (PyString_Check(value)) {
15077                         object->domain = PyString_AS_STRING(value);
15078                 } else {
15079                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15080                         return -1;
15081                 }
15082         }
15083         return 0;
15084 }
15085
15086 static PyObject *py_srvsvc_NetTransportInfo2_get_unknown(PyObject *obj, void *closure)
15087 {
15088         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15089         PyObject *py_unknown;
15090         py_unknown = PyInt_FromLong(object->unknown);
15091         return py_unknown;
15092 }
15093
15094 static int py_srvsvc_NetTransportInfo2_set_unknown(PyObject *py_obj, PyObject *value, void *closure)
15095 {
15096         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15097         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15098         object->unknown = PyInt_AsLong(value);
15099         return 0;
15100 }
15101
15102 static PyGetSetDef py_srvsvc_NetTransportInfo2_getsetters[] = {
15103         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo2_get_vcs, py_srvsvc_NetTransportInfo2_set_vcs },
15104         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo2_get_name, py_srvsvc_NetTransportInfo2_set_name },
15105         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo2_get_addr, py_srvsvc_NetTransportInfo2_set_addr },
15106         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo2_get_addr_len, py_srvsvc_NetTransportInfo2_set_addr_len },
15107         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo2_get_net_addr, py_srvsvc_NetTransportInfo2_set_net_addr },
15108         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo2_get_domain, py_srvsvc_NetTransportInfo2_set_domain },
15109         { discard_const_p(char, "unknown"), py_srvsvc_NetTransportInfo2_get_unknown, py_srvsvc_NetTransportInfo2_set_unknown },
15110         { NULL }
15111 };
15112
15113 static PyObject *py_srvsvc_NetTransportInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15114 {
15115         return pytalloc_new(struct srvsvc_NetTransportInfo2, type);
15116 }
15117
15118
15119 static PyTypeObject srvsvc_NetTransportInfo2_Type = {
15120         PyObject_HEAD_INIT(NULL) 0,
15121         .tp_name = "srvsvc.NetTransportInfo2",
15122         .tp_getset = py_srvsvc_NetTransportInfo2_getsetters,
15123         .tp_methods = NULL,
15124         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15125         .tp_basicsize = sizeof(pytalloc_Object),
15126         .tp_new = py_srvsvc_NetTransportInfo2_new,
15127 };
15128
15129
15130 static PyObject *py_srvsvc_NetTransportCtr2_get_count(PyObject *obj, void *closure)
15131 {
15132         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
15133         PyObject *py_count;
15134         py_count = PyInt_FromLong(object->count);
15135         return py_count;
15136 }
15137
15138 static int py_srvsvc_NetTransportCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
15139 {
15140         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(py_obj);
15141         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15142         object->count = PyInt_AsLong(value);
15143         return 0;
15144 }
15145
15146 static PyObject *py_srvsvc_NetTransportCtr2_get_array(PyObject *obj, void *closure)
15147 {
15148         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
15149         PyObject *py_array;
15150         if (object->array == NULL) {
15151                 py_array = Py_None;
15152                 Py_INCREF(py_array);
15153         } else {
15154                 py_array = PyList_New(object->count);
15155                 if (py_array == NULL) {
15156                         return NULL;
15157                 }
15158                 {
15159                         int array_cntr_1;
15160                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
15161                                 PyObject *py_array_1;
15162                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, object->array, &object->array[array_cntr_1]);
15163                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
15164                         }
15165                 }
15166         }
15167         return py_array;
15168 }
15169
15170 static int py_srvsvc_NetTransportCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
15171 {
15172         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(py_obj);
15173         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
15174         if (value == Py_None) {
15175                 object->array = NULL;
15176         } else {
15177                 object->array = NULL;
15178                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15179                 {
15180                         int array_cntr_1;
15181                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
15182                         if (!object->array) { return -1;; }
15183                         talloc_set_name_const(object->array, "ARRAY: object->array");
15184                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
15185                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
15186                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
15187                                         PyErr_NoMemory();
15188                                         return -1;
15189                                 }
15190                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
15191                         }
15192                 }
15193         }
15194         return 0;
15195 }
15196
15197 static PyGetSetDef py_srvsvc_NetTransportCtr2_getsetters[] = {
15198         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr2_get_count, py_srvsvc_NetTransportCtr2_set_count },
15199         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr2_get_array, py_srvsvc_NetTransportCtr2_set_array },
15200         { NULL }
15201 };
15202
15203 static PyObject *py_srvsvc_NetTransportCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15204 {
15205         return pytalloc_new(struct srvsvc_NetTransportCtr2, type);
15206 }
15207
15208
15209 static PyTypeObject srvsvc_NetTransportCtr2_Type = {
15210         PyObject_HEAD_INIT(NULL) 0,
15211         .tp_name = "srvsvc.NetTransportCtr2",
15212         .tp_getset = py_srvsvc_NetTransportCtr2_getsetters,
15213         .tp_methods = NULL,
15214         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15215         .tp_basicsize = sizeof(pytalloc_Object),
15216         .tp_new = py_srvsvc_NetTransportCtr2_new,
15217 };
15218
15219
15220 static PyObject *py_srvsvc_NetTransportInfo3_get_vcs(PyObject *obj, void *closure)
15221 {
15222         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15223         PyObject *py_vcs;
15224         py_vcs = PyInt_FromLong(object->vcs);
15225         return py_vcs;
15226 }
15227
15228 static int py_srvsvc_NetTransportInfo3_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
15229 {
15230         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15231         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15232         object->vcs = PyInt_AsLong(value);
15233         return 0;
15234 }
15235
15236 static PyObject *py_srvsvc_NetTransportInfo3_get_name(PyObject *obj, void *closure)
15237 {
15238         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15239         PyObject *py_name;
15240         if (object->name == NULL) {
15241                 py_name = Py_None;
15242                 Py_INCREF(py_name);
15243         } else {
15244                 if (object->name == NULL) {
15245                         py_name = Py_None;
15246                         Py_INCREF(py_name);
15247                 } else {
15248                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
15249                 }
15250         }
15251         return py_name;
15252 }
15253
15254 static int py_srvsvc_NetTransportInfo3_set_name(PyObject *py_obj, PyObject *value, void *closure)
15255 {
15256         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15257         if (value == Py_None) {
15258                 object->name = NULL;
15259         } else {
15260                 object->name = NULL;
15261                 if (PyUnicode_Check(value)) {
15262                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15263                 } else if (PyString_Check(value)) {
15264                         object->name = PyString_AS_STRING(value);
15265                 } else {
15266                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15267                         return -1;
15268                 }
15269         }
15270         return 0;
15271 }
15272
15273 static PyObject *py_srvsvc_NetTransportInfo3_get_addr(PyObject *obj, void *closure)
15274 {
15275         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15276         PyObject *py_addr;
15277         if (object->addr == NULL) {
15278                 py_addr = Py_None;
15279                 Py_INCREF(py_addr);
15280         } else {
15281                 py_addr = PyList_New(object->addr_len);
15282                 if (py_addr == NULL) {
15283                         return NULL;
15284                 }
15285                 {
15286                         int addr_cntr_1;
15287                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
15288                                 PyObject *py_addr_1;
15289                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
15290                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
15291                         }
15292                 }
15293         }
15294         return py_addr;
15295 }
15296
15297 static int py_srvsvc_NetTransportInfo3_set_addr(PyObject *py_obj, PyObject *value, void *closure)
15298 {
15299         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15300         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
15301         if (value == Py_None) {
15302                 object->addr = NULL;
15303         } else {
15304                 object->addr = NULL;
15305                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15306                 {
15307                         int addr_cntr_1;
15308                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
15309                         if (!object->addr) { return -1;; }
15310                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
15311                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
15312                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
15313                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
15314                         }
15315                 }
15316         }
15317         return 0;
15318 }
15319
15320 static PyObject *py_srvsvc_NetTransportInfo3_get_addr_len(PyObject *obj, void *closure)
15321 {
15322         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15323         PyObject *py_addr_len;
15324         py_addr_len = PyInt_FromLong(object->addr_len);
15325         return py_addr_len;
15326 }
15327
15328 static int py_srvsvc_NetTransportInfo3_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
15329 {
15330         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15331         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15332         object->addr_len = PyInt_AsLong(value);
15333         return 0;
15334 }
15335
15336 static PyObject *py_srvsvc_NetTransportInfo3_get_net_addr(PyObject *obj, void *closure)
15337 {
15338         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15339         PyObject *py_net_addr;
15340         if (object->net_addr == NULL) {
15341                 py_net_addr = Py_None;
15342                 Py_INCREF(py_net_addr);
15343         } else {
15344                 if (object->net_addr == NULL) {
15345                         py_net_addr = Py_None;
15346                         Py_INCREF(py_net_addr);
15347                 } else {
15348                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
15349                 }
15350         }
15351         return py_net_addr;
15352 }
15353
15354 static int py_srvsvc_NetTransportInfo3_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
15355 {
15356         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15357         if (value == Py_None) {
15358                 object->net_addr = NULL;
15359         } else {
15360                 object->net_addr = NULL;
15361                 if (PyUnicode_Check(value)) {
15362                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15363                 } else if (PyString_Check(value)) {
15364                         object->net_addr = PyString_AS_STRING(value);
15365                 } else {
15366                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15367                         return -1;
15368                 }
15369         }
15370         return 0;
15371 }
15372
15373 static PyObject *py_srvsvc_NetTransportInfo3_get_domain(PyObject *obj, void *closure)
15374 {
15375         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15376         PyObject *py_domain;
15377         if (object->domain == NULL) {
15378                 py_domain = Py_None;
15379                 Py_INCREF(py_domain);
15380         } else {
15381                 if (object->domain == NULL) {
15382                         py_domain = Py_None;
15383                         Py_INCREF(py_domain);
15384                 } else {
15385                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
15386                 }
15387         }
15388         return py_domain;
15389 }
15390
15391 static int py_srvsvc_NetTransportInfo3_set_domain(PyObject *py_obj, PyObject *value, void *closure)
15392 {
15393         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15394         if (value == Py_None) {
15395                 object->domain = NULL;
15396         } else {
15397                 object->domain = NULL;
15398                 if (PyUnicode_Check(value)) {
15399                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15400                 } else if (PyString_Check(value)) {
15401                         object->domain = PyString_AS_STRING(value);
15402                 } else {
15403                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15404                         return -1;
15405                 }
15406         }
15407         return 0;
15408 }
15409
15410 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown1(PyObject *obj, void *closure)
15411 {
15412         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15413         PyObject *py_unknown1;
15414         py_unknown1 = PyInt_FromLong(object->unknown1);
15415         return py_unknown1;
15416 }
15417
15418 static int py_srvsvc_NetTransportInfo3_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
15419 {
15420         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15421         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15422         object->unknown1 = PyInt_AsLong(value);
15423         return 0;
15424 }
15425
15426 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown2(PyObject *obj, void *closure)
15427 {
15428         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15429         PyObject *py_unknown2;
15430         py_unknown2 = PyInt_FromLong(object->unknown2);
15431         return py_unknown2;
15432 }
15433
15434 static int py_srvsvc_NetTransportInfo3_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
15435 {
15436         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15437         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15438         object->unknown2 = PyInt_AsLong(value);
15439         return 0;
15440 }
15441
15442 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown3(PyObject *obj, void *closure)
15443 {
15444         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15445         PyObject *py_unknown3;
15446         py_unknown3 = PyList_New(256);
15447         if (py_unknown3 == NULL) {
15448                 return NULL;
15449         }
15450         {
15451                 int unknown3_cntr_0;
15452                 for (unknown3_cntr_0 = 0; unknown3_cntr_0 < 256; unknown3_cntr_0++) {
15453                         PyObject *py_unknown3_0;
15454                         py_unknown3_0 = PyInt_FromLong(object->unknown3[unknown3_cntr_0]);
15455                         PyList_SetItem(py_unknown3, unknown3_cntr_0, py_unknown3_0);
15456                 }
15457         }
15458         return py_unknown3;
15459 }
15460
15461 static int py_srvsvc_NetTransportInfo3_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
15462 {
15463         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15464         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15465         {
15466                 int unknown3_cntr_0;
15467                 for (unknown3_cntr_0 = 0; unknown3_cntr_0 < PyList_GET_SIZE(value); unknown3_cntr_0++) {
15468                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, unknown3_cntr_0), return -1;);
15469                         object->unknown3[unknown3_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, unknown3_cntr_0));
15470                 }
15471         }
15472         return 0;
15473 }
15474
15475 static PyGetSetDef py_srvsvc_NetTransportInfo3_getsetters[] = {
15476         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo3_get_vcs, py_srvsvc_NetTransportInfo3_set_vcs },
15477         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo3_get_name, py_srvsvc_NetTransportInfo3_set_name },
15478         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo3_get_addr, py_srvsvc_NetTransportInfo3_set_addr },
15479         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo3_get_addr_len, py_srvsvc_NetTransportInfo3_set_addr_len },
15480         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo3_get_net_addr, py_srvsvc_NetTransportInfo3_set_net_addr },
15481         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo3_get_domain, py_srvsvc_NetTransportInfo3_set_domain },
15482         { discard_const_p(char, "unknown1"), py_srvsvc_NetTransportInfo3_get_unknown1, py_srvsvc_NetTransportInfo3_set_unknown1 },
15483         { discard_const_p(char, "unknown2"), py_srvsvc_NetTransportInfo3_get_unknown2, py_srvsvc_NetTransportInfo3_set_unknown2 },
15484         { discard_const_p(char, "unknown3"), py_srvsvc_NetTransportInfo3_get_unknown3, py_srvsvc_NetTransportInfo3_set_unknown3 },
15485         { NULL }
15486 };
15487
15488 static PyObject *py_srvsvc_NetTransportInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15489 {
15490         return pytalloc_new(struct srvsvc_NetTransportInfo3, type);
15491 }
15492
15493
15494 static PyTypeObject srvsvc_NetTransportInfo3_Type = {
15495         PyObject_HEAD_INIT(NULL) 0,
15496         .tp_name = "srvsvc.NetTransportInfo3",
15497         .tp_getset = py_srvsvc_NetTransportInfo3_getsetters,
15498         .tp_methods = NULL,
15499         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15500         .tp_basicsize = sizeof(pytalloc_Object),
15501         .tp_new = py_srvsvc_NetTransportInfo3_new,
15502 };
15503
15504
15505 static PyObject *py_srvsvc_NetTransportCtr3_get_count(PyObject *obj, void *closure)
15506 {
15507         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
15508         PyObject *py_count;
15509         py_count = PyInt_FromLong(object->count);
15510         return py_count;
15511 }
15512
15513 static int py_srvsvc_NetTransportCtr3_set_count(PyObject *py_obj, PyObject *value, void *closure)
15514 {
15515         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(py_obj);
15516         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15517         object->count = PyInt_AsLong(value);
15518         return 0;
15519 }
15520
15521 static PyObject *py_srvsvc_NetTransportCtr3_get_array(PyObject *obj, void *closure)
15522 {
15523         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
15524         PyObject *py_array;
15525         if (object->array == NULL) {
15526                 py_array = Py_None;
15527                 Py_INCREF(py_array);
15528         } else {
15529                 py_array = PyList_New(object->count);
15530                 if (py_array == NULL) {
15531                         return NULL;
15532                 }
15533                 {
15534                         int array_cntr_1;
15535                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
15536                                 PyObject *py_array_1;
15537                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, object->array, &object->array[array_cntr_1]);
15538                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
15539                         }
15540                 }
15541         }
15542         return py_array;
15543 }
15544
15545 static int py_srvsvc_NetTransportCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
15546 {
15547         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(py_obj);
15548         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
15549         if (value == Py_None) {
15550                 object->array = NULL;
15551         } else {
15552                 object->array = NULL;
15553                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15554                 {
15555                         int array_cntr_1;
15556                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
15557                         if (!object->array) { return -1;; }
15558                         talloc_set_name_const(object->array, "ARRAY: object->array");
15559                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
15560                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
15561                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
15562                                         PyErr_NoMemory();
15563                                         return -1;
15564                                 }
15565                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
15566                         }
15567                 }
15568         }
15569         return 0;
15570 }
15571
15572 static PyGetSetDef py_srvsvc_NetTransportCtr3_getsetters[] = {
15573         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr3_get_count, py_srvsvc_NetTransportCtr3_set_count },
15574         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr3_get_array, py_srvsvc_NetTransportCtr3_set_array },
15575         { NULL }
15576 };
15577
15578 static PyObject *py_srvsvc_NetTransportCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15579 {
15580         return pytalloc_new(struct srvsvc_NetTransportCtr3, type);
15581 }
15582
15583
15584 static PyTypeObject srvsvc_NetTransportCtr3_Type = {
15585         PyObject_HEAD_INIT(NULL) 0,
15586         .tp_name = "srvsvc.NetTransportCtr3",
15587         .tp_getset = py_srvsvc_NetTransportCtr3_getsetters,
15588         .tp_methods = NULL,
15589         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15590         .tp_basicsize = sizeof(pytalloc_Object),
15591         .tp_new = py_srvsvc_NetTransportCtr3_new,
15592 };
15593
15594 static PyObject *py_import_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportCtr *in)
15595 {
15596         PyObject *ret;
15597
15598         switch (level) {
15599                 case 0:
15600                         if (in->ctr0 == NULL) {
15601                                 ret = Py_None;
15602                                 Py_INCREF(ret);
15603                         } else {
15604                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr0_Type, in->ctr0, in->ctr0);
15605                         }
15606                         return ret;
15607
15608                 case 1:
15609                         if (in->ctr1 == NULL) {
15610                                 ret = Py_None;
15611                                 Py_INCREF(ret);
15612                         } else {
15613                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr1_Type, in->ctr1, in->ctr1);
15614                         }
15615                         return ret;
15616
15617                 case 2:
15618                         if (in->ctr2 == NULL) {
15619                                 ret = Py_None;
15620                                 Py_INCREF(ret);
15621                         } else {
15622                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr2_Type, in->ctr2, in->ctr2);
15623                         }
15624                         return ret;
15625
15626                 case 3:
15627                         if (in->ctr3 == NULL) {
15628                                 ret = Py_None;
15629                                 Py_INCREF(ret);
15630                         } else {
15631                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr3_Type, in->ctr3, in->ctr3);
15632                         }
15633                         return ret;
15634
15635                 default:
15636                         ret = Py_None;
15637                         Py_INCREF(ret);
15638                         return ret;
15639
15640         }
15641         PyErr_SetString(PyExc_TypeError, "unknown union level");
15642         return NULL;
15643 }
15644
15645 static union srvsvc_NetTransportCtr *py_export_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
15646 {
15647         union srvsvc_NetTransportCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportCtr);
15648         switch (level) {
15649                 case 0:
15650                         if (in == Py_None) {
15651                                 ret->ctr0 = NULL;
15652                         } else {
15653                                 ret->ctr0 = NULL;
15654                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr0_Type, in, talloc_free(ret); return NULL;);
15655                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15656                                         PyErr_NoMemory();
15657                                         talloc_free(ret); return NULL;
15658                                 }
15659                                 ret->ctr0 = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(in);
15660                         }
15661                         break;
15662
15663                 case 1:
15664                         if (in == Py_None) {
15665                                 ret->ctr1 = NULL;
15666                         } else {
15667                                 ret->ctr1 = NULL;
15668                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr1_Type, in, talloc_free(ret); return NULL;);
15669                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15670                                         PyErr_NoMemory();
15671                                         talloc_free(ret); return NULL;
15672                                 }
15673                                 ret->ctr1 = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(in);
15674                         }
15675                         break;
15676
15677                 case 2:
15678                         if (in == Py_None) {
15679                                 ret->ctr2 = NULL;
15680                         } else {
15681                                 ret->ctr2 = NULL;
15682                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr2_Type, in, talloc_free(ret); return NULL;);
15683                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15684                                         PyErr_NoMemory();
15685                                         talloc_free(ret); return NULL;
15686                                 }
15687                                 ret->ctr2 = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(in);
15688                         }
15689                         break;
15690
15691                 case 3:
15692                         if (in == Py_None) {
15693                                 ret->ctr3 = NULL;
15694                         } else {
15695                                 ret->ctr3 = NULL;
15696                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr3_Type, in, talloc_free(ret); return NULL;);
15697                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15698                                         PyErr_NoMemory();
15699                                         talloc_free(ret); return NULL;
15700                                 }
15701                                 ret->ctr3 = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(in);
15702                         }
15703                         break;
15704
15705                 default:
15706                         break;
15707
15708         }
15709
15710         return ret;
15711 }
15712
15713
15714 static PyObject *py_srvsvc_NetTransportInfoCtr_get_level(PyObject *obj, void *closure)
15715 {
15716         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
15717         PyObject *py_level;
15718         py_level = PyInt_FromLong(object->level);
15719         return py_level;
15720 }
15721
15722 static int py_srvsvc_NetTransportInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
15723 {
15724         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_obj);
15725         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15726         object->level = PyInt_AsLong(value);
15727         return 0;
15728 }
15729
15730 static PyObject *py_srvsvc_NetTransportInfoCtr_get_ctr(PyObject *obj, void *closure)
15731 {
15732         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
15733         PyObject *py_ctr;
15734         py_ctr = py_import_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
15735         if (py_ctr == NULL) {
15736                 return NULL;
15737         }
15738         return py_ctr;
15739 }
15740
15741 static int py_srvsvc_NetTransportInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
15742 {
15743         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_obj);
15744         {
15745                 union srvsvc_NetTransportCtr *ctr_switch_0;
15746                 ctr_switch_0 = py_export_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
15747                 if (ctr_switch_0 == NULL) {
15748                         return -1;
15749                 }
15750                 object->ctr = *ctr_switch_0;
15751         }
15752         return 0;
15753 }
15754
15755 static PyGetSetDef py_srvsvc_NetTransportInfoCtr_getsetters[] = {
15756         { discard_const_p(char, "level"), py_srvsvc_NetTransportInfoCtr_get_level, py_srvsvc_NetTransportInfoCtr_set_level },
15757         { discard_const_p(char, "ctr"), py_srvsvc_NetTransportInfoCtr_get_ctr, py_srvsvc_NetTransportInfoCtr_set_ctr },
15758         { NULL }
15759 };
15760
15761 static PyObject *py_srvsvc_NetTransportInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15762 {
15763         return pytalloc_new(struct srvsvc_NetTransportInfoCtr, type);
15764 }
15765
15766
15767 static PyTypeObject srvsvc_NetTransportInfoCtr_Type = {
15768         PyObject_HEAD_INIT(NULL) 0,
15769         .tp_name = "srvsvc.NetTransportInfoCtr",
15770         .tp_getset = py_srvsvc_NetTransportInfoCtr_getsetters,
15771         .tp_methods = NULL,
15772         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15773         .tp_basicsize = sizeof(pytalloc_Object),
15774         .tp_new = py_srvsvc_NetTransportInfoCtr_new,
15775 };
15776
15777
15778 static PyObject *py_srvsvc_NetRemoteTODInfo_get_elapsed(PyObject *obj, void *closure)
15779 {
15780         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15781         PyObject *py_elapsed;
15782         py_elapsed = PyInt_FromLong(object->elapsed);
15783         return py_elapsed;
15784 }
15785
15786 static int py_srvsvc_NetRemoteTODInfo_set_elapsed(PyObject *py_obj, PyObject *value, void *closure)
15787 {
15788         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15789         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15790         object->elapsed = PyInt_AsLong(value);
15791         return 0;
15792 }
15793
15794 static PyObject *py_srvsvc_NetRemoteTODInfo_get_msecs(PyObject *obj, void *closure)
15795 {
15796         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15797         PyObject *py_msecs;
15798         py_msecs = PyInt_FromLong(object->msecs);
15799         return py_msecs;
15800 }
15801
15802 static int py_srvsvc_NetRemoteTODInfo_set_msecs(PyObject *py_obj, PyObject *value, void *closure)
15803 {
15804         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15805         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15806         object->msecs = PyInt_AsLong(value);
15807         return 0;
15808 }
15809
15810 static PyObject *py_srvsvc_NetRemoteTODInfo_get_hours(PyObject *obj, void *closure)
15811 {
15812         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15813         PyObject *py_hours;
15814         py_hours = PyInt_FromLong(object->hours);
15815         return py_hours;
15816 }
15817
15818 static int py_srvsvc_NetRemoteTODInfo_set_hours(PyObject *py_obj, PyObject *value, void *closure)
15819 {
15820         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15821         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15822         object->hours = PyInt_AsLong(value);
15823         return 0;
15824 }
15825
15826 static PyObject *py_srvsvc_NetRemoteTODInfo_get_mins(PyObject *obj, void *closure)
15827 {
15828         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15829         PyObject *py_mins;
15830         py_mins = PyInt_FromLong(object->mins);
15831         return py_mins;
15832 }
15833
15834 static int py_srvsvc_NetRemoteTODInfo_set_mins(PyObject *py_obj, PyObject *value, void *closure)
15835 {
15836         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15837         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15838         object->mins = PyInt_AsLong(value);
15839         return 0;
15840 }
15841
15842 static PyObject *py_srvsvc_NetRemoteTODInfo_get_secs(PyObject *obj, void *closure)
15843 {
15844         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15845         PyObject *py_secs;
15846         py_secs = PyInt_FromLong(object->secs);
15847         return py_secs;
15848 }
15849
15850 static int py_srvsvc_NetRemoteTODInfo_set_secs(PyObject *py_obj, PyObject *value, void *closure)
15851 {
15852         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15853         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15854         object->secs = PyInt_AsLong(value);
15855         return 0;
15856 }
15857
15858 static PyObject *py_srvsvc_NetRemoteTODInfo_get_hunds(PyObject *obj, void *closure)
15859 {
15860         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15861         PyObject *py_hunds;
15862         py_hunds = PyInt_FromLong(object->hunds);
15863         return py_hunds;
15864 }
15865
15866 static int py_srvsvc_NetRemoteTODInfo_set_hunds(PyObject *py_obj, PyObject *value, void *closure)
15867 {
15868         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15869         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15870         object->hunds = PyInt_AsLong(value);
15871         return 0;
15872 }
15873
15874 static PyObject *py_srvsvc_NetRemoteTODInfo_get_timezone(PyObject *obj, void *closure)
15875 {
15876         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15877         PyObject *py_timezone;
15878         py_timezone = PyInt_FromLong(object->timezone);
15879         return py_timezone;
15880 }
15881
15882 static int py_srvsvc_NetRemoteTODInfo_set_timezone(PyObject *py_obj, PyObject *value, void *closure)
15883 {
15884         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15885         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15886         object->timezone = PyInt_AsLong(value);
15887         return 0;
15888 }
15889
15890 static PyObject *py_srvsvc_NetRemoteTODInfo_get_tinterval(PyObject *obj, void *closure)
15891 {
15892         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15893         PyObject *py_tinterval;
15894         py_tinterval = PyInt_FromLong(object->tinterval);
15895         return py_tinterval;
15896 }
15897
15898 static int py_srvsvc_NetRemoteTODInfo_set_tinterval(PyObject *py_obj, PyObject *value, void *closure)
15899 {
15900         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15901         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15902         object->tinterval = PyInt_AsLong(value);
15903         return 0;
15904 }
15905
15906 static PyObject *py_srvsvc_NetRemoteTODInfo_get_day(PyObject *obj, void *closure)
15907 {
15908         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15909         PyObject *py_day;
15910         py_day = PyInt_FromLong(object->day);
15911         return py_day;
15912 }
15913
15914 static int py_srvsvc_NetRemoteTODInfo_set_day(PyObject *py_obj, PyObject *value, void *closure)
15915 {
15916         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15917         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15918         object->day = PyInt_AsLong(value);
15919         return 0;
15920 }
15921
15922 static PyObject *py_srvsvc_NetRemoteTODInfo_get_month(PyObject *obj, void *closure)
15923 {
15924         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15925         PyObject *py_month;
15926         py_month = PyInt_FromLong(object->month);
15927         return py_month;
15928 }
15929
15930 static int py_srvsvc_NetRemoteTODInfo_set_month(PyObject *py_obj, PyObject *value, void *closure)
15931 {
15932         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15933         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15934         object->month = PyInt_AsLong(value);
15935         return 0;
15936 }
15937
15938 static PyObject *py_srvsvc_NetRemoteTODInfo_get_year(PyObject *obj, void *closure)
15939 {
15940         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15941         PyObject *py_year;
15942         py_year = PyInt_FromLong(object->year);
15943         return py_year;
15944 }
15945
15946 static int py_srvsvc_NetRemoteTODInfo_set_year(PyObject *py_obj, PyObject *value, void *closure)
15947 {
15948         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15949         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15950         object->year = PyInt_AsLong(value);
15951         return 0;
15952 }
15953
15954 static PyObject *py_srvsvc_NetRemoteTODInfo_get_weekday(PyObject *obj, void *closure)
15955 {
15956         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15957         PyObject *py_weekday;
15958         py_weekday = PyInt_FromLong(object->weekday);
15959         return py_weekday;
15960 }
15961
15962 static int py_srvsvc_NetRemoteTODInfo_set_weekday(PyObject *py_obj, PyObject *value, void *closure)
15963 {
15964         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15965         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15966         object->weekday = PyInt_AsLong(value);
15967         return 0;
15968 }
15969
15970 static PyGetSetDef py_srvsvc_NetRemoteTODInfo_getsetters[] = {
15971         { discard_const_p(char, "elapsed"), py_srvsvc_NetRemoteTODInfo_get_elapsed, py_srvsvc_NetRemoteTODInfo_set_elapsed },
15972         { discard_const_p(char, "msecs"), py_srvsvc_NetRemoteTODInfo_get_msecs, py_srvsvc_NetRemoteTODInfo_set_msecs },
15973         { discard_const_p(char, "hours"), py_srvsvc_NetRemoteTODInfo_get_hours, py_srvsvc_NetRemoteTODInfo_set_hours },
15974         { discard_const_p(char, "mins"), py_srvsvc_NetRemoteTODInfo_get_mins, py_srvsvc_NetRemoteTODInfo_set_mins },
15975         { discard_const_p(char, "secs"), py_srvsvc_NetRemoteTODInfo_get_secs, py_srvsvc_NetRemoteTODInfo_set_secs },
15976         { discard_const_p(char, "hunds"), py_srvsvc_NetRemoteTODInfo_get_hunds, py_srvsvc_NetRemoteTODInfo_set_hunds },
15977         { discard_const_p(char, "timezone"), py_srvsvc_NetRemoteTODInfo_get_timezone, py_srvsvc_NetRemoteTODInfo_set_timezone },
15978         { discard_const_p(char, "tinterval"), py_srvsvc_NetRemoteTODInfo_get_tinterval, py_srvsvc_NetRemoteTODInfo_set_tinterval },
15979         { discard_const_p(char, "day"), py_srvsvc_NetRemoteTODInfo_get_day, py_srvsvc_NetRemoteTODInfo_set_day },
15980         { discard_const_p(char, "month"), py_srvsvc_NetRemoteTODInfo_get_month, py_srvsvc_NetRemoteTODInfo_set_month },
15981         { discard_const_p(char, "year"), py_srvsvc_NetRemoteTODInfo_get_year, py_srvsvc_NetRemoteTODInfo_set_year },
15982         { discard_const_p(char, "weekday"), py_srvsvc_NetRemoteTODInfo_get_weekday, py_srvsvc_NetRemoteTODInfo_set_weekday },
15983         { NULL }
15984 };
15985
15986 static PyObject *py_srvsvc_NetRemoteTODInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15987 {
15988         return pytalloc_new(struct srvsvc_NetRemoteTODInfo, type);
15989 }
15990
15991
15992 static PyTypeObject srvsvc_NetRemoteTODInfo_Type = {
15993         PyObject_HEAD_INIT(NULL) 0,
15994         .tp_name = "srvsvc.NetRemoteTODInfo",
15995         .tp_getset = py_srvsvc_NetRemoteTODInfo_getsetters,
15996         .tp_methods = NULL,
15997         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15998         .tp_basicsize = sizeof(pytalloc_Object),
15999         .tp_new = py_srvsvc_NetRemoteTODInfo_new,
16000 };
16001
16002 static PyObject *py_import_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportInfo *in)
16003 {
16004         PyObject *ret;
16005
16006         switch (level) {
16007                 case 0:
16008                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, mem_ctx, &in->info0);
16009                         return ret;
16010
16011                 case 1:
16012                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, mem_ctx, &in->info1);
16013                         return ret;
16014
16015                 case 2:
16016                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, mem_ctx, &in->info2);
16017                         return ret;
16018
16019                 case 3:
16020                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, mem_ctx, &in->info3);
16021                         return ret;
16022
16023         }
16024         PyErr_SetString(PyExc_TypeError, "unknown union level");
16025         return NULL;
16026 }
16027
16028 static union srvsvc_NetTransportInfo *py_export_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
16029 {
16030         union srvsvc_NetTransportInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportInfo);
16031         switch (level) {
16032                 case 0:
16033                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, in, talloc_free(ret); return NULL;);
16034                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16035                                 PyErr_NoMemory();
16036                                 talloc_free(ret); return NULL;
16037                         }
16038                         ret->info0 = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(in);
16039                         break;
16040
16041                 case 1:
16042                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, in, talloc_free(ret); return NULL;);
16043                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16044                                 PyErr_NoMemory();
16045                                 talloc_free(ret); return NULL;
16046                         }
16047                         ret->info1 = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(in);
16048                         break;
16049
16050                 case 2:
16051                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, in, talloc_free(ret); return NULL;);
16052                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16053                                 PyErr_NoMemory();
16054                                 talloc_free(ret); return NULL;
16055                         }
16056                         ret->info2 = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(in);
16057                         break;
16058
16059                 case 3:
16060                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, in, talloc_free(ret); return NULL;);
16061                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16062                                 PyErr_NoMemory();
16063                                 talloc_free(ret); return NULL;
16064                         }
16065                         ret->info3 = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(in);
16066                         break;
16067
16068                 default:
16069                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
16070                         talloc_free(ret);
16071                         ret = NULL;
16072         }
16073
16074         return ret;
16075 }
16076
16077
16078 static bool pack_py_srvsvc_NetCharDevEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevEnum *r)
16079 {
16080         PyObject *py_server_unc;
16081         PyObject *py_info_ctr;
16082         PyObject *py_max_buffer;
16083         PyObject *py_resume_handle;
16084         const char *kwnames[] = {
16085                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
16086         };
16087
16088         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetCharDevEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
16089                 return false;
16090         }
16091
16092         if (py_server_unc == Py_None) {
16093                 r->in.server_unc = NULL;
16094         } else {
16095                 r->in.server_unc = NULL;
16096                 if (PyUnicode_Check(py_server_unc)) {
16097                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16098                 } else if (PyString_Check(py_server_unc)) {
16099                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16100                 } else {
16101                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16102                         return false;
16103                 }
16104         }
16105         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16106         PY_CHECK_TYPE(&srvsvc_NetCharDevInfoCtr_Type, py_info_ctr, return false;);
16107         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16108                 PyErr_NoMemory();
16109                 return false;
16110         }
16111         r->in.info_ctr = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16112         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16113         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16114         if (py_resume_handle == Py_None) {
16115                 r->in.resume_handle = NULL;
16116         } else {
16117                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16118                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16119                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16120         }
16121         return true;
16122 }
16123
16124 static PyObject *unpack_py_srvsvc_NetCharDevEnum_args_out(struct srvsvc_NetCharDevEnum *r)
16125 {
16126         PyObject *result;
16127         PyObject *py_info_ctr;
16128         PyObject *py_totalentries;
16129         PyObject *py_resume_handle;
16130         result = PyTuple_New(3);
16131         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16132         PyTuple_SetItem(result, 0, py_info_ctr);
16133         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16134         PyTuple_SetItem(result, 1, py_totalentries);
16135         if (r->out.resume_handle == NULL) {
16136                 py_resume_handle = Py_None;
16137                 Py_INCREF(py_resume_handle);
16138         } else {
16139                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16140         }
16141         PyTuple_SetItem(result, 2, py_resume_handle);
16142         if (!W_ERROR_IS_OK(r->out.result)) {
16143                 PyErr_SetWERROR(r->out.result);
16144                 return NULL;
16145         }
16146
16147         return result;
16148 }
16149
16150 static bool pack_py_srvsvc_NetCharDevGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevGetInfo *r)
16151 {
16152         PyObject *py_server_unc;
16153         PyObject *py_device_name;
16154         PyObject *py_level;
16155         const char *kwnames[] = {
16156                 "server_unc", "device_name", "level", NULL
16157         };
16158
16159         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_level)) {
16160                 return false;
16161         }
16162
16163         if (py_server_unc == Py_None) {
16164                 r->in.server_unc = NULL;
16165         } else {
16166                 r->in.server_unc = NULL;
16167                 if (PyUnicode_Check(py_server_unc)) {
16168                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16169                 } else if (PyString_Check(py_server_unc)) {
16170                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16171                 } else {
16172                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16173                         return false;
16174                 }
16175         }
16176         if (PyUnicode_Check(py_device_name)) {
16177                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
16178         } else if (PyString_Check(py_device_name)) {
16179                 r->in.device_name = PyString_AS_STRING(py_device_name);
16180         } else {
16181                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
16182                 return false;
16183         }
16184         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16185         r->in.level = PyInt_AsLong(py_level);
16186         return true;
16187 }
16188
16189 static PyObject *unpack_py_srvsvc_NetCharDevGetInfo_args_out(struct srvsvc_NetCharDevGetInfo *r)
16190 {
16191         PyObject *result;
16192         PyObject *py_info;
16193         py_info = py_import_srvsvc_NetCharDevInfo(r->out.info, r->in.level, r->out.info);
16194         if (py_info == NULL) {
16195                 return NULL;
16196         }
16197         result = py_info;
16198         if (!W_ERROR_IS_OK(r->out.result)) {
16199                 PyErr_SetWERROR(r->out.result);
16200                 return NULL;
16201         }
16202
16203         return result;
16204 }
16205
16206 static bool pack_py_srvsvc_NetCharDevControl_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevControl *r)
16207 {
16208         PyObject *py_server_unc;
16209         PyObject *py_device_name;
16210         PyObject *py_opcode;
16211         const char *kwnames[] = {
16212                 "server_unc", "device_name", "opcode", NULL
16213         };
16214
16215         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevControl", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_opcode)) {
16216                 return false;
16217         }
16218
16219         if (py_server_unc == Py_None) {
16220                 r->in.server_unc = NULL;
16221         } else {
16222                 r->in.server_unc = NULL;
16223                 if (PyUnicode_Check(py_server_unc)) {
16224                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16225                 } else if (PyString_Check(py_server_unc)) {
16226                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16227                 } else {
16228                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16229                         return false;
16230                 }
16231         }
16232         if (PyUnicode_Check(py_device_name)) {
16233                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
16234         } else if (PyString_Check(py_device_name)) {
16235                 r->in.device_name = PyString_AS_STRING(py_device_name);
16236         } else {
16237                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
16238                 return false;
16239         }
16240         PY_CHECK_TYPE(&PyInt_Type, py_opcode, return false;);
16241         r->in.opcode = PyInt_AsLong(py_opcode);
16242         return true;
16243 }
16244
16245 static PyObject *unpack_py_srvsvc_NetCharDevControl_args_out(struct srvsvc_NetCharDevControl *r)
16246 {
16247         PyObject *result;
16248         result = Py_None;
16249         Py_INCREF(result);
16250         if (!W_ERROR_IS_OK(r->out.result)) {
16251                 PyErr_SetWERROR(r->out.result);
16252                 return NULL;
16253         }
16254
16255         return result;
16256 }
16257
16258 static bool pack_py_srvsvc_NetCharDevQEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQEnum *r)
16259 {
16260         PyObject *py_server_unc;
16261         PyObject *py_user;
16262         PyObject *py_info_ctr;
16263         PyObject *py_max_buffer;
16264         PyObject *py_resume_handle;
16265         const char *kwnames[] = {
16266                 "server_unc", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16267         };
16268
16269         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetCharDevQEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
16270                 return false;
16271         }
16272
16273         if (py_server_unc == Py_None) {
16274                 r->in.server_unc = NULL;
16275         } else {
16276                 r->in.server_unc = NULL;
16277                 if (PyUnicode_Check(py_server_unc)) {
16278                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16279                 } else if (PyString_Check(py_server_unc)) {
16280                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16281                 } else {
16282                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16283                         return false;
16284                 }
16285         }
16286         if (py_user == Py_None) {
16287                 r->in.user = NULL;
16288         } else {
16289                 r->in.user = NULL;
16290                 if (PyUnicode_Check(py_user)) {
16291                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16292                 } else if (PyString_Check(py_user)) {
16293                         r->in.user = PyString_AS_STRING(py_user);
16294                 } else {
16295                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16296                         return false;
16297                 }
16298         }
16299         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16300         PY_CHECK_TYPE(&srvsvc_NetCharDevQInfoCtr_Type, py_info_ctr, return false;);
16301         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16302                 PyErr_NoMemory();
16303                 return false;
16304         }
16305         r->in.info_ctr = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16306         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16307         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16308         if (py_resume_handle == Py_None) {
16309                 r->in.resume_handle = NULL;
16310         } else {
16311                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16312                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16313                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16314         }
16315         return true;
16316 }
16317
16318 static PyObject *unpack_py_srvsvc_NetCharDevQEnum_args_out(struct srvsvc_NetCharDevQEnum *r)
16319 {
16320         PyObject *result;
16321         PyObject *py_info_ctr;
16322         PyObject *py_totalentries;
16323         PyObject *py_resume_handle;
16324         result = PyTuple_New(3);
16325         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevQInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16326         PyTuple_SetItem(result, 0, py_info_ctr);
16327         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16328         PyTuple_SetItem(result, 1, py_totalentries);
16329         if (r->out.resume_handle == NULL) {
16330                 py_resume_handle = Py_None;
16331                 Py_INCREF(py_resume_handle);
16332         } else {
16333                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16334         }
16335         PyTuple_SetItem(result, 2, py_resume_handle);
16336         if (!W_ERROR_IS_OK(r->out.result)) {
16337                 PyErr_SetWERROR(r->out.result);
16338                 return NULL;
16339         }
16340
16341         return result;
16342 }
16343
16344 static bool pack_py_srvsvc_NetCharDevQGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQGetInfo *r)
16345 {
16346         PyObject *py_server_unc;
16347         PyObject *py_queue_name;
16348         PyObject *py_user;
16349         PyObject *py_level;
16350         const char *kwnames[] = {
16351                 "server_unc", "queue_name", "user", "level", NULL
16352         };
16353
16354         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetCharDevQGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_user, &py_level)) {
16355                 return false;
16356         }
16357
16358         if (py_server_unc == Py_None) {
16359                 r->in.server_unc = NULL;
16360         } else {
16361                 r->in.server_unc = NULL;
16362                 if (PyUnicode_Check(py_server_unc)) {
16363                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16364                 } else if (PyString_Check(py_server_unc)) {
16365                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16366                 } else {
16367                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16368                         return false;
16369                 }
16370         }
16371         if (PyUnicode_Check(py_queue_name)) {
16372                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16373         } else if (PyString_Check(py_queue_name)) {
16374                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16375         } else {
16376                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16377                 return false;
16378         }
16379         if (PyUnicode_Check(py_user)) {
16380                 r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16381         } else if (PyString_Check(py_user)) {
16382                 r->in.user = PyString_AS_STRING(py_user);
16383         } else {
16384                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16385                 return false;
16386         }
16387         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16388         r->in.level = PyInt_AsLong(py_level);
16389         return true;
16390 }
16391
16392 static PyObject *unpack_py_srvsvc_NetCharDevQGetInfo_args_out(struct srvsvc_NetCharDevQGetInfo *r)
16393 {
16394         PyObject *result;
16395         PyObject *py_info;
16396         py_info = py_import_srvsvc_NetCharDevQInfo(r->out.info, r->in.level, r->out.info);
16397         if (py_info == NULL) {
16398                 return NULL;
16399         }
16400         result = py_info;
16401         if (!W_ERROR_IS_OK(r->out.result)) {
16402                 PyErr_SetWERROR(r->out.result);
16403                 return NULL;
16404         }
16405
16406         return result;
16407 }
16408
16409 static bool pack_py_srvsvc_NetCharDevQSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQSetInfo *r)
16410 {
16411         PyObject *py_server_unc;
16412         PyObject *py_queue_name;
16413         PyObject *py_level;
16414         PyObject *py_info;
16415         PyObject *py_parm_error;
16416         const char *kwnames[] = {
16417                 "server_unc", "queue_name", "level", "info", "parm_error", NULL
16418         };
16419
16420         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetCharDevQSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_level, &py_info, &py_parm_error)) {
16421                 return false;
16422         }
16423
16424         if (py_server_unc == Py_None) {
16425                 r->in.server_unc = NULL;
16426         } else {
16427                 r->in.server_unc = NULL;
16428                 if (PyUnicode_Check(py_server_unc)) {
16429                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16430                 } else if (PyString_Check(py_server_unc)) {
16431                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16432                 } else {
16433                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16434                         return false;
16435                 }
16436         }
16437         if (PyUnicode_Check(py_queue_name)) {
16438                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16439         } else if (PyString_Check(py_queue_name)) {
16440                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16441         } else {
16442                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16443                 return false;
16444         }
16445         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16446         r->in.level = PyInt_AsLong(py_level);
16447         {
16448                 union srvsvc_NetCharDevQInfo *info_switch_0;
16449                 info_switch_0 = py_export_srvsvc_NetCharDevQInfo(r, r->in.level, py_info);
16450                 if (info_switch_0 == NULL) {
16451                         return false;
16452                 }
16453                 r->in.info = *info_switch_0;
16454         }
16455         if (py_parm_error == Py_None) {
16456                 r->in.parm_error = NULL;
16457         } else {
16458                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
16459                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
16460                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
16461         }
16462         return true;
16463 }
16464
16465 static PyObject *unpack_py_srvsvc_NetCharDevQSetInfo_args_out(struct srvsvc_NetCharDevQSetInfo *r)
16466 {
16467         PyObject *result;
16468         PyObject *py_parm_error;
16469         if (r->out.parm_error == NULL) {
16470                 py_parm_error = Py_None;
16471                 Py_INCREF(py_parm_error);
16472         } else {
16473                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
16474         }
16475         result = py_parm_error;
16476         if (!W_ERROR_IS_OK(r->out.result)) {
16477                 PyErr_SetWERROR(r->out.result);
16478                 return NULL;
16479         }
16480
16481         return result;
16482 }
16483
16484 static bool pack_py_srvsvc_NetCharDevQPurge_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurge *r)
16485 {
16486         PyObject *py_server_unc;
16487         PyObject *py_queue_name;
16488         const char *kwnames[] = {
16489                 "server_unc", "queue_name", NULL
16490         };
16491
16492         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetCharDevQPurge", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name)) {
16493                 return false;
16494         }
16495
16496         if (py_server_unc == Py_None) {
16497                 r->in.server_unc = NULL;
16498         } else {
16499                 r->in.server_unc = NULL;
16500                 if (PyUnicode_Check(py_server_unc)) {
16501                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16502                 } else if (PyString_Check(py_server_unc)) {
16503                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16504                 } else {
16505                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16506                         return false;
16507                 }
16508         }
16509         if (PyUnicode_Check(py_queue_name)) {
16510                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16511         } else if (PyString_Check(py_queue_name)) {
16512                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16513         } else {
16514                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16515                 return false;
16516         }
16517         return true;
16518 }
16519
16520 static PyObject *unpack_py_srvsvc_NetCharDevQPurge_args_out(struct srvsvc_NetCharDevQPurge *r)
16521 {
16522         PyObject *result;
16523         result = Py_None;
16524         Py_INCREF(result);
16525         if (!W_ERROR_IS_OK(r->out.result)) {
16526                 PyErr_SetWERROR(r->out.result);
16527                 return NULL;
16528         }
16529
16530         return result;
16531 }
16532
16533 static bool pack_py_srvsvc_NetCharDevQPurgeSelf_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurgeSelf *r)
16534 {
16535         PyObject *py_server_unc;
16536         PyObject *py_queue_name;
16537         PyObject *py_computer_name;
16538         const char *kwnames[] = {
16539                 "server_unc", "queue_name", "computer_name", NULL
16540         };
16541
16542         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevQPurgeSelf", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_computer_name)) {
16543                 return false;
16544         }
16545
16546         if (py_server_unc == Py_None) {
16547                 r->in.server_unc = NULL;
16548         } else {
16549                 r->in.server_unc = NULL;
16550                 if (PyUnicode_Check(py_server_unc)) {
16551                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16552                 } else if (PyString_Check(py_server_unc)) {
16553                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16554                 } else {
16555                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16556                         return false;
16557                 }
16558         }
16559         if (PyUnicode_Check(py_queue_name)) {
16560                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16561         } else if (PyString_Check(py_queue_name)) {
16562                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16563         } else {
16564                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16565                 return false;
16566         }
16567         if (PyUnicode_Check(py_computer_name)) {
16568                 r->in.computer_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_computer_name, "utf-8", "ignore"));
16569         } else if (PyString_Check(py_computer_name)) {
16570                 r->in.computer_name = PyString_AS_STRING(py_computer_name);
16571         } else {
16572                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_computer_name)->tp_name);
16573                 return false;
16574         }
16575         return true;
16576 }
16577
16578 static PyObject *unpack_py_srvsvc_NetCharDevQPurgeSelf_args_out(struct srvsvc_NetCharDevQPurgeSelf *r)
16579 {
16580         PyObject *result;
16581         result = Py_None;
16582         Py_INCREF(result);
16583         if (!W_ERROR_IS_OK(r->out.result)) {
16584                 PyErr_SetWERROR(r->out.result);
16585                 return NULL;
16586         }
16587
16588         return result;
16589 }
16590
16591 static bool pack_py_srvsvc_NetConnEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetConnEnum *r)
16592 {
16593         PyObject *py_server_unc;
16594         PyObject *py_path;
16595         PyObject *py_info_ctr;
16596         PyObject *py_max_buffer;
16597         PyObject *py_resume_handle;
16598         const char *kwnames[] = {
16599                 "server_unc", "path", "info_ctr", "max_buffer", "resume_handle", NULL
16600         };
16601
16602         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetConnEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
16603                 return false;
16604         }
16605
16606         if (py_server_unc == Py_None) {
16607                 r->in.server_unc = NULL;
16608         } else {
16609                 r->in.server_unc = NULL;
16610                 if (PyUnicode_Check(py_server_unc)) {
16611                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16612                 } else if (PyString_Check(py_server_unc)) {
16613                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16614                 } else {
16615                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16616                         return false;
16617                 }
16618         }
16619         if (py_path == Py_None) {
16620                 r->in.path = NULL;
16621         } else {
16622                 r->in.path = NULL;
16623                 if (PyUnicode_Check(py_path)) {
16624                         r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
16625                 } else if (PyString_Check(py_path)) {
16626                         r->in.path = PyString_AS_STRING(py_path);
16627                 } else {
16628                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
16629                         return false;
16630                 }
16631         }
16632         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16633         PY_CHECK_TYPE(&srvsvc_NetConnInfoCtr_Type, py_info_ctr, return false;);
16634         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16635                 PyErr_NoMemory();
16636                 return false;
16637         }
16638         r->in.info_ctr = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16639         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16640         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16641         if (py_resume_handle == Py_None) {
16642                 r->in.resume_handle = NULL;
16643         } else {
16644                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16645                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16646                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16647         }
16648         return true;
16649 }
16650
16651 static PyObject *unpack_py_srvsvc_NetConnEnum_args_out(struct srvsvc_NetConnEnum *r)
16652 {
16653         PyObject *result;
16654         PyObject *py_info_ctr;
16655         PyObject *py_totalentries;
16656         PyObject *py_resume_handle;
16657         result = PyTuple_New(3);
16658         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetConnInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16659         PyTuple_SetItem(result, 0, py_info_ctr);
16660         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16661         PyTuple_SetItem(result, 1, py_totalentries);
16662         if (r->out.resume_handle == NULL) {
16663                 py_resume_handle = Py_None;
16664                 Py_INCREF(py_resume_handle);
16665         } else {
16666                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16667         }
16668         PyTuple_SetItem(result, 2, py_resume_handle);
16669         if (!W_ERROR_IS_OK(r->out.result)) {
16670                 PyErr_SetWERROR(r->out.result);
16671                 return NULL;
16672         }
16673
16674         return result;
16675 }
16676
16677 static bool pack_py_srvsvc_NetFileEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileEnum *r)
16678 {
16679         PyObject *py_server_unc;
16680         PyObject *py_path;
16681         PyObject *py_user;
16682         PyObject *py_info_ctr;
16683         PyObject *py_max_buffer;
16684         PyObject *py_resume_handle;
16685         const char *kwnames[] = {
16686                 "server_unc", "path", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16687         };
16688
16689         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetFileEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
16690                 return false;
16691         }
16692
16693         if (py_server_unc == Py_None) {
16694                 r->in.server_unc = NULL;
16695         } else {
16696                 r->in.server_unc = NULL;
16697                 if (PyUnicode_Check(py_server_unc)) {
16698                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16699                 } else if (PyString_Check(py_server_unc)) {
16700                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16701                 } else {
16702                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16703                         return false;
16704                 }
16705         }
16706         if (py_path == Py_None) {
16707                 r->in.path = NULL;
16708         } else {
16709                 r->in.path = NULL;
16710                 if (PyUnicode_Check(py_path)) {
16711                         r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
16712                 } else if (PyString_Check(py_path)) {
16713                         r->in.path = PyString_AS_STRING(py_path);
16714                 } else {
16715                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
16716                         return false;
16717                 }
16718         }
16719         if (py_user == Py_None) {
16720                 r->in.user = NULL;
16721         } else {
16722                 r->in.user = NULL;
16723                 if (PyUnicode_Check(py_user)) {
16724                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16725                 } else if (PyString_Check(py_user)) {
16726                         r->in.user = PyString_AS_STRING(py_user);
16727                 } else {
16728                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16729                         return false;
16730                 }
16731         }
16732         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16733         PY_CHECK_TYPE(&srvsvc_NetFileInfoCtr_Type, py_info_ctr, return false;);
16734         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16735                 PyErr_NoMemory();
16736                 return false;
16737         }
16738         r->in.info_ctr = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16739         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16740         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16741         if (py_resume_handle == Py_None) {
16742                 r->in.resume_handle = NULL;
16743         } else {
16744                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16745                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16746                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16747         }
16748         return true;
16749 }
16750
16751 static PyObject *unpack_py_srvsvc_NetFileEnum_args_out(struct srvsvc_NetFileEnum *r)
16752 {
16753         PyObject *result;
16754         PyObject *py_info_ctr;
16755         PyObject *py_totalentries;
16756         PyObject *py_resume_handle;
16757         result = PyTuple_New(3);
16758         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetFileInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16759         PyTuple_SetItem(result, 0, py_info_ctr);
16760         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16761         PyTuple_SetItem(result, 1, py_totalentries);
16762         if (r->out.resume_handle == NULL) {
16763                 py_resume_handle = Py_None;
16764                 Py_INCREF(py_resume_handle);
16765         } else {
16766                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16767         }
16768         PyTuple_SetItem(result, 2, py_resume_handle);
16769         if (!W_ERROR_IS_OK(r->out.result)) {
16770                 PyErr_SetWERROR(r->out.result);
16771                 return NULL;
16772         }
16773
16774         return result;
16775 }
16776
16777 static bool pack_py_srvsvc_NetFileGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileGetInfo *r)
16778 {
16779         PyObject *py_server_unc;
16780         PyObject *py_fid;
16781         PyObject *py_level;
16782         const char *kwnames[] = {
16783                 "server_unc", "fid", "level", NULL
16784         };
16785
16786         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetFileGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_fid, &py_level)) {
16787                 return false;
16788         }
16789
16790         if (py_server_unc == Py_None) {
16791                 r->in.server_unc = NULL;
16792         } else {
16793                 r->in.server_unc = NULL;
16794                 if (PyUnicode_Check(py_server_unc)) {
16795                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16796                 } else if (PyString_Check(py_server_unc)) {
16797                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16798                 } else {
16799                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16800                         return false;
16801                 }
16802         }
16803         PY_CHECK_TYPE(&PyInt_Type, py_fid, return false;);
16804         r->in.fid = PyInt_AsLong(py_fid);
16805         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16806         r->in.level = PyInt_AsLong(py_level);
16807         return true;
16808 }
16809
16810 static PyObject *unpack_py_srvsvc_NetFileGetInfo_args_out(struct srvsvc_NetFileGetInfo *r)
16811 {
16812         PyObject *result;
16813         PyObject *py_info;
16814         py_info = py_import_srvsvc_NetFileInfo(r->out.info, r->in.level, r->out.info);
16815         if (py_info == NULL) {
16816                 return NULL;
16817         }
16818         result = py_info;
16819         if (!W_ERROR_IS_OK(r->out.result)) {
16820                 PyErr_SetWERROR(r->out.result);
16821                 return NULL;
16822         }
16823
16824         return result;
16825 }
16826
16827 static bool pack_py_srvsvc_NetFileClose_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileClose *r)
16828 {
16829         PyObject *py_server_unc;
16830         PyObject *py_fid;
16831         const char *kwnames[] = {
16832                 "server_unc", "fid", NULL
16833         };
16834
16835         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetFileClose", discard_const_p(char *, kwnames), &py_server_unc, &py_fid)) {
16836                 return false;
16837         }
16838
16839         if (py_server_unc == Py_None) {
16840                 r->in.server_unc = NULL;
16841         } else {
16842                 r->in.server_unc = NULL;
16843                 if (PyUnicode_Check(py_server_unc)) {
16844                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16845                 } else if (PyString_Check(py_server_unc)) {
16846                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16847                 } else {
16848                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16849                         return false;
16850                 }
16851         }
16852         PY_CHECK_TYPE(&PyInt_Type, py_fid, return false;);
16853         r->in.fid = PyInt_AsLong(py_fid);
16854         return true;
16855 }
16856
16857 static PyObject *unpack_py_srvsvc_NetFileClose_args_out(struct srvsvc_NetFileClose *r)
16858 {
16859         PyObject *result;
16860         result = Py_None;
16861         Py_INCREF(result);
16862         if (!W_ERROR_IS_OK(r->out.result)) {
16863                 PyErr_SetWERROR(r->out.result);
16864                 return NULL;
16865         }
16866
16867         return result;
16868 }
16869
16870 static bool pack_py_srvsvc_NetSessEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessEnum *r)
16871 {
16872         PyObject *py_server_unc;
16873         PyObject *py_client;
16874         PyObject *py_user;
16875         PyObject *py_info_ctr;
16876         PyObject *py_max_buffer;
16877         PyObject *py_resume_handle;
16878         const char *kwnames[] = {
16879                 "server_unc", "client", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16880         };
16881
16882         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetSessEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_client, &py_user, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
16883                 return false;
16884         }
16885
16886         if (py_server_unc == Py_None) {
16887                 r->in.server_unc = NULL;
16888         } else {
16889                 r->in.server_unc = NULL;
16890                 if (PyUnicode_Check(py_server_unc)) {
16891                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16892                 } else if (PyString_Check(py_server_unc)) {
16893                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16894                 } else {
16895                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16896                         return false;
16897                 }
16898         }
16899         if (py_client == Py_None) {
16900                 r->in.client = NULL;
16901         } else {
16902                 r->in.client = NULL;
16903                 if (PyUnicode_Check(py_client)) {
16904                         r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
16905                 } else if (PyString_Check(py_client)) {
16906                         r->in.client = PyString_AS_STRING(py_client);
16907                 } else {
16908                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
16909                         return false;
16910                 }
16911         }
16912         if (py_user == Py_None) {
16913                 r->in.user = NULL;
16914         } else {
16915                 r->in.user = NULL;
16916                 if (PyUnicode_Check(py_user)) {
16917                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16918                 } else if (PyString_Check(py_user)) {
16919                         r->in.user = PyString_AS_STRING(py_user);
16920                 } else {
16921                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16922                         return false;
16923                 }
16924         }
16925         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16926         PY_CHECK_TYPE(&srvsvc_NetSessInfoCtr_Type, py_info_ctr, return false;);
16927         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16928                 PyErr_NoMemory();
16929                 return false;
16930         }
16931         r->in.info_ctr = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16932         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16933         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16934         if (py_resume_handle == Py_None) {
16935                 r->in.resume_handle = NULL;
16936         } else {
16937                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16938                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16939                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16940         }
16941         return true;
16942 }
16943
16944 static PyObject *unpack_py_srvsvc_NetSessEnum_args_out(struct srvsvc_NetSessEnum *r)
16945 {
16946         PyObject *result;
16947         PyObject *py_info_ctr;
16948         PyObject *py_totalentries;
16949         PyObject *py_resume_handle;
16950         result = PyTuple_New(3);
16951         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetSessInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16952         PyTuple_SetItem(result, 0, py_info_ctr);
16953         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16954         PyTuple_SetItem(result, 1, py_totalentries);
16955         if (r->out.resume_handle == NULL) {
16956                 py_resume_handle = Py_None;
16957                 Py_INCREF(py_resume_handle);
16958         } else {
16959                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16960         }
16961         PyTuple_SetItem(result, 2, py_resume_handle);
16962         if (!W_ERROR_IS_OK(r->out.result)) {
16963                 PyErr_SetWERROR(r->out.result);
16964                 return NULL;
16965         }
16966
16967         return result;
16968 }
16969
16970 static bool pack_py_srvsvc_NetSessDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessDel *r)
16971 {
16972         PyObject *py_server_unc;
16973         PyObject *py_client;
16974         PyObject *py_user;
16975         const char *kwnames[] = {
16976                 "server_unc", "client", "user", NULL
16977         };
16978
16979         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetSessDel", discard_const_p(char *, kwnames), &py_server_unc, &py_client, &py_user)) {
16980                 return false;
16981         }
16982
16983         if (py_server_unc == Py_None) {
16984                 r->in.server_unc = NULL;
16985         } else {
16986                 r->in.server_unc = NULL;
16987                 if (PyUnicode_Check(py_server_unc)) {
16988                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16989                 } else if (PyString_Check(py_server_unc)) {
16990                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16991                 } else {
16992                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16993                         return false;
16994                 }
16995         }
16996         if (py_client == Py_None) {
16997                 r->in.client = NULL;
16998         } else {
16999                 r->in.client = NULL;
17000                 if (PyUnicode_Check(py_client)) {
17001                         r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
17002                 } else if (PyString_Check(py_client)) {
17003                         r->in.client = PyString_AS_STRING(py_client);
17004                 } else {
17005                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
17006                         return false;
17007                 }
17008         }
17009         if (py_user == Py_None) {
17010                 r->in.user = NULL;
17011         } else {
17012                 r->in.user = NULL;
17013                 if (PyUnicode_Check(py_user)) {
17014                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
17015                 } else if (PyString_Check(py_user)) {
17016                         r->in.user = PyString_AS_STRING(py_user);
17017                 } else {
17018                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
17019                         return false;
17020                 }
17021         }
17022         return true;
17023 }
17024
17025 static PyObject *unpack_py_srvsvc_NetSessDel_args_out(struct srvsvc_NetSessDel *r)
17026 {
17027         PyObject *result;
17028         result = Py_None;
17029         Py_INCREF(result);
17030         if (!W_ERROR_IS_OK(r->out.result)) {
17031                 PyErr_SetWERROR(r->out.result);
17032                 return NULL;
17033         }
17034
17035         return result;
17036 }
17037
17038 static bool pack_py_srvsvc_NetShareAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareAdd *r)
17039 {
17040         PyObject *py_server_unc;
17041         PyObject *py_level;
17042         PyObject *py_info;
17043         PyObject *py_parm_error;
17044         const char *kwnames[] = {
17045                 "server_unc", "level", "info", "parm_error", NULL
17046         };
17047
17048         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
17049                 return false;
17050         }
17051
17052         if (py_server_unc == Py_None) {
17053                 r->in.server_unc = NULL;
17054         } else {
17055                 r->in.server_unc = NULL;
17056                 if (PyUnicode_Check(py_server_unc)) {
17057                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17058                 } else if (PyString_Check(py_server_unc)) {
17059                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17060                 } else {
17061                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17062                         return false;
17063                 }
17064         }
17065         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17066         r->in.level = PyInt_AsLong(py_level);
17067         r->in.info = talloc_ptrtype(r, r->in.info);
17068         {
17069                 union srvsvc_NetShareInfo *info_switch_1;
17070                 info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
17071                 if (info_switch_1 == NULL) {
17072                         return false;
17073                 }
17074                 r->in.info = info_switch_1;
17075         }
17076         if (py_parm_error == Py_None) {
17077                 r->in.parm_error = NULL;
17078         } else {
17079                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17080                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17081                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17082         }
17083         return true;
17084 }
17085
17086 static PyObject *unpack_py_srvsvc_NetShareAdd_args_out(struct srvsvc_NetShareAdd *r)
17087 {
17088         PyObject *result;
17089         PyObject *py_parm_error;
17090         if (r->out.parm_error == NULL) {
17091                 py_parm_error = Py_None;
17092                 Py_INCREF(py_parm_error);
17093         } else {
17094                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17095         }
17096         result = py_parm_error;
17097         if (!W_ERROR_IS_OK(r->out.result)) {
17098                 PyErr_SetWERROR(r->out.result);
17099                 return NULL;
17100         }
17101
17102         return result;
17103 }
17104
17105 static bool pack_py_srvsvc_NetShareEnumAll_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnumAll *r)
17106 {
17107         PyObject *py_server_unc;
17108         PyObject *py_info_ctr;
17109         PyObject *py_max_buffer;
17110         PyObject *py_resume_handle;
17111         const char *kwnames[] = {
17112                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
17113         };
17114
17115         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareEnumAll", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
17116                 return false;
17117         }
17118
17119         if (py_server_unc == Py_None) {
17120                 r->in.server_unc = NULL;
17121         } else {
17122                 r->in.server_unc = NULL;
17123                 if (PyUnicode_Check(py_server_unc)) {
17124                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17125                 } else if (PyString_Check(py_server_unc)) {
17126                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17127                 } else {
17128                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17129                         return false;
17130                 }
17131         }
17132         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
17133         PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
17134         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
17135                 PyErr_NoMemory();
17136                 return false;
17137         }
17138         r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
17139         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
17140         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
17141         if (py_resume_handle == Py_None) {
17142                 r->in.resume_handle = NULL;
17143         } else {
17144                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17145                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17146                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17147         }
17148         return true;
17149 }
17150
17151 static PyObject *unpack_py_srvsvc_NetShareEnumAll_args_out(struct srvsvc_NetShareEnumAll *r)
17152 {
17153         PyObject *result;
17154         PyObject *py_info_ctr;
17155         PyObject *py_totalentries;
17156         PyObject *py_resume_handle;
17157         result = PyTuple_New(3);
17158         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
17159         PyTuple_SetItem(result, 0, py_info_ctr);
17160         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17161         PyTuple_SetItem(result, 1, py_totalentries);
17162         if (r->out.resume_handle == NULL) {
17163                 py_resume_handle = Py_None;
17164                 Py_INCREF(py_resume_handle);
17165         } else {
17166                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17167         }
17168         PyTuple_SetItem(result, 2, py_resume_handle);
17169         if (!W_ERROR_IS_OK(r->out.result)) {
17170                 PyErr_SetWERROR(r->out.result);
17171                 return NULL;
17172         }
17173
17174         return result;
17175 }
17176
17177 static bool pack_py_srvsvc_NetShareGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareGetInfo *r)
17178 {
17179         PyObject *py_server_unc;
17180         PyObject *py_share_name;
17181         PyObject *py_level;
17182         const char *kwnames[] = {
17183                 "server_unc", "share_name", "level", NULL
17184         };
17185
17186         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_level)) {
17187                 return false;
17188         }
17189
17190         if (py_server_unc == Py_None) {
17191                 r->in.server_unc = NULL;
17192         } else {
17193                 r->in.server_unc = NULL;
17194                 if (PyUnicode_Check(py_server_unc)) {
17195                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17196                 } else if (PyString_Check(py_server_unc)) {
17197                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17198                 } else {
17199                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17200                         return false;
17201                 }
17202         }
17203         if (PyUnicode_Check(py_share_name)) {
17204                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17205         } else if (PyString_Check(py_share_name)) {
17206                 r->in.share_name = PyString_AS_STRING(py_share_name);
17207         } else {
17208                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17209                 return false;
17210         }
17211         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17212         r->in.level = PyInt_AsLong(py_level);
17213         return true;
17214 }
17215
17216 static PyObject *unpack_py_srvsvc_NetShareGetInfo_args_out(struct srvsvc_NetShareGetInfo *r)
17217 {
17218         PyObject *result;
17219         PyObject *py_info;
17220         py_info = py_import_srvsvc_NetShareInfo(r->out.info, r->in.level, r->out.info);
17221         if (py_info == NULL) {
17222                 return NULL;
17223         }
17224         result = py_info;
17225         if (!W_ERROR_IS_OK(r->out.result)) {
17226                 PyErr_SetWERROR(r->out.result);
17227                 return NULL;
17228         }
17229
17230         return result;
17231 }
17232
17233 static bool pack_py_srvsvc_NetShareSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareSetInfo *r)
17234 {
17235         PyObject *py_server_unc;
17236         PyObject *py_share_name;
17237         PyObject *py_level;
17238         PyObject *py_info;
17239         PyObject *py_parm_error;
17240         const char *kwnames[] = {
17241                 "server_unc", "share_name", "level", "info", "parm_error", NULL
17242         };
17243
17244         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetShareSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_level, &py_info, &py_parm_error)) {
17245                 return false;
17246         }
17247
17248         if (py_server_unc == Py_None) {
17249                 r->in.server_unc = NULL;
17250         } else {
17251                 r->in.server_unc = NULL;
17252                 if (PyUnicode_Check(py_server_unc)) {
17253                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17254                 } else if (PyString_Check(py_server_unc)) {
17255                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17256                 } else {
17257                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17258                         return false;
17259                 }
17260         }
17261         if (PyUnicode_Check(py_share_name)) {
17262                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17263         } else if (PyString_Check(py_share_name)) {
17264                 r->in.share_name = PyString_AS_STRING(py_share_name);
17265         } else {
17266                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17267                 return false;
17268         }
17269         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17270         r->in.level = PyInt_AsLong(py_level);
17271         r->in.info = talloc_ptrtype(r, r->in.info);
17272         {
17273                 union srvsvc_NetShareInfo *info_switch_1;
17274                 info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
17275                 if (info_switch_1 == NULL) {
17276                         return false;
17277                 }
17278                 r->in.info = info_switch_1;
17279         }
17280         if (py_parm_error == Py_None) {
17281                 r->in.parm_error = NULL;
17282         } else {
17283                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17284                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17285                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17286         }
17287         return true;
17288 }
17289
17290 static PyObject *unpack_py_srvsvc_NetShareSetInfo_args_out(struct srvsvc_NetShareSetInfo *r)
17291 {
17292         PyObject *result;
17293         PyObject *py_parm_error;
17294         if (r->out.parm_error == NULL) {
17295                 py_parm_error = Py_None;
17296                 Py_INCREF(py_parm_error);
17297         } else {
17298                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17299         }
17300         result = py_parm_error;
17301         if (!W_ERROR_IS_OK(r->out.result)) {
17302                 PyErr_SetWERROR(r->out.result);
17303                 return NULL;
17304         }
17305
17306         return result;
17307 }
17308
17309 static bool pack_py_srvsvc_NetShareDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDel *r)
17310 {
17311         PyObject *py_server_unc;
17312         PyObject *py_share_name;
17313         PyObject *py_reserved;
17314         const char *kwnames[] = {
17315                 "server_unc", "share_name", "reserved", NULL
17316         };
17317
17318         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDel", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
17319                 return false;
17320         }
17321
17322         if (py_server_unc == Py_None) {
17323                 r->in.server_unc = NULL;
17324         } else {
17325                 r->in.server_unc = NULL;
17326                 if (PyUnicode_Check(py_server_unc)) {
17327                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17328                 } else if (PyString_Check(py_server_unc)) {
17329                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17330                 } else {
17331                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17332                         return false;
17333                 }
17334         }
17335         if (PyUnicode_Check(py_share_name)) {
17336                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17337         } else if (PyString_Check(py_share_name)) {
17338                 r->in.share_name = PyString_AS_STRING(py_share_name);
17339         } else {
17340                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17341                 return false;
17342         }
17343         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
17344         r->in.reserved = PyInt_AsLong(py_reserved);
17345         return true;
17346 }
17347
17348 static PyObject *unpack_py_srvsvc_NetShareDel_args_out(struct srvsvc_NetShareDel *r)
17349 {
17350         PyObject *result;
17351         result = Py_None;
17352         Py_INCREF(result);
17353         if (!W_ERROR_IS_OK(r->out.result)) {
17354                 PyErr_SetWERROR(r->out.result);
17355                 return NULL;
17356         }
17357
17358         return result;
17359 }
17360
17361 static bool pack_py_srvsvc_NetShareDelSticky_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelSticky *r)
17362 {
17363         PyObject *py_server_unc;
17364         PyObject *py_share_name;
17365         PyObject *py_reserved;
17366         const char *kwnames[] = {
17367                 "server_unc", "share_name", "reserved", NULL
17368         };
17369
17370         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelSticky", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
17371                 return false;
17372         }
17373
17374         if (py_server_unc == Py_None) {
17375                 r->in.server_unc = NULL;
17376         } else {
17377                 r->in.server_unc = NULL;
17378                 if (PyUnicode_Check(py_server_unc)) {
17379                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17380                 } else if (PyString_Check(py_server_unc)) {
17381                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17382                 } else {
17383                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17384                         return false;
17385                 }
17386         }
17387         if (PyUnicode_Check(py_share_name)) {
17388                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17389         } else if (PyString_Check(py_share_name)) {
17390                 r->in.share_name = PyString_AS_STRING(py_share_name);
17391         } else {
17392                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17393                 return false;
17394         }
17395         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
17396         r->in.reserved = PyInt_AsLong(py_reserved);
17397         return true;
17398 }
17399
17400 static PyObject *unpack_py_srvsvc_NetShareDelSticky_args_out(struct srvsvc_NetShareDelSticky *r)
17401 {
17402         PyObject *result;
17403         result = Py_None;
17404         Py_INCREF(result);
17405         if (!W_ERROR_IS_OK(r->out.result)) {
17406                 PyErr_SetWERROR(r->out.result);
17407                 return NULL;
17408         }
17409
17410         return result;
17411 }
17412
17413 static bool pack_py_srvsvc_NetShareCheck_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareCheck *r)
17414 {
17415         PyObject *py_server_unc;
17416         PyObject *py_device_name;
17417         const char *kwnames[] = {
17418                 "server_unc", "device_name", NULL
17419         };
17420
17421         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetShareCheck", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name)) {
17422                 return false;
17423         }
17424
17425         if (py_server_unc == Py_None) {
17426                 r->in.server_unc = NULL;
17427         } else {
17428                 r->in.server_unc = NULL;
17429                 if (PyUnicode_Check(py_server_unc)) {
17430                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17431                 } else if (PyString_Check(py_server_unc)) {
17432                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17433                 } else {
17434                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17435                         return false;
17436                 }
17437         }
17438         if (PyUnicode_Check(py_device_name)) {
17439                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
17440         } else if (PyString_Check(py_device_name)) {
17441                 r->in.device_name = PyString_AS_STRING(py_device_name);
17442         } else {
17443                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
17444                 return false;
17445         }
17446         return true;
17447 }
17448
17449 static PyObject *unpack_py_srvsvc_NetShareCheck_args_out(struct srvsvc_NetShareCheck *r)
17450 {
17451         PyObject *result;
17452         PyObject *py_type;
17453         py_type = PyInt_FromLong(*r->out.type);
17454         result = py_type;
17455         if (!W_ERROR_IS_OK(r->out.result)) {
17456                 PyErr_SetWERROR(r->out.result);
17457                 return NULL;
17458         }
17459
17460         return result;
17461 }
17462
17463 static bool pack_py_srvsvc_NetSrvGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvGetInfo *r)
17464 {
17465         PyObject *py_server_unc;
17466         PyObject *py_level;
17467         const char *kwnames[] = {
17468                 "server_unc", "level", NULL
17469         };
17470
17471         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetSrvGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level)) {
17472                 return false;
17473         }
17474
17475         if (py_server_unc == Py_None) {
17476                 r->in.server_unc = NULL;
17477         } else {
17478                 r->in.server_unc = NULL;
17479                 if (PyUnicode_Check(py_server_unc)) {
17480                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17481                 } else if (PyString_Check(py_server_unc)) {
17482                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17483                 } else {
17484                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17485                         return false;
17486                 }
17487         }
17488         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17489         r->in.level = PyInt_AsLong(py_level);
17490         return true;
17491 }
17492
17493 static PyObject *unpack_py_srvsvc_NetSrvGetInfo_args_out(struct srvsvc_NetSrvGetInfo *r)
17494 {
17495         PyObject *result;
17496         PyObject *py_info;
17497         py_info = py_import_srvsvc_NetSrvInfo(r->out.info, r->in.level, r->out.info);
17498         if (py_info == NULL) {
17499                 return NULL;
17500         }
17501         result = py_info;
17502         if (!W_ERROR_IS_OK(r->out.result)) {
17503                 PyErr_SetWERROR(r->out.result);
17504                 return NULL;
17505         }
17506
17507         return result;
17508 }
17509
17510 static bool pack_py_srvsvc_NetSrvSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvSetInfo *r)
17511 {
17512         PyObject *py_server_unc;
17513         PyObject *py_level;
17514         PyObject *py_info;
17515         PyObject *py_parm_error;
17516         const char *kwnames[] = {
17517                 "server_unc", "level", "info", "parm_error", NULL
17518         };
17519
17520         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSrvSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
17521                 return false;
17522         }
17523
17524         if (py_server_unc == Py_None) {
17525                 r->in.server_unc = NULL;
17526         } else {
17527                 r->in.server_unc = NULL;
17528                 if (PyUnicode_Check(py_server_unc)) {
17529                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17530                 } else if (PyString_Check(py_server_unc)) {
17531                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17532                 } else {
17533                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17534                         return false;
17535                 }
17536         }
17537         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17538         r->in.level = PyInt_AsLong(py_level);
17539         r->in.info = talloc_ptrtype(r, r->in.info);
17540         {
17541                 union srvsvc_NetSrvInfo *info_switch_1;
17542                 info_switch_1 = py_export_srvsvc_NetSrvInfo(r, r->in.level, py_info);
17543                 if (info_switch_1 == NULL) {
17544                         return false;
17545                 }
17546                 r->in.info = info_switch_1;
17547         }
17548         if (py_parm_error == Py_None) {
17549                 r->in.parm_error = NULL;
17550         } else {
17551                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17552                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17553                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17554         }
17555         return true;
17556 }
17557
17558 static PyObject *unpack_py_srvsvc_NetSrvSetInfo_args_out(struct srvsvc_NetSrvSetInfo *r)
17559 {
17560         PyObject *result;
17561         PyObject *py_parm_error;
17562         if (r->out.parm_error == NULL) {
17563                 py_parm_error = Py_None;
17564                 Py_INCREF(py_parm_error);
17565         } else {
17566                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17567         }
17568         result = py_parm_error;
17569         if (!W_ERROR_IS_OK(r->out.result)) {
17570                 PyErr_SetWERROR(r->out.result);
17571                 return NULL;
17572         }
17573
17574         return result;
17575 }
17576
17577 static bool pack_py_srvsvc_NetDiskEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetDiskEnum *r)
17578 {
17579         PyObject *py_server_unc;
17580         PyObject *py_level;
17581         PyObject *py_info;
17582         PyObject *py_maxlen;
17583         PyObject *py_resume_handle;
17584         const char *kwnames[] = {
17585                 "server_unc", "level", "info", "maxlen", "resume_handle", NULL
17586         };
17587
17588         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetDiskEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_maxlen, &py_resume_handle)) {
17589                 return false;
17590         }
17591
17592         if (py_server_unc == Py_None) {
17593                 r->in.server_unc = NULL;
17594         } else {
17595                 r->in.server_unc = NULL;
17596                 if (PyUnicode_Check(py_server_unc)) {
17597                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17598                 } else if (PyString_Check(py_server_unc)) {
17599                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17600                 } else {
17601                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17602                         return false;
17603                 }
17604         }
17605         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17606         r->in.level = PyInt_AsLong(py_level);
17607         r->in.info = talloc_ptrtype(r, r->in.info);
17608         PY_CHECK_TYPE(&srvsvc_NetDiskInfo_Type, py_info, return false;);
17609         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
17610                 PyErr_NoMemory();
17611                 return false;
17612         }
17613         r->in.info = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_info);
17614         PY_CHECK_TYPE(&PyInt_Type, py_maxlen, return false;);
17615         r->in.maxlen = PyInt_AsLong(py_maxlen);
17616         if (py_resume_handle == Py_None) {
17617                 r->in.resume_handle = NULL;
17618         } else {
17619                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17620                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17621                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17622         }
17623         return true;
17624 }
17625
17626 static PyObject *unpack_py_srvsvc_NetDiskEnum_args_out(struct srvsvc_NetDiskEnum *r)
17627 {
17628         PyObject *result;
17629         PyObject *py_info;
17630         PyObject *py_totalentries;
17631         PyObject *py_resume_handle;
17632         result = PyTuple_New(3);
17633         py_info = pytalloc_reference_ex(&srvsvc_NetDiskInfo_Type, r->out.info, r->out.info);
17634         PyTuple_SetItem(result, 0, py_info);
17635         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17636         PyTuple_SetItem(result, 1, py_totalentries);
17637         if (r->out.resume_handle == NULL) {
17638                 py_resume_handle = Py_None;
17639                 Py_INCREF(py_resume_handle);
17640         } else {
17641                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17642         }
17643         PyTuple_SetItem(result, 2, py_resume_handle);
17644         if (!W_ERROR_IS_OK(r->out.result)) {
17645                 PyErr_SetWERROR(r->out.result);
17646                 return NULL;
17647         }
17648
17649         return result;
17650 }
17651
17652 static bool pack_py_srvsvc_NetServerStatisticsGet_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerStatisticsGet *r)
17653 {
17654         PyObject *py_server_unc;
17655         PyObject *py_service;
17656         PyObject *py_level;
17657         PyObject *py_options;
17658         const char *kwnames[] = {
17659                 "server_unc", "service", "level", "options", NULL
17660         };
17661
17662         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetServerStatisticsGet", discard_const_p(char *, kwnames), &py_server_unc, &py_service, &py_level, &py_options)) {
17663                 return false;
17664         }
17665
17666         if (py_server_unc == Py_None) {
17667                 r->in.server_unc = NULL;
17668         } else {
17669                 r->in.server_unc = NULL;
17670                 if (PyUnicode_Check(py_server_unc)) {
17671                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17672                 } else if (PyString_Check(py_server_unc)) {
17673                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17674                 } else {
17675                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17676                         return false;
17677                 }
17678         }
17679         if (py_service == Py_None) {
17680                 r->in.service = NULL;
17681         } else {
17682                 r->in.service = NULL;
17683                 if (PyUnicode_Check(py_service)) {
17684                         r->in.service = PyString_AS_STRING(PyUnicode_AsEncodedString(py_service, "utf-8", "ignore"));
17685                 } else if (PyString_Check(py_service)) {
17686                         r->in.service = PyString_AS_STRING(py_service);
17687                 } else {
17688                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_service)->tp_name);
17689                         return false;
17690                 }
17691         }
17692         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17693         r->in.level = PyInt_AsLong(py_level);
17694         PY_CHECK_TYPE(&PyInt_Type, py_options, return false;);
17695         r->in.options = PyInt_AsLong(py_options);
17696         return true;
17697 }
17698
17699 static PyObject *unpack_py_srvsvc_NetServerStatisticsGet_args_out(struct srvsvc_NetServerStatisticsGet *r)
17700 {
17701         PyObject *result;
17702         PyObject *py_stats;
17703         if (*r->out.stats == NULL) {
17704                 py_stats = Py_None;
17705                 Py_INCREF(py_stats);
17706         } else {
17707                 py_stats = pytalloc_reference_ex(&srvsvc_Statistics_Type, *r->out.stats, *r->out.stats);
17708         }
17709         result = py_stats;
17710         if (!W_ERROR_IS_OK(r->out.result)) {
17711                 PyErr_SetWERROR(r->out.result);
17712                 return NULL;
17713         }
17714
17715         return result;
17716 }
17717
17718 static bool pack_py_srvsvc_NetTransportAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportAdd *r)
17719 {
17720         PyObject *py_server_unc;
17721         PyObject *py_level;
17722         PyObject *py_info;
17723         const char *kwnames[] = {
17724                 "server_unc", "level", "info", NULL
17725         };
17726
17727         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
17728                 return false;
17729         }
17730
17731         if (py_server_unc == Py_None) {
17732                 r->in.server_unc = NULL;
17733         } else {
17734                 r->in.server_unc = NULL;
17735                 if (PyUnicode_Check(py_server_unc)) {
17736                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17737                 } else if (PyString_Check(py_server_unc)) {
17738                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17739                 } else {
17740                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17741                         return false;
17742                 }
17743         }
17744         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17745         r->in.level = PyInt_AsLong(py_level);
17746         {
17747                 union srvsvc_NetTransportInfo *info_switch_0;
17748                 info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
17749                 if (info_switch_0 == NULL) {
17750                         return false;
17751                 }
17752                 r->in.info = *info_switch_0;
17753         }
17754         return true;
17755 }
17756
17757 static PyObject *unpack_py_srvsvc_NetTransportAdd_args_out(struct srvsvc_NetTransportAdd *r)
17758 {
17759         PyObject *result;
17760         result = Py_None;
17761         Py_INCREF(result);
17762         if (!W_ERROR_IS_OK(r->out.result)) {
17763                 PyErr_SetWERROR(r->out.result);
17764                 return NULL;
17765         }
17766
17767         return result;
17768 }
17769
17770 static bool pack_py_srvsvc_NetTransportEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportEnum *r)
17771 {
17772         PyObject *py_server_unc;
17773         PyObject *py_transports;
17774         PyObject *py_max_buffer;
17775         PyObject *py_resume_handle;
17776         const char *kwnames[] = {
17777                 "server_unc", "transports", "max_buffer", "resume_handle", NULL
17778         };
17779
17780         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetTransportEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_transports, &py_max_buffer, &py_resume_handle)) {
17781                 return false;
17782         }
17783
17784         if (py_server_unc == Py_None) {
17785                 r->in.server_unc = NULL;
17786         } else {
17787                 r->in.server_unc = NULL;
17788                 if (PyUnicode_Check(py_server_unc)) {
17789                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17790                 } else if (PyString_Check(py_server_unc)) {
17791                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17792                 } else {
17793                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17794                         return false;
17795                 }
17796         }
17797         r->in.transports = talloc_ptrtype(r, r->in.transports);
17798         PY_CHECK_TYPE(&srvsvc_NetTransportInfoCtr_Type, py_transports, return false;);
17799         if (talloc_reference(r, pytalloc_get_mem_ctx(py_transports)) == NULL) {
17800                 PyErr_NoMemory();
17801                 return false;
17802         }
17803         r->in.transports = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_transports);
17804         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
17805         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
17806         if (py_resume_handle == Py_None) {
17807                 r->in.resume_handle = NULL;
17808         } else {
17809                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17810                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17811                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17812         }
17813         return true;
17814 }
17815
17816 static PyObject *unpack_py_srvsvc_NetTransportEnum_args_out(struct srvsvc_NetTransportEnum *r)
17817 {
17818         PyObject *result;
17819         PyObject *py_transports;
17820         PyObject *py_totalentries;
17821         PyObject *py_resume_handle;
17822         result = PyTuple_New(3);
17823         py_transports = pytalloc_reference_ex(&srvsvc_NetTransportInfoCtr_Type, r->out.transports, r->out.transports);
17824         PyTuple_SetItem(result, 0, py_transports);
17825         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17826         PyTuple_SetItem(result, 1, py_totalentries);
17827         if (r->out.resume_handle == NULL) {
17828                 py_resume_handle = Py_None;
17829                 Py_INCREF(py_resume_handle);
17830         } else {
17831                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17832         }
17833         PyTuple_SetItem(result, 2, py_resume_handle);
17834         if (!W_ERROR_IS_OK(r->out.result)) {
17835                 PyErr_SetWERROR(r->out.result);
17836                 return NULL;
17837         }
17838
17839         return result;
17840 }
17841
17842 static bool pack_py_srvsvc_NetTransportDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportDel *r)
17843 {
17844         PyObject *py_server_unc;
17845         PyObject *py_level;
17846         PyObject *py_info0;
17847         const char *kwnames[] = {
17848                 "server_unc", "level", "info0", NULL
17849         };
17850
17851         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportDel", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info0)) {
17852                 return false;
17853         }
17854
17855         if (py_server_unc == Py_None) {
17856                 r->in.server_unc = NULL;
17857         } else {
17858                 r->in.server_unc = NULL;
17859                 if (PyUnicode_Check(py_server_unc)) {
17860                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17861                 } else if (PyString_Check(py_server_unc)) {
17862                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17863                 } else {
17864                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17865                         return false;
17866                 }
17867         }
17868         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17869         r->in.level = PyInt_AsLong(py_level);
17870         r->in.info0 = talloc_ptrtype(r, r->in.info0);
17871         PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, py_info0, return false;);
17872         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info0)) == NULL) {
17873                 PyErr_NoMemory();
17874                 return false;
17875         }
17876         r->in.info0 = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_info0);
17877         return true;
17878 }
17879
17880 static PyObject *unpack_py_srvsvc_NetTransportDel_args_out(struct srvsvc_NetTransportDel *r)
17881 {
17882         PyObject *result;
17883         result = Py_None;
17884         Py_INCREF(result);
17885         if (!W_ERROR_IS_OK(r->out.result)) {
17886                 PyErr_SetWERROR(r->out.result);
17887                 return NULL;
17888         }
17889
17890         return result;
17891 }
17892
17893 static bool pack_py_srvsvc_NetRemoteTOD_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetRemoteTOD *r)
17894 {
17895         PyObject *py_server_unc;
17896         const char *kwnames[] = {
17897                 "server_unc", NULL
17898         };
17899
17900         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetRemoteTOD", discard_const_p(char *, kwnames), &py_server_unc)) {
17901                 return false;
17902         }
17903
17904         if (py_server_unc == Py_None) {
17905                 r->in.server_unc = NULL;
17906         } else {
17907                 r->in.server_unc = NULL;
17908                 if (PyUnicode_Check(py_server_unc)) {
17909                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17910                 } else if (PyString_Check(py_server_unc)) {
17911                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17912                 } else {
17913                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17914                         return false;
17915                 }
17916         }
17917         return true;
17918 }
17919
17920 static PyObject *unpack_py_srvsvc_NetRemoteTOD_args_out(struct srvsvc_NetRemoteTOD *r)
17921 {
17922         PyObject *result;
17923         PyObject *py_info;
17924         if (*r->out.info == NULL) {
17925                 py_info = Py_None;
17926                 Py_INCREF(py_info);
17927         } else {
17928                 py_info = pytalloc_reference_ex(&srvsvc_NetRemoteTODInfo_Type, *r->out.info, *r->out.info);
17929         }
17930         result = py_info;
17931         if (!W_ERROR_IS_OK(r->out.result)) {
17932                 PyErr_SetWERROR(r->out.result);
17933                 return NULL;
17934         }
17935
17936         return result;
17937 }
17938
17939 static bool pack_py_srvsvc_NetSetServiceBits_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetServiceBits *r)
17940 {
17941         PyObject *py_server_unc;
17942         PyObject *py_transport;
17943         PyObject *py_servicebits;
17944         PyObject *py_updateimmediately;
17945         const char *kwnames[] = {
17946                 "server_unc", "transport", "servicebits", "updateimmediately", NULL
17947         };
17948
17949         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSetServiceBits", discard_const_p(char *, kwnames), &py_server_unc, &py_transport, &py_servicebits, &py_updateimmediately)) {
17950                 return false;
17951         }
17952
17953         if (py_server_unc == Py_None) {
17954                 r->in.server_unc = NULL;
17955         } else {
17956                 r->in.server_unc = NULL;
17957                 if (PyUnicode_Check(py_server_unc)) {
17958                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17959                 } else if (PyString_Check(py_server_unc)) {
17960                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17961                 } else {
17962                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17963                         return false;
17964                 }
17965         }
17966         if (py_transport == Py_None) {
17967                 r->in.transport = NULL;
17968         } else {
17969                 r->in.transport = NULL;
17970                 if (PyUnicode_Check(py_transport)) {
17971                         r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
17972                 } else if (PyString_Check(py_transport)) {
17973                         r->in.transport = PyString_AS_STRING(py_transport);
17974                 } else {
17975                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
17976                         return false;
17977                 }
17978         }
17979         PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
17980         r->in.servicebits = PyInt_AsLong(py_servicebits);
17981         PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
17982         r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
17983         return true;
17984 }
17985
17986 static PyObject *unpack_py_srvsvc_NetSetServiceBits_args_out(struct srvsvc_NetSetServiceBits *r)
17987 {
17988         PyObject *result;
17989         result = Py_None;
17990         Py_INCREF(result);
17991         if (!W_ERROR_IS_OK(r->out.result)) {
17992                 PyErr_SetWERROR(r->out.result);
17993                 return NULL;
17994         }
17995
17996         return result;
17997 }
17998
17999 static bool pack_py_srvsvc_NetPathType_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathType *r)
18000 {
18001         PyObject *py_server_unc;
18002         PyObject *py_path;
18003         PyObject *py_pathflags;
18004         const char *kwnames[] = {
18005                 "server_unc", "path", "pathflags", NULL
18006         };
18007
18008         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetPathType", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_pathflags)) {
18009                 return false;
18010         }
18011
18012         if (py_server_unc == Py_None) {
18013                 r->in.server_unc = NULL;
18014         } else {
18015                 r->in.server_unc = NULL;
18016                 if (PyUnicode_Check(py_server_unc)) {
18017                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18018                 } else if (PyString_Check(py_server_unc)) {
18019                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18020                 } else {
18021                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18022                         return false;
18023                 }
18024         }
18025         if (PyUnicode_Check(py_path)) {
18026                 r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
18027         } else if (PyString_Check(py_path)) {
18028                 r->in.path = PyString_AS_STRING(py_path);
18029         } else {
18030                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
18031                 return false;
18032         }
18033         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18034         r->in.pathflags = PyInt_AsLong(py_pathflags);
18035         return true;
18036 }
18037
18038 static PyObject *unpack_py_srvsvc_NetPathType_args_out(struct srvsvc_NetPathType *r)
18039 {
18040         PyObject *result;
18041         PyObject *py_pathtype;
18042         py_pathtype = PyInt_FromLong(*r->out.pathtype);
18043         result = py_pathtype;
18044         if (!W_ERROR_IS_OK(r->out.result)) {
18045                 PyErr_SetWERROR(r->out.result);
18046                 return NULL;
18047         }
18048
18049         return result;
18050 }
18051
18052 static bool pack_py_srvsvc_NetPathCanonicalize_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCanonicalize *r)
18053 {
18054         PyObject *py_server_unc;
18055         PyObject *py_path;
18056         PyObject *py_maxbuf;
18057         PyObject *py_prefix;
18058         PyObject *py_pathtype;
18059         PyObject *py_pathflags;
18060         const char *kwnames[] = {
18061                 "server_unc", "path", "maxbuf", "prefix", "pathtype", "pathflags", NULL
18062         };
18063
18064         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetPathCanonicalize", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_maxbuf, &py_prefix, &py_pathtype, &py_pathflags)) {
18065                 return false;
18066         }
18067
18068         if (py_server_unc == Py_None) {
18069                 r->in.server_unc = NULL;
18070         } else {
18071                 r->in.server_unc = NULL;
18072                 if (PyUnicode_Check(py_server_unc)) {
18073                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18074                 } else if (PyString_Check(py_server_unc)) {
18075                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18076                 } else {
18077                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18078                         return false;
18079                 }
18080         }
18081         if (PyUnicode_Check(py_path)) {
18082                 r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
18083         } else if (PyString_Check(py_path)) {
18084                 r->in.path = PyString_AS_STRING(py_path);
18085         } else {
18086                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
18087                 return false;
18088         }
18089         PY_CHECK_TYPE(&PyInt_Type, py_maxbuf, return false;);
18090         r->in.maxbuf = PyInt_AsLong(py_maxbuf);
18091         if (PyUnicode_Check(py_prefix)) {
18092                 r->in.prefix = PyString_AS_STRING(PyUnicode_AsEncodedString(py_prefix, "utf-8", "ignore"));
18093         } else if (PyString_Check(py_prefix)) {
18094                 r->in.prefix = PyString_AS_STRING(py_prefix);
18095         } else {
18096                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_prefix)->tp_name);
18097                 return false;
18098         }
18099         r->in.pathtype = talloc_ptrtype(r, r->in.pathtype);
18100         PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
18101         *r->in.pathtype = PyInt_AsLong(py_pathtype);
18102         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18103         r->in.pathflags = PyInt_AsLong(py_pathflags);
18104         return true;
18105 }
18106
18107 static PyObject *unpack_py_srvsvc_NetPathCanonicalize_args_out(struct srvsvc_NetPathCanonicalize *r)
18108 {
18109         PyObject *result;
18110         PyObject *py_can_path;
18111         PyObject *py_pathtype;
18112         result = PyTuple_New(2);
18113         py_can_path = PyList_New(r->in.maxbuf);
18114         if (py_can_path == NULL) {
18115                 return NULL;
18116         }
18117         {
18118                 int can_path_cntr_0;
18119                 for (can_path_cntr_0 = 0; can_path_cntr_0 < r->in.maxbuf; can_path_cntr_0++) {
18120                         PyObject *py_can_path_0;
18121                         py_can_path_0 = PyInt_FromLong(r->out.can_path[can_path_cntr_0]);
18122                         PyList_SetItem(py_can_path, can_path_cntr_0, py_can_path_0);
18123                 }
18124         }
18125         PyTuple_SetItem(result, 0, py_can_path);
18126         py_pathtype = PyInt_FromLong(*r->out.pathtype);
18127         PyTuple_SetItem(result, 1, py_pathtype);
18128         if (!W_ERROR_IS_OK(r->out.result)) {
18129                 PyErr_SetWERROR(r->out.result);
18130                 return NULL;
18131         }
18132
18133         return result;
18134 }
18135
18136 static bool pack_py_srvsvc_NetPathCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCompare *r)
18137 {
18138         PyObject *py_server_unc;
18139         PyObject *py_path1;
18140         PyObject *py_path2;
18141         PyObject *py_pathtype;
18142         PyObject *py_pathflags;
18143         const char *kwnames[] = {
18144                 "server_unc", "path1", "path2", "pathtype", "pathflags", NULL
18145         };
18146
18147         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetPathCompare", discard_const_p(char *, kwnames), &py_server_unc, &py_path1, &py_path2, &py_pathtype, &py_pathflags)) {
18148                 return false;
18149         }
18150
18151         if (py_server_unc == Py_None) {
18152                 r->in.server_unc = NULL;
18153         } else {
18154                 r->in.server_unc = NULL;
18155                 if (PyUnicode_Check(py_server_unc)) {
18156                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18157                 } else if (PyString_Check(py_server_unc)) {
18158                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18159                 } else {
18160                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18161                         return false;
18162                 }
18163         }
18164         if (PyUnicode_Check(py_path1)) {
18165                 r->in.path1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path1, "utf-8", "ignore"));
18166         } else if (PyString_Check(py_path1)) {
18167                 r->in.path1 = PyString_AS_STRING(py_path1);
18168         } else {
18169                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path1)->tp_name);
18170                 return false;
18171         }
18172         if (PyUnicode_Check(py_path2)) {
18173                 r->in.path2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path2, "utf-8", "ignore"));
18174         } else if (PyString_Check(py_path2)) {
18175                 r->in.path2 = PyString_AS_STRING(py_path2);
18176         } else {
18177                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path2)->tp_name);
18178                 return false;
18179         }
18180         PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
18181         r->in.pathtype = PyInt_AsLong(py_pathtype);
18182         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18183         r->in.pathflags = PyInt_AsLong(py_pathflags);
18184         return true;
18185 }
18186
18187 static PyObject *unpack_py_srvsvc_NetPathCompare_args_out(struct srvsvc_NetPathCompare *r)
18188 {
18189         PyObject *result;
18190         result = Py_None;
18191         Py_INCREF(result);
18192         if (!W_ERROR_IS_OK(r->out.result)) {
18193                 PyErr_SetWERROR(r->out.result);
18194                 return NULL;
18195         }
18196
18197         return result;
18198 }
18199
18200 static bool pack_py_srvsvc_NetNameValidate_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetNameValidate *r)
18201 {
18202         PyObject *py_server_unc;
18203         PyObject *py_name;
18204         PyObject *py_name_type;
18205         PyObject *py_flags;
18206         const char *kwnames[] = {
18207                 "server_unc", "name", "name_type", "flags", NULL
18208         };
18209
18210         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetNameValidate", discard_const_p(char *, kwnames), &py_server_unc, &py_name, &py_name_type, &py_flags)) {
18211                 return false;
18212         }
18213
18214         if (py_server_unc == Py_None) {
18215                 r->in.server_unc = NULL;
18216         } else {
18217                 r->in.server_unc = NULL;
18218                 if (PyUnicode_Check(py_server_unc)) {
18219                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18220                 } else if (PyString_Check(py_server_unc)) {
18221                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18222                 } else {
18223                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18224                         return false;
18225                 }
18226         }
18227         if (PyUnicode_Check(py_name)) {
18228                 r->in.name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name, "utf-8", "ignore"));
18229         } else if (PyString_Check(py_name)) {
18230                 r->in.name = PyString_AS_STRING(py_name);
18231         } else {
18232                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name)->tp_name);
18233                 return false;
18234         }
18235         PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
18236         r->in.name_type = PyInt_AsLong(py_name_type);
18237         PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
18238         r->in.flags = PyInt_AsLong(py_flags);
18239         return true;
18240 }
18241
18242 static PyObject *unpack_py_srvsvc_NetNameValidate_args_out(struct srvsvc_NetNameValidate *r)
18243 {
18244         PyObject *result;
18245         result = Py_None;
18246         Py_INCREF(result);
18247         if (!W_ERROR_IS_OK(r->out.result)) {
18248                 PyErr_SetWERROR(r->out.result);
18249                 return NULL;
18250         }
18251
18252         return result;
18253 }
18254
18255 static bool pack_py_srvsvc_NetPRNameCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPRNameCompare *r)
18256 {
18257         PyObject *py_server_unc;
18258         PyObject *py_name1;
18259         PyObject *py_name2;
18260         PyObject *py_name_type;
18261         PyObject *py_flags;
18262         const char *kwnames[] = {
18263                 "server_unc", "name1", "name2", "name_type", "flags", NULL
18264         };
18265
18266         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetPRNameCompare", discard_const_p(char *, kwnames), &py_server_unc, &py_name1, &py_name2, &py_name_type, &py_flags)) {
18267                 return false;
18268         }
18269
18270         if (py_server_unc == Py_None) {
18271                 r->in.server_unc = NULL;
18272         } else {
18273                 r->in.server_unc = NULL;
18274                 if (PyUnicode_Check(py_server_unc)) {
18275                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18276                 } else if (PyString_Check(py_server_unc)) {
18277                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18278                 } else {
18279                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18280                         return false;
18281                 }
18282         }
18283         if (PyUnicode_Check(py_name1)) {
18284                 r->in.name1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name1, "utf-8", "ignore"));
18285         } else if (PyString_Check(py_name1)) {
18286                 r->in.name1 = PyString_AS_STRING(py_name1);
18287         } else {
18288                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name1)->tp_name);
18289                 return false;
18290         }
18291         if (PyUnicode_Check(py_name2)) {
18292                 r->in.name2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name2, "utf-8", "ignore"));
18293         } else if (PyString_Check(py_name2)) {
18294                 r->in.name2 = PyString_AS_STRING(py_name2);
18295         } else {
18296                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name2)->tp_name);
18297                 return false;
18298         }
18299         PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
18300         r->in.name_type = PyInt_AsLong(py_name_type);
18301         PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
18302         r->in.flags = PyInt_AsLong(py_flags);
18303         return true;
18304 }
18305
18306 static PyObject *unpack_py_srvsvc_NetPRNameCompare_args_out(struct srvsvc_NetPRNameCompare *r)
18307 {
18308         PyObject *result;
18309         result = Py_None;
18310         Py_INCREF(result);
18311         if (!W_ERROR_IS_OK(r->out.result)) {
18312                 PyErr_SetWERROR(r->out.result);
18313                 return NULL;
18314         }
18315
18316         return result;
18317 }
18318
18319 static bool pack_py_srvsvc_NetShareEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnum *r)
18320 {
18321         PyObject *py_server_unc;
18322         PyObject *py_info_ctr;
18323         PyObject *py_max_buffer;
18324         PyObject *py_resume_handle;
18325         const char *kwnames[] = {
18326                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
18327         };
18328
18329         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_info_ctr, &py_max_buffer, &py_resume_handle)) {
18330                 return false;
18331         }
18332
18333         if (py_server_unc == Py_None) {
18334                 r->in.server_unc = NULL;
18335         } else {
18336                 r->in.server_unc = NULL;
18337                 if (PyUnicode_Check(py_server_unc)) {
18338                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18339                 } else if (PyString_Check(py_server_unc)) {
18340                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18341                 } else {
18342                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18343                         return false;
18344                 }
18345         }
18346         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
18347         PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
18348         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
18349                 PyErr_NoMemory();
18350                 return false;
18351         }
18352         r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
18353         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
18354         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
18355         if (py_resume_handle == Py_None) {
18356                 r->in.resume_handle = NULL;
18357         } else {
18358                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
18359                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
18360                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
18361         }
18362         return true;
18363 }
18364
18365 static PyObject *unpack_py_srvsvc_NetShareEnum_args_out(struct srvsvc_NetShareEnum *r)
18366 {
18367         PyObject *result;
18368         PyObject *py_info_ctr;
18369         PyObject *py_totalentries;
18370         PyObject *py_resume_handle;
18371         result = PyTuple_New(3);
18372         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
18373         PyTuple_SetItem(result, 0, py_info_ctr);
18374         py_totalentries = PyInt_FromLong(*r->out.totalentries);
18375         PyTuple_SetItem(result, 1, py_totalentries);
18376         if (r->out.resume_handle == NULL) {
18377                 py_resume_handle = Py_None;
18378                 Py_INCREF(py_resume_handle);
18379         } else {
18380                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
18381         }
18382         PyTuple_SetItem(result, 2, py_resume_handle);
18383         if (!W_ERROR_IS_OK(r->out.result)) {
18384                 PyErr_SetWERROR(r->out.result);
18385                 return NULL;
18386         }
18387
18388         return result;
18389 }
18390
18391 static bool pack_py_srvsvc_NetShareDelStart_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelStart *r)
18392 {
18393         PyObject *py_server_unc;
18394         PyObject *py_share;
18395         PyObject *py_reserved;
18396         const char *kwnames[] = {
18397                 "server_unc", "share", "reserved", NULL
18398         };
18399
18400         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelStart", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_reserved)) {
18401                 return false;
18402         }
18403
18404         if (py_server_unc == Py_None) {
18405                 r->in.server_unc = NULL;
18406         } else {
18407                 r->in.server_unc = NULL;
18408                 if (PyUnicode_Check(py_server_unc)) {
18409                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18410                 } else if (PyString_Check(py_server_unc)) {
18411                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18412                 } else {
18413                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18414                         return false;
18415                 }
18416         }
18417         if (PyUnicode_Check(py_share)) {
18418                 r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18419         } else if (PyString_Check(py_share)) {
18420                 r->in.share = PyString_AS_STRING(py_share);
18421         } else {
18422                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18423                 return false;
18424         }
18425         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
18426         r->in.reserved = PyInt_AsLong(py_reserved);
18427         return true;
18428 }
18429
18430 static PyObject *unpack_py_srvsvc_NetShareDelStart_args_out(struct srvsvc_NetShareDelStart *r)
18431 {
18432         PyObject *result;
18433         PyObject *py_hnd;
18434         if (r->out.hnd == NULL) {
18435                 py_hnd = Py_None;
18436                 Py_INCREF(py_hnd);
18437         } else {
18438                 py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
18439         }
18440         result = py_hnd;
18441         if (!W_ERROR_IS_OK(r->out.result)) {
18442                 PyErr_SetWERROR(r->out.result);
18443                 return NULL;
18444         }
18445
18446         return result;
18447 }
18448
18449 static bool pack_py_srvsvc_NetShareDelCommit_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelCommit *r)
18450 {
18451         PyObject *py_hnd;
18452         const char *kwnames[] = {
18453                 "hnd", NULL
18454         };
18455
18456         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetShareDelCommit", discard_const_p(char *, kwnames), &py_hnd)) {
18457                 return false;
18458         }
18459
18460         if (py_hnd == Py_None) {
18461                 r->in.hnd = NULL;
18462         } else {
18463                 r->in.hnd = NULL;
18464                 PY_CHECK_TYPE(policy_handle_Type, py_hnd, return false;);
18465                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_hnd)) == NULL) {
18466                         PyErr_NoMemory();
18467                         return false;
18468                 }
18469                 r->in.hnd = (struct policy_handle *)pytalloc_get_ptr(py_hnd);
18470         }
18471         return true;
18472 }
18473
18474 static PyObject *unpack_py_srvsvc_NetShareDelCommit_args_out(struct srvsvc_NetShareDelCommit *r)
18475 {
18476         PyObject *result;
18477         PyObject *py_hnd;
18478         if (r->out.hnd == NULL) {
18479                 py_hnd = Py_None;
18480                 Py_INCREF(py_hnd);
18481         } else {
18482                 py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
18483         }
18484         result = py_hnd;
18485         if (!W_ERROR_IS_OK(r->out.result)) {
18486                 PyErr_SetWERROR(r->out.result);
18487                 return NULL;
18488         }
18489
18490         return result;
18491 }
18492
18493 static bool pack_py_srvsvc_NetGetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetGetFileSecurity *r)
18494 {
18495         PyObject *py_server_unc;
18496         PyObject *py_share;
18497         PyObject *py_file;
18498         PyObject *py_securityinformation;
18499         const char *kwnames[] = {
18500                 "server_unc", "share", "file", "securityinformation", NULL
18501         };
18502
18503         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetGetFileSecurity", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_file, &py_securityinformation)) {
18504                 return false;
18505         }
18506
18507         if (py_server_unc == Py_None) {
18508                 r->in.server_unc = NULL;
18509         } else {
18510                 r->in.server_unc = NULL;
18511                 if (PyUnicode_Check(py_server_unc)) {
18512                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18513                 } else if (PyString_Check(py_server_unc)) {
18514                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18515                 } else {
18516                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18517                         return false;
18518                 }
18519         }
18520         if (py_share == Py_None) {
18521                 r->in.share = NULL;
18522         } else {
18523                 r->in.share = NULL;
18524                 if (PyUnicode_Check(py_share)) {
18525                         r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18526                 } else if (PyString_Check(py_share)) {
18527                         r->in.share = PyString_AS_STRING(py_share);
18528                 } else {
18529                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18530                         return false;
18531                 }
18532         }
18533         if (PyUnicode_Check(py_file)) {
18534                 r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
18535         } else if (PyString_Check(py_file)) {
18536                 r->in.file = PyString_AS_STRING(py_file);
18537         } else {
18538                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
18539                 return false;
18540         }
18541         if (PyLong_Check(py_securityinformation)) {
18542                 r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
18543         } else if (PyInt_Check(py_securityinformation)) {
18544                 r->in.securityinformation = PyInt_AsLong(py_securityinformation);
18545         } else {
18546                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
18547                   PyInt_Type.tp_name, PyLong_Type.tp_name);
18548                 return false;
18549         }
18550         return true;
18551 }
18552
18553 static PyObject *unpack_py_srvsvc_NetGetFileSecurity_args_out(struct srvsvc_NetGetFileSecurity *r)
18554 {
18555         PyObject *result;
18556         PyObject *py_sd_buf;
18557         if (*r->out.sd_buf == NULL) {
18558                 py_sd_buf = Py_None;
18559                 Py_INCREF(py_sd_buf);
18560         } else {
18561                 py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, *r->out.sd_buf, *r->out.sd_buf);
18562         }
18563         result = py_sd_buf;
18564         if (!W_ERROR_IS_OK(r->out.result)) {
18565                 PyErr_SetWERROR(r->out.result);
18566                 return NULL;
18567         }
18568
18569         return result;
18570 }
18571
18572 static bool pack_py_srvsvc_NetSetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetFileSecurity *r)
18573 {
18574         PyObject *py_server_unc;
18575         PyObject *py_share;
18576         PyObject *py_file;
18577         PyObject *py_securityinformation;
18578         PyObject *py_sd_buf;
18579         const char *kwnames[] = {
18580                 "server_unc", "share", "file", "securityinformation", "sd_buf", NULL
18581         };
18582
18583         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetSetFileSecurity", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_file, &py_securityinformation, &py_sd_buf)) {
18584                 return false;
18585         }
18586
18587         if (py_server_unc == Py_None) {
18588                 r->in.server_unc = NULL;
18589         } else {
18590                 r->in.server_unc = NULL;
18591                 if (PyUnicode_Check(py_server_unc)) {
18592                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18593                 } else if (PyString_Check(py_server_unc)) {
18594                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18595                 } else {
18596                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18597                         return false;
18598                 }
18599         }
18600         if (py_share == Py_None) {
18601                 r->in.share = NULL;
18602         } else {
18603                 r->in.share = NULL;
18604                 if (PyUnicode_Check(py_share)) {
18605                         r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18606                 } else if (PyString_Check(py_share)) {
18607                         r->in.share = PyString_AS_STRING(py_share);
18608                 } else {
18609                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18610                         return false;
18611                 }
18612         }
18613         if (PyUnicode_Check(py_file)) {
18614                 r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
18615         } else if (PyString_Check(py_file)) {
18616                 r->in.file = PyString_AS_STRING(py_file);
18617         } else {
18618                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
18619                 return false;
18620         }
18621         if (PyLong_Check(py_securityinformation)) {
18622                 r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
18623         } else if (PyInt_Check(py_securityinformation)) {
18624                 r->in.securityinformation = PyInt_AsLong(py_securityinformation);
18625         } else {
18626                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
18627                   PyInt_Type.tp_name, PyLong_Type.tp_name);
18628                 return false;
18629         }
18630         r->in.sd_buf = talloc_ptrtype(r, r->in.sd_buf);
18631         PY_CHECK_TYPE(sec_desc_buf_Type, py_sd_buf, return false;);
18632         if (talloc_reference(r, pytalloc_get_mem_ctx(py_sd_buf)) == NULL) {
18633                 PyErr_NoMemory();
18634                 return false;
18635         }
18636         r->in.sd_buf = (struct sec_desc_buf *)pytalloc_get_ptr(py_sd_buf);
18637         return true;
18638 }
18639
18640 static PyObject *unpack_py_srvsvc_NetSetFileSecurity_args_out(struct srvsvc_NetSetFileSecurity *r)
18641 {
18642         PyObject *result;
18643         result = Py_None;
18644         Py_INCREF(result);
18645         if (!W_ERROR_IS_OK(r->out.result)) {
18646                 PyErr_SetWERROR(r->out.result);
18647                 return NULL;
18648         }
18649
18650         return result;
18651 }
18652
18653 static bool pack_py_srvsvc_NetServerTransportAddEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerTransportAddEx *r)
18654 {
18655         PyObject *py_server_unc;
18656         PyObject *py_level;
18657         PyObject *py_info;
18658         const char *kwnames[] = {
18659                 "server_unc", "level", "info", NULL
18660         };
18661
18662         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetServerTransportAddEx", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
18663                 return false;
18664         }
18665
18666         if (py_server_unc == Py_None) {
18667                 r->in.server_unc = NULL;
18668         } else {
18669                 r->in.server_unc = NULL;
18670                 if (PyUnicode_Check(py_server_unc)) {
18671                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18672                 } else if (PyString_Check(py_server_unc)) {
18673                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18674                 } else {
18675                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18676                         return false;
18677                 }
18678         }
18679         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
18680         r->in.level = PyInt_AsLong(py_level);
18681         {
18682                 union srvsvc_NetTransportInfo *info_switch_0;
18683                 info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
18684                 if (info_switch_0 == NULL) {
18685                         return false;
18686                 }
18687                 r->in.info = *info_switch_0;
18688         }
18689         return true;
18690 }
18691
18692 static PyObject *unpack_py_srvsvc_NetServerTransportAddEx_args_out(struct srvsvc_NetServerTransportAddEx *r)
18693 {
18694         PyObject *result;
18695         result = Py_None;
18696         Py_INCREF(result);
18697         if (!W_ERROR_IS_OK(r->out.result)) {
18698                 PyErr_SetWERROR(r->out.result);
18699                 return NULL;
18700         }
18701
18702         return result;
18703 }
18704
18705 static bool pack_py_srvsvc_NetServerSetServiceBitsEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerSetServiceBitsEx *r)
18706 {
18707         PyObject *py_server_unc;
18708         PyObject *py_emulated_server_unc;
18709         PyObject *py_transport;
18710         PyObject *py_servicebitsofinterest;
18711         PyObject *py_servicebits;
18712         PyObject *py_updateimmediately;
18713         const char *kwnames[] = {
18714                 "server_unc", "emulated_server_unc", "transport", "servicebitsofinterest", "servicebits", "updateimmediately", NULL
18715         };
18716
18717         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:srvsvc_NetServerSetServiceBitsEx", discard_const_p(char *, kwnames), &py_server_unc, &py_emulated_server_unc, &py_transport, &py_servicebitsofinterest, &py_servicebits, &py_updateimmediately)) {
18718                 return false;
18719         }
18720
18721         if (py_server_unc == Py_None) {
18722                 r->in.server_unc = NULL;
18723         } else {
18724                 r->in.server_unc = NULL;
18725                 if (PyUnicode_Check(py_server_unc)) {
18726                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18727                 } else if (PyString_Check(py_server_unc)) {
18728                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18729                 } else {
18730                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18731                         return false;
18732                 }
18733         }
18734         if (py_emulated_server_unc == Py_None) {
18735                 r->in.emulated_server_unc = NULL;
18736         } else {
18737                 r->in.emulated_server_unc = NULL;
18738                 if (PyUnicode_Check(py_emulated_server_unc)) {
18739                         r->in.emulated_server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_emulated_server_unc, "utf-8", "ignore"));
18740                 } else if (PyString_Check(py_emulated_server_unc)) {
18741                         r->in.emulated_server_unc = PyString_AS_STRING(py_emulated_server_unc);
18742                 } else {
18743                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_emulated_server_unc)->tp_name);
18744                         return false;
18745                 }
18746         }
18747         if (py_transport == Py_None) {
18748                 r->in.transport = NULL;
18749         } else {
18750                 r->in.transport = NULL;
18751                 if (PyUnicode_Check(py_transport)) {
18752                         r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
18753                 } else if (PyString_Check(py_transport)) {
18754                         r->in.transport = PyString_AS_STRING(py_transport);
18755                 } else {
18756                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
18757                         return false;
18758                 }
18759         }
18760         PY_CHECK_TYPE(&PyInt_Type, py_servicebitsofinterest, return false;);
18761         r->in.servicebitsofinterest = PyInt_AsLong(py_servicebitsofinterest);
18762         PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
18763         r->in.servicebits = PyInt_AsLong(py_servicebits);
18764         PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
18765         r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
18766         return true;
18767 }
18768
18769 static PyObject *unpack_py_srvsvc_NetServerSetServiceBitsEx_args_out(struct srvsvc_NetServerSetServiceBitsEx *r)
18770 {
18771         PyObject *result;
18772         result = Py_None;
18773         Py_INCREF(result);
18774         if (!W_ERROR_IS_OK(r->out.result)) {
18775                 PyErr_SetWERROR(r->out.result);
18776                 return NULL;
18777         }
18778
18779         return result;
18780 }
18781
18782 const struct PyNdrRpcMethodDef py_ndr_srvsvc_methods[] = {
18783         { "NetCharDevEnum", "S.NetCharDevEnum(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevEnum_args_out, 0, &ndr_table_srvsvc },
18784         { "NetCharDevGetInfo", "S.NetCharDevGetInfo(server_unc, device_name, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevGetInfo_args_out, 1, &ndr_table_srvsvc },
18785         { "NetCharDevControl", "S.NetCharDevControl(server_unc, device_name, opcode) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevControl_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevControl_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevControl_args_out, 2, &ndr_table_srvsvc },
18786         { "NetCharDevQEnum", "S.NetCharDevQEnum(server_unc, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQEnum_args_out, 3, &ndr_table_srvsvc },
18787         { "NetCharDevQGetInfo", "S.NetCharDevQGetInfo(server_unc, queue_name, user, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQGetInfo_args_out, 4, &ndr_table_srvsvc },
18788         { "NetCharDevQSetInfo", "S.NetCharDevQSetInfo(server_unc, queue_name, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQSetInfo_args_out, 5, &ndr_table_srvsvc },
18789         { "NetCharDevQPurge", "S.NetCharDevQPurge(server_unc, queue_name) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQPurge_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQPurge_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQPurge_args_out, 6, &ndr_table_srvsvc },
18790         { "NetCharDevQPurgeSelf", "S.NetCharDevQPurgeSelf(server_unc, queue_name, computer_name) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetCharDevQPurgeSelf_r, (py_data_pack_fn)pack_py_srvsvc_NetCharDevQPurgeSelf_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetCharDevQPurgeSelf_args_out, 7, &ndr_table_srvsvc },
18791         { "NetConnEnum", "S.NetConnEnum(server_unc, path, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetConnEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetConnEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetConnEnum_args_out, 8, &ndr_table_srvsvc },
18792         { "NetFileEnum", "S.NetFileEnum(server_unc, path, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetFileEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileEnum_args_out, 9, &ndr_table_srvsvc },
18793         { "NetFileGetInfo", "S.NetFileGetInfo(server_unc, fid, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetFileGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileGetInfo_args_out, 10, &ndr_table_srvsvc },
18794         { "NetFileClose", "S.NetFileClose(server_unc, fid) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetFileClose_r, (py_data_pack_fn)pack_py_srvsvc_NetFileClose_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetFileClose_args_out, 11, &ndr_table_srvsvc },
18795         { "NetSessEnum", "S.NetSessEnum(server_unc, client, user, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSessEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetSessEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSessEnum_args_out, 12, &ndr_table_srvsvc },
18796         { "NetSessDel", "S.NetSessDel(server_unc, client, user) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSessDel_r, (py_data_pack_fn)pack_py_srvsvc_NetSessDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSessDel_args_out, 13, &ndr_table_srvsvc },
18797         { "NetShareAdd", "S.NetShareAdd(server_unc, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareAdd_r, (py_data_pack_fn)pack_py_srvsvc_NetShareAdd_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareAdd_args_out, 14, &ndr_table_srvsvc },
18798         { "NetShareEnumAll", "S.NetShareEnumAll(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareEnumAll_r, (py_data_pack_fn)pack_py_srvsvc_NetShareEnumAll_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareEnumAll_args_out, 15, &ndr_table_srvsvc },
18799         { "NetShareGetInfo", "S.NetShareGetInfo(server_unc, share_name, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetShareGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareGetInfo_args_out, 16, &ndr_table_srvsvc },
18800         { "NetShareSetInfo", "S.NetShareSetInfo(server_unc, share_name, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetShareSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareSetInfo_args_out, 17, &ndr_table_srvsvc },
18801         { "NetShareDel", "S.NetShareDel(server_unc, share_name, reserved) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDel_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDel_args_out, 18, &ndr_table_srvsvc },
18802         { "NetShareDelSticky", "S.NetShareDelSticky(server_unc, share_name, reserved) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelSticky_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelSticky_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelSticky_args_out, 19, &ndr_table_srvsvc },
18803         { "NetShareCheck", "S.NetShareCheck(server_unc, device_name) -> type", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareCheck_r, (py_data_pack_fn)pack_py_srvsvc_NetShareCheck_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareCheck_args_out, 20, &ndr_table_srvsvc },
18804         { "NetSrvGetInfo", "S.NetSrvGetInfo(server_unc, level) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSrvGetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetSrvGetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSrvGetInfo_args_out, 21, &ndr_table_srvsvc },
18805         { "NetSrvSetInfo", "S.NetSrvSetInfo(server_unc, level, info, parm_error) -> parm_error", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSrvSetInfo_r, (py_data_pack_fn)pack_py_srvsvc_NetSrvSetInfo_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSrvSetInfo_args_out, 22, &ndr_table_srvsvc },
18806         { "NetDiskEnum", "S.NetDiskEnum(server_unc, level, info, maxlen, resume_handle) -> (info, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetDiskEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetDiskEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetDiskEnum_args_out, 23, &ndr_table_srvsvc },
18807         { "NetServerStatisticsGet", "S.NetServerStatisticsGet(server_unc, service, level, options) -> stats", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerStatisticsGet_r, (py_data_pack_fn)pack_py_srvsvc_NetServerStatisticsGet_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerStatisticsGet_args_out, 24, &ndr_table_srvsvc },
18808         { "NetTransportAdd", "S.NetTransportAdd(server_unc, level, info) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportAdd_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportAdd_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportAdd_args_out, 25, &ndr_table_srvsvc },
18809         { "NetTransportEnum", "S.NetTransportEnum(server_unc, transports, max_buffer, resume_handle) -> (transports, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportEnum_args_out, 26, &ndr_table_srvsvc },
18810         { "NetTransportDel", "S.NetTransportDel(server_unc, level, info0) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetTransportDel_r, (py_data_pack_fn)pack_py_srvsvc_NetTransportDel_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetTransportDel_args_out, 27, &ndr_table_srvsvc },
18811         { "NetRemoteTOD", "S.NetRemoteTOD(server_unc) -> info", (py_dcerpc_call_fn)dcerpc_srvsvc_NetRemoteTOD_r, (py_data_pack_fn)pack_py_srvsvc_NetRemoteTOD_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetRemoteTOD_args_out, 28, &ndr_table_srvsvc },
18812         { "NetSetServiceBits", "S.NetSetServiceBits(server_unc, transport, servicebits, updateimmediately) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSetServiceBits_r, (py_data_pack_fn)pack_py_srvsvc_NetSetServiceBits_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSetServiceBits_args_out, 29, &ndr_table_srvsvc },
18813         { "NetPathType", "S.NetPathType(server_unc, path, pathflags) -> pathtype", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathType_r, (py_data_pack_fn)pack_py_srvsvc_NetPathType_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathType_args_out, 30, &ndr_table_srvsvc },
18814         { "NetPathCanonicalize", "S.NetPathCanonicalize(server_unc, path, maxbuf, prefix, pathtype, pathflags) -> (can_path, pathtype)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathCanonicalize_r, (py_data_pack_fn)pack_py_srvsvc_NetPathCanonicalize_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathCanonicalize_args_out, 31, &ndr_table_srvsvc },
18815         { "NetPathCompare", "S.NetPathCompare(server_unc, path1, path2, pathtype, pathflags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPathCompare_r, (py_data_pack_fn)pack_py_srvsvc_NetPathCompare_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPathCompare_args_out, 32, &ndr_table_srvsvc },
18816         { "NetNameValidate", "S.NetNameValidate(server_unc, name, name_type, flags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetNameValidate_r, (py_data_pack_fn)pack_py_srvsvc_NetNameValidate_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetNameValidate_args_out, 33, &ndr_table_srvsvc },
18817         { "NetPRNameCompare", "S.NetPRNameCompare(server_unc, name1, name2, name_type, flags) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetPRNameCompare_r, (py_data_pack_fn)pack_py_srvsvc_NetPRNameCompare_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetPRNameCompare_args_out, 35, &ndr_table_srvsvc },
18818         { "NetShareEnum", "S.NetShareEnum(server_unc, info_ctr, max_buffer, resume_handle) -> (info_ctr, totalentries, resume_handle)", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareEnum_r, (py_data_pack_fn)pack_py_srvsvc_NetShareEnum_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareEnum_args_out, 36, &ndr_table_srvsvc },
18819         { "NetShareDelStart", "S.NetShareDelStart(server_unc, share, reserved) -> hnd", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelStart_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelStart_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelStart_args_out, 37, &ndr_table_srvsvc },
18820         { "NetShareDelCommit", "S.NetShareDelCommit(hnd) -> hnd", (py_dcerpc_call_fn)dcerpc_srvsvc_NetShareDelCommit_r, (py_data_pack_fn)pack_py_srvsvc_NetShareDelCommit_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetShareDelCommit_args_out, 38, &ndr_table_srvsvc },
18821         { "NetGetFileSecurity", "S.NetGetFileSecurity(server_unc, share, file, securityinformation) -> sd_buf", (py_dcerpc_call_fn)dcerpc_srvsvc_NetGetFileSecurity_r, (py_data_pack_fn)pack_py_srvsvc_NetGetFileSecurity_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetGetFileSecurity_args_out, 39, &ndr_table_srvsvc },
18822         { "NetSetFileSecurity", "S.NetSetFileSecurity(server_unc, share, file, securityinformation, sd_buf) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetSetFileSecurity_r, (py_data_pack_fn)pack_py_srvsvc_NetSetFileSecurity_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetSetFileSecurity_args_out, 40, &ndr_table_srvsvc },
18823         { "NetServerTransportAddEx", "S.NetServerTransportAddEx(server_unc, level, info) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerTransportAddEx_r, (py_data_pack_fn)pack_py_srvsvc_NetServerTransportAddEx_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerTransportAddEx_args_out, 41, &ndr_table_srvsvc },
18824         { "NetServerSetServiceBitsEx", "S.NetServerSetServiceBitsEx(server_unc, emulated_server_unc, transport, servicebitsofinterest, servicebits, updateimmediately) -> None", (py_dcerpc_call_fn)dcerpc_srvsvc_NetServerSetServiceBitsEx_r, (py_data_pack_fn)pack_py_srvsvc_NetServerSetServiceBitsEx_args_in, (py_data_unpack_fn)unpack_py_srvsvc_NetServerSetServiceBitsEx_args_out, 42, &ndr_table_srvsvc },
18825         { NULL }
18826 };
18827
18828 static PyObject *interface_srvsvc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
18829 {
18830         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_srvsvc);
18831 }
18832
18833 #define PY_DOC_SRVSVC "Server Service"
18834 static PyTypeObject srvsvc_InterfaceType = {
18835         PyObject_HEAD_INIT(NULL) 0,
18836         .tp_name = "srvsvc.srvsvc",
18837         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
18838         .tp_doc = "srvsvc(binding, lp_ctx=None, credentials=None) -> connection\n"
18839 "\n"
18840 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
18841 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
18842 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_SRVSVC,
18843         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
18844         .tp_new = interface_srvsvc_new,
18845 };
18846
18847 static PyObject *syntax_srvsvc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
18848 {
18849         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_srvsvc.syntax_id);
18850 }
18851
18852 #define PY_DOC_SRVSVC_SYNTAX "Server Service"
18853 static PyTypeObject srvsvc_SyntaxType = {
18854         PyObject_HEAD_INIT(NULL) 0,
18855         .tp_name = "srvsvc.srvsvc",
18856         .tp_basicsize = sizeof(pytalloc_Object),
18857         .tp_doc = "abstract_syntax()\n"PY_DOC_SRVSVC_SYNTAX,
18858         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
18859         .tp_new = syntax_srvsvc_new,
18860 };
18861
18862 static PyMethodDef srvsvc_methods[] = {
18863         { NULL, NULL, 0, NULL }
18864 };
18865
18866 void initsrvsvc(void)
18867 {
18868         PyObject *m;
18869         PyObject *dep_samba_dcerpc_misc;
18870         PyObject *dep_samba_dcerpc_security;
18871         PyObject *dep_samba_dcerpc_svcctl;
18872         PyObject *dep_talloc;
18873         PyObject *dep_samba_dcerpc_base;
18874
18875         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
18876         if (dep_samba_dcerpc_misc == NULL)
18877                 return;
18878
18879         dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
18880         if (dep_samba_dcerpc_security == NULL)
18881                 return;
18882
18883         dep_samba_dcerpc_svcctl = PyImport_ImportModule("samba.dcerpc.svcctl");
18884         if (dep_samba_dcerpc_svcctl == NULL)
18885                 return;
18886
18887         dep_talloc = PyImport_ImportModule("talloc");
18888         if (dep_talloc == NULL)
18889                 return;
18890
18891         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
18892         if (dep_samba_dcerpc_base == NULL)
18893                 return;
18894
18895         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
18896         if (Object_Type == NULL)
18897                 return;
18898
18899         sec_desc_buf_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "sec_desc_buf");
18900         if (sec_desc_buf_Type == NULL)
18901                 return;
18902
18903         policy_handle_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "policy_handle");
18904         if (policy_handle_Type == NULL)
18905                 return;
18906
18907         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
18908         if (ClientConnection_Type == NULL)
18909                 return;
18910
18911         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
18912         if (ndr_syntax_id_Type == NULL)
18913                 return;
18914
18915         srvsvc_NetCharDevInfo0_Type.tp_base = Object_Type;
18916
18917         srvsvc_NetCharDevCtr0_Type.tp_base = Object_Type;
18918
18919         srvsvc_NetCharDevInfo1_Type.tp_base = Object_Type;
18920
18921         srvsvc_NetCharDevCtr1_Type.tp_base = Object_Type;
18922
18923         srvsvc_NetCharDevInfoCtr_Type.tp_base = Object_Type;
18924
18925         srvsvc_NetCharDevQInfo0_Type.tp_base = Object_Type;
18926
18927         srvsvc_NetCharDevQCtr0_Type.tp_base = Object_Type;
18928
18929         srvsvc_NetCharDevQInfo1_Type.tp_base = Object_Type;
18930
18931         srvsvc_NetCharDevQCtr1_Type.tp_base = Object_Type;
18932
18933         srvsvc_NetCharDevQInfoCtr_Type.tp_base = Object_Type;
18934
18935         srvsvc_NetConnInfo0_Type.tp_base = Object_Type;
18936
18937         srvsvc_NetConnCtr0_Type.tp_base = Object_Type;
18938
18939         srvsvc_NetConnInfo1_Type.tp_base = Object_Type;
18940
18941         srvsvc_NetConnCtr1_Type.tp_base = Object_Type;
18942
18943         srvsvc_NetConnInfoCtr_Type.tp_base = Object_Type;
18944
18945         srvsvc_NetFileInfo2_Type.tp_base = Object_Type;
18946
18947         srvsvc_NetFileCtr2_Type.tp_base = Object_Type;
18948
18949         srvsvc_NetFileInfo3_Type.tp_base = Object_Type;
18950
18951         srvsvc_NetFileCtr3_Type.tp_base = Object_Type;
18952
18953         srvsvc_NetFileInfoCtr_Type.tp_base = Object_Type;
18954
18955         srvsvc_NetSessInfo0_Type.tp_base = Object_Type;
18956
18957         srvsvc_NetSessCtr0_Type.tp_base = Object_Type;
18958
18959         srvsvc_NetSessInfo1_Type.tp_base = Object_Type;
18960
18961         srvsvc_NetSessCtr1_Type.tp_base = Object_Type;
18962
18963         srvsvc_NetSessInfo2_Type.tp_base = Object_Type;
18964
18965         srvsvc_NetSessCtr2_Type.tp_base = Object_Type;
18966
18967         srvsvc_NetSessInfo10_Type.tp_base = Object_Type;
18968
18969         srvsvc_NetSessCtr10_Type.tp_base = Object_Type;
18970
18971         srvsvc_NetSessInfo502_Type.tp_base = Object_Type;
18972
18973         srvsvc_NetSessCtr502_Type.tp_base = Object_Type;
18974
18975         srvsvc_NetSessInfoCtr_Type.tp_base = Object_Type;
18976
18977         srvsvc_NetShareInfo0_Type.tp_base = Object_Type;
18978
18979         srvsvc_NetShareCtr0_Type.tp_base = Object_Type;
18980
18981         srvsvc_NetShareInfo1_Type.tp_base = Object_Type;
18982
18983         srvsvc_NetShareCtr1_Type.tp_base = Object_Type;
18984
18985         srvsvc_NetShareInfo2_Type.tp_base = Object_Type;
18986
18987         srvsvc_NetShareCtr2_Type.tp_base = Object_Type;
18988
18989         srvsvc_NetShareInfo501_Type.tp_base = Object_Type;
18990
18991         srvsvc_NetShareCtr501_Type.tp_base = Object_Type;
18992
18993         srvsvc_NetShareInfo502_Type.tp_base = Object_Type;
18994
18995         srvsvc_NetShareCtr502_Type.tp_base = Object_Type;
18996
18997         srvsvc_NetShareInfo1004_Type.tp_base = Object_Type;
18998
18999         srvsvc_NetShareCtr1004_Type.tp_base = Object_Type;
19000
19001         srvsvc_NetShareInfo1005_Type.tp_base = Object_Type;
19002
19003         srvsvc_NetShareCtr1005_Type.tp_base = Object_Type;
19004
19005         srvsvc_NetShareInfo1006_Type.tp_base = Object_Type;
19006
19007         srvsvc_NetShareCtr1006_Type.tp_base = Object_Type;
19008
19009         srvsvc_NetShareInfo1007_Type.tp_base = Object_Type;
19010
19011         srvsvc_NetShareCtr1007_Type.tp_base = Object_Type;
19012
19013         srvsvc_NetShareCtr1501_Type.tp_base = Object_Type;
19014
19015         srvsvc_NetShareInfoCtr_Type.tp_base = Object_Type;
19016
19017         srvsvc_NetSrvInfo100_Type.tp_base = Object_Type;
19018
19019         srvsvc_NetSrvInfo101_Type.tp_base = Object_Type;
19020
19021         srvsvc_NetSrvInfo102_Type.tp_base = Object_Type;
19022
19023         srvsvc_NetSrvInfo402_Type.tp_base = Object_Type;
19024
19025         srvsvc_NetSrvInfo403_Type.tp_base = Object_Type;
19026
19027         srvsvc_NetSrvInfo502_Type.tp_base = Object_Type;
19028
19029         srvsvc_NetSrvInfo503_Type.tp_base = Object_Type;
19030
19031         srvsvc_NetSrvInfo599_Type.tp_base = Object_Type;
19032
19033         srvsvc_NetSrvInfo1005_Type.tp_base = Object_Type;
19034
19035         srvsvc_NetSrvInfo1010_Type.tp_base = Object_Type;
19036
19037         srvsvc_NetSrvInfo1016_Type.tp_base = Object_Type;
19038
19039         srvsvc_NetSrvInfo1017_Type.tp_base = Object_Type;
19040
19041         srvsvc_NetSrvInfo1018_Type.tp_base = Object_Type;
19042
19043         srvsvc_NetSrvInfo1107_Type.tp_base = Object_Type;
19044
19045         srvsvc_NetSrvInfo1501_Type.tp_base = Object_Type;
19046
19047         srvsvc_NetSrvInfo1502_Type.tp_base = Object_Type;
19048
19049         srvsvc_NetSrvInfo1503_Type.tp_base = Object_Type;
19050
19051         srvsvc_NetSrvInfo1506_Type.tp_base = Object_Type;
19052
19053         srvsvc_NetSrvInfo1509_Type.tp_base = Object_Type;
19054
19055         srvsvc_NetSrvInfo1510_Type.tp_base = Object_Type;
19056
19057         srvsvc_NetSrvInfo1511_Type.tp_base = Object_Type;
19058
19059         srvsvc_NetSrvInfo1512_Type.tp_base = Object_Type;
19060
19061         srvsvc_NetSrvInfo1513_Type.tp_base = Object_Type;
19062
19063         srvsvc_NetSrvInfo1514_Type.tp_base = Object_Type;
19064
19065         srvsvc_NetSrvInfo1515_Type.tp_base = Object_Type;
19066
19067         srvsvc_NetSrvInfo1516_Type.tp_base = Object_Type;
19068
19069         srvsvc_NetSrvInfo1518_Type.tp_base = Object_Type;
19070
19071         srvsvc_NetSrvInfo1520_Type.tp_base = Object_Type;
19072
19073         srvsvc_NetSrvInfo1521_Type.tp_base = Object_Type;
19074
19075         srvsvc_NetSrvInfo1522_Type.tp_base = Object_Type;
19076
19077         srvsvc_NetSrvInfo1523_Type.tp_base = Object_Type;
19078
19079         srvsvc_NetSrvInfo1524_Type.tp_base = Object_Type;
19080
19081         srvsvc_NetSrvInfo1525_Type.tp_base = Object_Type;
19082
19083         srvsvc_NetSrvInfo1528_Type.tp_base = Object_Type;
19084
19085         srvsvc_NetSrvInfo1529_Type.tp_base = Object_Type;
19086
19087         srvsvc_NetSrvInfo1530_Type.tp_base = Object_Type;
19088
19089         srvsvc_NetSrvInfo1533_Type.tp_base = Object_Type;
19090
19091         srvsvc_NetSrvInfo1534_Type.tp_base = Object_Type;
19092
19093         srvsvc_NetSrvInfo1535_Type.tp_base = Object_Type;
19094
19095         srvsvc_NetSrvInfo1536_Type.tp_base = Object_Type;
19096
19097         srvsvc_NetSrvInfo1537_Type.tp_base = Object_Type;
19098
19099         srvsvc_NetSrvInfo1538_Type.tp_base = Object_Type;
19100
19101         srvsvc_NetSrvInfo1539_Type.tp_base = Object_Type;
19102
19103         srvsvc_NetSrvInfo1540_Type.tp_base = Object_Type;
19104
19105         srvsvc_NetSrvInfo1541_Type.tp_base = Object_Type;
19106
19107         srvsvc_NetSrvInfo1542_Type.tp_base = Object_Type;
19108
19109         srvsvc_NetSrvInfo1543_Type.tp_base = Object_Type;
19110
19111         srvsvc_NetSrvInfo1544_Type.tp_base = Object_Type;
19112
19113         srvsvc_NetSrvInfo1545_Type.tp_base = Object_Type;
19114
19115         srvsvc_NetSrvInfo1546_Type.tp_base = Object_Type;
19116
19117         srvsvc_NetSrvInfo1547_Type.tp_base = Object_Type;
19118
19119         srvsvc_NetSrvInfo1548_Type.tp_base = Object_Type;
19120
19121         srvsvc_NetSrvInfo1549_Type.tp_base = Object_Type;
19122
19123         srvsvc_NetSrvInfo1550_Type.tp_base = Object_Type;
19124
19125         srvsvc_NetSrvInfo1552_Type.tp_base = Object_Type;
19126
19127         srvsvc_NetSrvInfo1553_Type.tp_base = Object_Type;
19128
19129         srvsvc_NetSrvInfo1554_Type.tp_base = Object_Type;
19130
19131         srvsvc_NetSrvInfo1555_Type.tp_base = Object_Type;
19132
19133         srvsvc_NetSrvInfo1556_Type.tp_base = Object_Type;
19134
19135         srvsvc_NetDiskInfo0_Type.tp_base = Object_Type;
19136
19137         srvsvc_NetDiskInfo_Type.tp_base = Object_Type;
19138
19139         srvsvc_Statistics_Type.tp_base = Object_Type;
19140
19141         srvsvc_NetTransportInfo0_Type.tp_base = Object_Type;
19142
19143         srvsvc_NetTransportCtr0_Type.tp_base = Object_Type;
19144
19145         srvsvc_NetTransportInfo1_Type.tp_base = Object_Type;
19146
19147         srvsvc_NetTransportCtr1_Type.tp_base = Object_Type;
19148
19149         srvsvc_NetTransportInfo2_Type.tp_base = Object_Type;
19150
19151         srvsvc_NetTransportCtr2_Type.tp_base = Object_Type;
19152
19153         srvsvc_NetTransportInfo3_Type.tp_base = Object_Type;
19154
19155         srvsvc_NetTransportCtr3_Type.tp_base = Object_Type;
19156
19157         srvsvc_NetTransportInfoCtr_Type.tp_base = Object_Type;
19158
19159         srvsvc_NetRemoteTODInfo_Type.tp_base = Object_Type;
19160
19161         srvsvc_InterfaceType.tp_base = ClientConnection_Type;
19162
19163         srvsvc_SyntaxType.tp_base = ndr_syntax_id_Type;
19164
19165         if (PyType_Ready(&srvsvc_NetCharDevInfo0_Type) < 0)
19166                 return;
19167         if (PyType_Ready(&srvsvc_NetCharDevCtr0_Type) < 0)
19168                 return;
19169         if (PyType_Ready(&srvsvc_NetCharDevInfo1_Type) < 0)
19170                 return;
19171         if (PyType_Ready(&srvsvc_NetCharDevCtr1_Type) < 0)
19172                 return;
19173         if (PyType_Ready(&srvsvc_NetCharDevInfoCtr_Type) < 0)
19174                 return;
19175         if (PyType_Ready(&srvsvc_NetCharDevQInfo0_Type) < 0)
19176                 return;
19177         if (PyType_Ready(&srvsvc_NetCharDevQCtr0_Type) < 0)
19178                 return;
19179         if (PyType_Ready(&srvsvc_NetCharDevQInfo1_Type) < 0)
19180                 return;
19181         if (PyType_Ready(&srvsvc_NetCharDevQCtr1_Type) < 0)
19182                 return;
19183         if (PyType_Ready(&srvsvc_NetCharDevQInfoCtr_Type) < 0)
19184                 return;
19185         if (PyType_Ready(&srvsvc_NetConnInfo0_Type) < 0)
19186                 return;
19187         if (PyType_Ready(&srvsvc_NetConnCtr0_Type) < 0)
19188                 return;
19189         if (PyType_Ready(&srvsvc_NetConnInfo1_Type) < 0)
19190                 return;
19191         if (PyType_Ready(&srvsvc_NetConnCtr1_Type) < 0)
19192                 return;
19193         if (PyType_Ready(&srvsvc_NetConnInfoCtr_Type) < 0)
19194                 return;
19195         if (PyType_Ready(&srvsvc_NetFileInfo2_Type) < 0)
19196                 return;
19197         if (PyType_Ready(&srvsvc_NetFileCtr2_Type) < 0)
19198                 return;
19199         if (PyType_Ready(&srvsvc_NetFileInfo3_Type) < 0)
19200                 return;
19201         if (PyType_Ready(&srvsvc_NetFileCtr3_Type) < 0)
19202                 return;
19203         if (PyType_Ready(&srvsvc_NetFileInfoCtr_Type) < 0)
19204                 return;
19205         if (PyType_Ready(&srvsvc_NetSessInfo0_Type) < 0)
19206                 return;
19207         if (PyType_Ready(&srvsvc_NetSessCtr0_Type) < 0)
19208                 return;
19209         if (PyType_Ready(&srvsvc_NetSessInfo1_Type) < 0)
19210                 return;
19211         if (PyType_Ready(&srvsvc_NetSessCtr1_Type) < 0)
19212                 return;
19213         if (PyType_Ready(&srvsvc_NetSessInfo2_Type) < 0)
19214                 return;
19215         if (PyType_Ready(&srvsvc_NetSessCtr2_Type) < 0)
19216                 return;
19217         if (PyType_Ready(&srvsvc_NetSessInfo10_Type) < 0)
19218                 return;
19219         if (PyType_Ready(&srvsvc_NetSessCtr10_Type) < 0)
19220                 return;
19221         if (PyType_Ready(&srvsvc_NetSessInfo502_Type) < 0)
19222                 return;
19223         if (PyType_Ready(&srvsvc_NetSessCtr502_Type) < 0)
19224                 return;
19225         if (PyType_Ready(&srvsvc_NetSessInfoCtr_Type) < 0)
19226                 return;
19227         if (PyType_Ready(&srvsvc_NetShareInfo0_Type) < 0)
19228                 return;
19229         if (PyType_Ready(&srvsvc_NetShareCtr0_Type) < 0)
19230                 return;
19231         if (PyType_Ready(&srvsvc_NetShareInfo1_Type) < 0)
19232                 return;
19233         if (PyType_Ready(&srvsvc_NetShareCtr1_Type) < 0)
19234                 return;
19235         if (PyType_Ready(&srvsvc_NetShareInfo2_Type) < 0)
19236                 return;
19237         if (PyType_Ready(&srvsvc_NetShareCtr2_Type) < 0)
19238                 return;
19239         if (PyType_Ready(&srvsvc_NetShareInfo501_Type) < 0)
19240                 return;
19241         if (PyType_Ready(&srvsvc_NetShareCtr501_Type) < 0)
19242                 return;
19243         if (PyType_Ready(&srvsvc_NetShareInfo502_Type) < 0)
19244                 return;
19245         if (PyType_Ready(&srvsvc_NetShareCtr502_Type) < 0)
19246                 return;
19247         if (PyType_Ready(&srvsvc_NetShareInfo1004_Type) < 0)
19248                 return;
19249         if (PyType_Ready(&srvsvc_NetShareCtr1004_Type) < 0)
19250                 return;
19251         if (PyType_Ready(&srvsvc_NetShareInfo1005_Type) < 0)
19252                 return;
19253         if (PyType_Ready(&srvsvc_NetShareCtr1005_Type) < 0)
19254                 return;
19255         if (PyType_Ready(&srvsvc_NetShareInfo1006_Type) < 0)
19256                 return;
19257         if (PyType_Ready(&srvsvc_NetShareCtr1006_Type) < 0)
19258                 return;
19259         if (PyType_Ready(&srvsvc_NetShareInfo1007_Type) < 0)
19260                 return;
19261         if (PyType_Ready(&srvsvc_NetShareCtr1007_Type) < 0)
19262                 return;
19263         if (PyType_Ready(&srvsvc_NetShareCtr1501_Type) < 0)
19264                 return;
19265         if (PyType_Ready(&srvsvc_NetShareInfoCtr_Type) < 0)
19266                 return;
19267         if (PyType_Ready(&srvsvc_NetSrvInfo100_Type) < 0)
19268                 return;
19269         if (PyType_Ready(&srvsvc_NetSrvInfo101_Type) < 0)
19270                 return;
19271         if (PyType_Ready(&srvsvc_NetSrvInfo102_Type) < 0)
19272                 return;
19273         if (PyType_Ready(&srvsvc_NetSrvInfo402_Type) < 0)
19274                 return;
19275         if (PyType_Ready(&srvsvc_NetSrvInfo403_Type) < 0)
19276                 return;
19277         if (PyType_Ready(&srvsvc_NetSrvInfo502_Type) < 0)
19278                 return;
19279         if (PyType_Ready(&srvsvc_NetSrvInfo503_Type) < 0)
19280                 return;
19281         if (PyType_Ready(&srvsvc_NetSrvInfo599_Type) < 0)
19282                 return;
19283         if (PyType_Ready(&srvsvc_NetSrvInfo1005_Type) < 0)
19284                 return;
19285         if (PyType_Ready(&srvsvc_NetSrvInfo1010_Type) < 0)
19286                 return;
19287         if (PyType_Ready(&srvsvc_NetSrvInfo1016_Type) < 0)
19288                 return;
19289         if (PyType_Ready(&srvsvc_NetSrvInfo1017_Type) < 0)
19290                 return;
19291         if (PyType_Ready(&srvsvc_NetSrvInfo1018_Type) < 0)
19292                 return;
19293         if (PyType_Ready(&srvsvc_NetSrvInfo1107_Type) < 0)
19294                 return;
19295         if (PyType_Ready(&srvsvc_NetSrvInfo1501_Type) < 0)
19296                 return;
19297         if (PyType_Ready(&srvsvc_NetSrvInfo1502_Type) < 0)
19298                 return;
19299         if (PyType_Ready(&srvsvc_NetSrvInfo1503_Type) < 0)
19300                 return;
19301         if (PyType_Ready(&srvsvc_NetSrvInfo1506_Type) < 0)
19302                 return;
19303         if (PyType_Ready(&srvsvc_NetSrvInfo1509_Type) < 0)
19304                 return;
19305         if (PyType_Ready(&srvsvc_NetSrvInfo1510_Type) < 0)
19306                 return;
19307         if (PyType_Ready(&srvsvc_NetSrvInfo1511_Type) < 0)
19308                 return;
19309         if (PyType_Ready(&srvsvc_NetSrvInfo1512_Type) < 0)
19310                 return;
19311         if (PyType_Ready(&srvsvc_NetSrvInfo1513_Type) < 0)
19312                 return;
19313         if (PyType_Ready(&srvsvc_NetSrvInfo1514_Type) < 0)
19314                 return;
19315         if (PyType_Ready(&srvsvc_NetSrvInfo1515_Type) < 0)
19316                 return;
19317         if (PyType_Ready(&srvsvc_NetSrvInfo1516_Type) < 0)
19318                 return;
19319         if (PyType_Ready(&srvsvc_NetSrvInfo1518_Type) < 0)
19320                 return;
19321         if (PyType_Ready(&srvsvc_NetSrvInfo1520_Type) < 0)
19322                 return;
19323         if (PyType_Ready(&srvsvc_NetSrvInfo1521_Type) < 0)
19324                 return;
19325         if (PyType_Ready(&srvsvc_NetSrvInfo1522_Type) < 0)
19326                 return;
19327         if (PyType_Ready(&srvsvc_NetSrvInfo1523_Type) < 0)
19328                 return;
19329         if (PyType_Ready(&srvsvc_NetSrvInfo1524_Type) < 0)
19330                 return;
19331         if (PyType_Ready(&srvsvc_NetSrvInfo1525_Type) < 0)
19332                 return;
19333         if (PyType_Ready(&srvsvc_NetSrvInfo1528_Type) < 0)
19334                 return;
19335         if (PyType_Ready(&srvsvc_NetSrvInfo1529_Type) < 0)
19336                 return;
19337         if (PyType_Ready(&srvsvc_NetSrvInfo1530_Type) < 0)
19338                 return;
19339         if (PyType_Ready(&srvsvc_NetSrvInfo1533_Type) < 0)
19340                 return;
19341         if (PyType_Ready(&srvsvc_NetSrvInfo1534_Type) < 0)
19342                 return;
19343         if (PyType_Ready(&srvsvc_NetSrvInfo1535_Type) < 0)
19344                 return;
19345         if (PyType_Ready(&srvsvc_NetSrvInfo1536_Type) < 0)
19346                 return;
19347         if (PyType_Ready(&srvsvc_NetSrvInfo1537_Type) < 0)
19348                 return;
19349         if (PyType_Ready(&srvsvc_NetSrvInfo1538_Type) < 0)
19350                 return;
19351         if (PyType_Ready(&srvsvc_NetSrvInfo1539_Type) < 0)
19352                 return;
19353         if (PyType_Ready(&srvsvc_NetSrvInfo1540_Type) < 0)
19354                 return;
19355         if (PyType_Ready(&srvsvc_NetSrvInfo1541_Type) < 0)
19356                 return;
19357         if (PyType_Ready(&srvsvc_NetSrvInfo1542_Type) < 0)
19358                 return;
19359         if (PyType_Ready(&srvsvc_NetSrvInfo1543_Type) < 0)
19360                 return;
19361         if (PyType_Ready(&srvsvc_NetSrvInfo1544_Type) < 0)
19362                 return;
19363         if (PyType_Ready(&srvsvc_NetSrvInfo1545_Type) < 0)
19364                 return;
19365         if (PyType_Ready(&srvsvc_NetSrvInfo1546_Type) < 0)
19366                 return;
19367         if (PyType_Ready(&srvsvc_NetSrvInfo1547_Type) < 0)
19368                 return;
19369         if (PyType_Ready(&srvsvc_NetSrvInfo1548_Type) < 0)
19370                 return;
19371         if (PyType_Ready(&srvsvc_NetSrvInfo1549_Type) < 0)
19372                 return;
19373         if (PyType_Ready(&srvsvc_NetSrvInfo1550_Type) < 0)
19374                 return;
19375         if (PyType_Ready(&srvsvc_NetSrvInfo1552_Type) < 0)
19376                 return;
19377         if (PyType_Ready(&srvsvc_NetSrvInfo1553_Type) < 0)
19378                 return;
19379         if (PyType_Ready(&srvsvc_NetSrvInfo1554_Type) < 0)
19380                 return;
19381         if (PyType_Ready(&srvsvc_NetSrvInfo1555_Type) < 0)
19382                 return;
19383         if (PyType_Ready(&srvsvc_NetSrvInfo1556_Type) < 0)
19384                 return;
19385         if (PyType_Ready(&srvsvc_NetDiskInfo0_Type) < 0)
19386                 return;
19387         if (PyType_Ready(&srvsvc_NetDiskInfo_Type) < 0)
19388                 return;
19389         if (PyType_Ready(&srvsvc_Statistics_Type) < 0)
19390                 return;
19391         if (PyType_Ready(&srvsvc_NetTransportInfo0_Type) < 0)
19392                 return;
19393         if (PyType_Ready(&srvsvc_NetTransportCtr0_Type) < 0)
19394                 return;
19395         if (PyType_Ready(&srvsvc_NetTransportInfo1_Type) < 0)
19396                 return;
19397         if (PyType_Ready(&srvsvc_NetTransportCtr1_Type) < 0)
19398                 return;
19399         if (PyType_Ready(&srvsvc_NetTransportInfo2_Type) < 0)
19400                 return;
19401         if (PyType_Ready(&srvsvc_NetTransportCtr2_Type) < 0)
19402                 return;
19403         if (PyType_Ready(&srvsvc_NetTransportInfo3_Type) < 0)
19404                 return;
19405         if (PyType_Ready(&srvsvc_NetTransportCtr3_Type) < 0)
19406                 return;
19407         if (PyType_Ready(&srvsvc_NetTransportInfoCtr_Type) < 0)
19408                 return;
19409         if (PyType_Ready(&srvsvc_NetRemoteTODInfo_Type) < 0)
19410                 return;
19411         if (PyType_Ready(&srvsvc_InterfaceType) < 0)
19412                 return;
19413         if (PyType_Ready(&srvsvc_SyntaxType) < 0)
19414                 return;
19415         if (!PyInterface_AddNdrRpcMethods(&srvsvc_InterfaceType, py_ndr_srvsvc_methods))
19416                 return;
19417
19418 #ifdef PY_NETCHARDEVINFO0_PATCH
19419         PY_NETCHARDEVINFO0_PATCH(&srvsvc_NetCharDevInfo0_Type);
19420 #endif
19421 #ifdef PY_NETCHARDEVCTR0_PATCH
19422         PY_NETCHARDEVCTR0_PATCH(&srvsvc_NetCharDevCtr0_Type);
19423 #endif
19424 #ifdef PY_NETCHARDEVINFO1_PATCH
19425         PY_NETCHARDEVINFO1_PATCH(&srvsvc_NetCharDevInfo1_Type);
19426 #endif
19427 #ifdef PY_NETCHARDEVCTR1_PATCH
19428         PY_NETCHARDEVCTR1_PATCH(&srvsvc_NetCharDevCtr1_Type);
19429 #endif
19430 #ifdef PY_NETCHARDEVINFOCTR_PATCH
19431         PY_NETCHARDEVINFOCTR_PATCH(&srvsvc_NetCharDevInfoCtr_Type);
19432 #endif
19433 #ifdef PY_NETCHARDEVQINFO0_PATCH
19434         PY_NETCHARDEVQINFO0_PATCH(&srvsvc_NetCharDevQInfo0_Type);
19435 #endif
19436 #ifdef PY_NETCHARDEVQCTR0_PATCH
19437         PY_NETCHARDEVQCTR0_PATCH(&srvsvc_NetCharDevQCtr0_Type);
19438 #endif
19439 #ifdef PY_NETCHARDEVQINFO1_PATCH
19440         PY_NETCHARDEVQINFO1_PATCH(&srvsvc_NetCharDevQInfo1_Type);
19441 #endif
19442 #ifdef PY_NETCHARDEVQCTR1_PATCH
19443         PY_NETCHARDEVQCTR1_PATCH(&srvsvc_NetCharDevQCtr1_Type);
19444 #endif
19445 #ifdef PY_NETCHARDEVQINFOCTR_PATCH
19446         PY_NETCHARDEVQINFOCTR_PATCH(&srvsvc_NetCharDevQInfoCtr_Type);
19447 #endif
19448 #ifdef PY_NETCONNINFO0_PATCH
19449         PY_NETCONNINFO0_PATCH(&srvsvc_NetConnInfo0_Type);
19450 #endif
19451 #ifdef PY_NETCONNCTR0_PATCH
19452         PY_NETCONNCTR0_PATCH(&srvsvc_NetConnCtr0_Type);
19453 #endif
19454 #ifdef PY_NETCONNINFO1_PATCH
19455         PY_NETCONNINFO1_PATCH(&srvsvc_NetConnInfo1_Type);
19456 #endif
19457 #ifdef PY_NETCONNCTR1_PATCH
19458         PY_NETCONNCTR1_PATCH(&srvsvc_NetConnCtr1_Type);
19459 #endif
19460 #ifdef PY_NETCONNINFOCTR_PATCH
19461         PY_NETCONNINFOCTR_PATCH(&srvsvc_NetConnInfoCtr_Type);
19462 #endif
19463 #ifdef PY_NETFILEINFO2_PATCH
19464         PY_NETFILEINFO2_PATCH(&srvsvc_NetFileInfo2_Type);
19465 #endif
19466 #ifdef PY_NETFILECTR2_PATCH
19467         PY_NETFILECTR2_PATCH(&srvsvc_NetFileCtr2_Type);
19468 #endif
19469 #ifdef PY_NETFILEINFO3_PATCH
19470         PY_NETFILEINFO3_PATCH(&srvsvc_NetFileInfo3_Type);
19471 #endif
19472 #ifdef PY_NETFILECTR3_PATCH
19473         PY_NETFILECTR3_PATCH(&srvsvc_NetFileCtr3_Type);
19474 #endif
19475 #ifdef PY_NETFILEINFOCTR_PATCH
19476         PY_NETFILEINFOCTR_PATCH(&srvsvc_NetFileInfoCtr_Type);
19477 #endif
19478 #ifdef PY_NETSESSINFO0_PATCH
19479         PY_NETSESSINFO0_PATCH(&srvsvc_NetSessInfo0_Type);
19480 #endif
19481 #ifdef PY_NETSESSCTR0_PATCH
19482         PY_NETSESSCTR0_PATCH(&srvsvc_NetSessCtr0_Type);
19483 #endif
19484 #ifdef PY_NETSESSINFO1_PATCH
19485         PY_NETSESSINFO1_PATCH(&srvsvc_NetSessInfo1_Type);
19486 #endif
19487 #ifdef PY_NETSESSCTR1_PATCH
19488         PY_NETSESSCTR1_PATCH(&srvsvc_NetSessCtr1_Type);
19489 #endif
19490 #ifdef PY_NETSESSINFO2_PATCH
19491         PY_NETSESSINFO2_PATCH(&srvsvc_NetSessInfo2_Type);
19492 #endif
19493 #ifdef PY_NETSESSCTR2_PATCH
19494         PY_NETSESSCTR2_PATCH(&srvsvc_NetSessCtr2_Type);
19495 #endif
19496 #ifdef PY_NETSESSINFO10_PATCH
19497         PY_NETSESSINFO10_PATCH(&srvsvc_NetSessInfo10_Type);
19498 #endif
19499 #ifdef PY_NETSESSCTR10_PATCH
19500         PY_NETSESSCTR10_PATCH(&srvsvc_NetSessCtr10_Type);
19501 #endif
19502 #ifdef PY_NETSESSINFO502_PATCH
19503         PY_NETSESSINFO502_PATCH(&srvsvc_NetSessInfo502_Type);
19504 #endif
19505 #ifdef PY_NETSESSCTR502_PATCH
19506         PY_NETSESSCTR502_PATCH(&srvsvc_NetSessCtr502_Type);
19507 #endif
19508 #ifdef PY_NETSESSINFOCTR_PATCH
19509         PY_NETSESSINFOCTR_PATCH(&srvsvc_NetSessInfoCtr_Type);
19510 #endif
19511 #ifdef PY_NETSHAREINFO0_PATCH
19512         PY_NETSHAREINFO0_PATCH(&srvsvc_NetShareInfo0_Type);
19513 #endif
19514 #ifdef PY_NETSHARECTR0_PATCH
19515         PY_NETSHARECTR0_PATCH(&srvsvc_NetShareCtr0_Type);
19516 #endif
19517 #ifdef PY_NETSHAREINFO1_PATCH
19518         PY_NETSHAREINFO1_PATCH(&srvsvc_NetShareInfo1_Type);
19519 #endif
19520 #ifdef PY_NETSHARECTR1_PATCH
19521         PY_NETSHARECTR1_PATCH(&srvsvc_NetShareCtr1_Type);
19522 #endif
19523 #ifdef PY_NETSHAREINFO2_PATCH
19524         PY_NETSHAREINFO2_PATCH(&srvsvc_NetShareInfo2_Type);
19525 #endif
19526 #ifdef PY_NETSHARECTR2_PATCH
19527         PY_NETSHARECTR2_PATCH(&srvsvc_NetShareCtr2_Type);
19528 #endif
19529 #ifdef PY_NETSHAREINFO501_PATCH
19530         PY_NETSHAREINFO501_PATCH(&srvsvc_NetShareInfo501_Type);
19531 #endif
19532 #ifdef PY_NETSHARECTR501_PATCH
19533         PY_NETSHARECTR501_PATCH(&srvsvc_NetShareCtr501_Type);
19534 #endif
19535 #ifdef PY_NETSHAREINFO502_PATCH
19536         PY_NETSHAREINFO502_PATCH(&srvsvc_NetShareInfo502_Type);
19537 #endif
19538 #ifdef PY_NETSHARECTR502_PATCH
19539         PY_NETSHARECTR502_PATCH(&srvsvc_NetShareCtr502_Type);
19540 #endif
19541 #ifdef PY_NETSHAREINFO1004_PATCH
19542         PY_NETSHAREINFO1004_PATCH(&srvsvc_NetShareInfo1004_Type);
19543 #endif
19544 #ifdef PY_NETSHARECTR1004_PATCH
19545         PY_NETSHARECTR1004_PATCH(&srvsvc_NetShareCtr1004_Type);
19546 #endif
19547 #ifdef PY_NETSHAREINFO1005_PATCH
19548         PY_NETSHAREINFO1005_PATCH(&srvsvc_NetShareInfo1005_Type);
19549 #endif
19550 #ifdef PY_NETSHARECTR1005_PATCH
19551         PY_NETSHARECTR1005_PATCH(&srvsvc_NetShareCtr1005_Type);
19552 #endif
19553 #ifdef PY_NETSHAREINFO1006_PATCH
19554         PY_NETSHAREINFO1006_PATCH(&srvsvc_NetShareInfo1006_Type);
19555 #endif
19556 #ifdef PY_NETSHARECTR1006_PATCH
19557         PY_NETSHARECTR1006_PATCH(&srvsvc_NetShareCtr1006_Type);
19558 #endif
19559 #ifdef PY_NETSHAREINFO1007_PATCH
19560         PY_NETSHAREINFO1007_PATCH(&srvsvc_NetShareInfo1007_Type);
19561 #endif
19562 #ifdef PY_NETSHARECTR1007_PATCH
19563         PY_NETSHARECTR1007_PATCH(&srvsvc_NetShareCtr1007_Type);
19564 #endif
19565 #ifdef PY_NETSHARECTR1501_PATCH
19566         PY_NETSHARECTR1501_PATCH(&srvsvc_NetShareCtr1501_Type);
19567 #endif
19568 #ifdef PY_NETSHAREINFOCTR_PATCH
19569         PY_NETSHAREINFOCTR_PATCH(&srvsvc_NetShareInfoCtr_Type);
19570 #endif
19571 #ifdef PY_NETSRVINFO100_PATCH
19572         PY_NETSRVINFO100_PATCH(&srvsvc_NetSrvInfo100_Type);
19573 #endif
19574 #ifdef PY_NETSRVINFO101_PATCH
19575         PY_NETSRVINFO101_PATCH(&srvsvc_NetSrvInfo101_Type);
19576 #endif
19577 #ifdef PY_NETSRVINFO102_PATCH
19578         PY_NETSRVINFO102_PATCH(&srvsvc_NetSrvInfo102_Type);
19579 #endif
19580 #ifdef PY_NETSRVINFO402_PATCH
19581         PY_NETSRVINFO402_PATCH(&srvsvc_NetSrvInfo402_Type);
19582 #endif
19583 #ifdef PY_NETSRVINFO403_PATCH
19584         PY_NETSRVINFO403_PATCH(&srvsvc_NetSrvInfo403_Type);
19585 #endif
19586 #ifdef PY_NETSRVINFO502_PATCH
19587         PY_NETSRVINFO502_PATCH(&srvsvc_NetSrvInfo502_Type);
19588 #endif
19589 #ifdef PY_NETSRVINFO503_PATCH
19590         PY_NETSRVINFO503_PATCH(&srvsvc_NetSrvInfo503_Type);
19591 #endif
19592 #ifdef PY_NETSRVINFO599_PATCH
19593         PY_NETSRVINFO599_PATCH(&srvsvc_NetSrvInfo599_Type);
19594 #endif
19595 #ifdef PY_NETSRVINFO1005_PATCH
19596         PY_NETSRVINFO1005_PATCH(&srvsvc_NetSrvInfo1005_Type);
19597 #endif
19598 #ifdef PY_NETSRVINFO1010_PATCH
19599         PY_NETSRVINFO1010_PATCH(&srvsvc_NetSrvInfo1010_Type);
19600 #endif
19601 #ifdef PY_NETSRVINFO1016_PATCH
19602         PY_NETSRVINFO1016_PATCH(&srvsvc_NetSrvInfo1016_Type);
19603 #endif
19604 #ifdef PY_NETSRVINFO1017_PATCH
19605         PY_NETSRVINFO1017_PATCH(&srvsvc_NetSrvInfo1017_Type);
19606 #endif
19607 #ifdef PY_NETSRVINFO1018_PATCH
19608         PY_NETSRVINFO1018_PATCH(&srvsvc_NetSrvInfo1018_Type);
19609 #endif
19610 #ifdef PY_NETSRVINFO1107_PATCH
19611         PY_NETSRVINFO1107_PATCH(&srvsvc_NetSrvInfo1107_Type);
19612 #endif
19613 #ifdef PY_NETSRVINFO1501_PATCH
19614         PY_NETSRVINFO1501_PATCH(&srvsvc_NetSrvInfo1501_Type);
19615 #endif
19616 #ifdef PY_NETSRVINFO1502_PATCH
19617         PY_NETSRVINFO1502_PATCH(&srvsvc_NetSrvInfo1502_Type);
19618 #endif
19619 #ifdef PY_NETSRVINFO1503_PATCH
19620         PY_NETSRVINFO1503_PATCH(&srvsvc_NetSrvInfo1503_Type);
19621 #endif
19622 #ifdef PY_NETSRVINFO1506_PATCH
19623         PY_NETSRVINFO1506_PATCH(&srvsvc_NetSrvInfo1506_Type);
19624 #endif
19625 #ifdef PY_NETSRVINFO1509_PATCH
19626         PY_NETSRVINFO1509_PATCH(&srvsvc_NetSrvInfo1509_Type);
19627 #endif
19628 #ifdef PY_NETSRVINFO1510_PATCH
19629         PY_NETSRVINFO1510_PATCH(&srvsvc_NetSrvInfo1510_Type);
19630 #endif
19631 #ifdef PY_NETSRVINFO1511_PATCH
19632         PY_NETSRVINFO1511_PATCH(&srvsvc_NetSrvInfo1511_Type);
19633 #endif
19634 #ifdef PY_NETSRVINFO1512_PATCH
19635         PY_NETSRVINFO1512_PATCH(&srvsvc_NetSrvInfo1512_Type);
19636 #endif
19637 #ifdef PY_NETSRVINFO1513_PATCH
19638         PY_NETSRVINFO1513_PATCH(&srvsvc_NetSrvInfo1513_Type);
19639 #endif
19640 #ifdef PY_NETSRVINFO1514_PATCH
19641         PY_NETSRVINFO1514_PATCH(&srvsvc_NetSrvInfo1514_Type);
19642 #endif
19643 #ifdef PY_NETSRVINFO1515_PATCH
19644         PY_NETSRVINFO1515_PATCH(&srvsvc_NetSrvInfo1515_Type);
19645 #endif
19646 #ifdef PY_NETSRVINFO1516_PATCH
19647         PY_NETSRVINFO1516_PATCH(&srvsvc_NetSrvInfo1516_Type);
19648 #endif
19649 #ifdef PY_NETSRVINFO1518_PATCH
19650         PY_NETSRVINFO1518_PATCH(&srvsvc_NetSrvInfo1518_Type);
19651 #endif
19652 #ifdef PY_NETSRVINFO1520_PATCH
19653         PY_NETSRVINFO1520_PATCH(&srvsvc_NetSrvInfo1520_Type);
19654 #endif
19655 #ifdef PY_NETSRVINFO1521_PATCH
19656         PY_NETSRVINFO1521_PATCH(&srvsvc_NetSrvInfo1521_Type);
19657 #endif
19658 #ifdef PY_NETSRVINFO1522_PATCH
19659         PY_NETSRVINFO1522_PATCH(&srvsvc_NetSrvInfo1522_Type);
19660 #endif
19661 #ifdef PY_NETSRVINFO1523_PATCH
19662         PY_NETSRVINFO1523_PATCH(&srvsvc_NetSrvInfo1523_Type);
19663 #endif
19664 #ifdef PY_NETSRVINFO1524_PATCH
19665         PY_NETSRVINFO1524_PATCH(&srvsvc_NetSrvInfo1524_Type);
19666 #endif
19667 #ifdef PY_NETSRVINFO1525_PATCH
19668         PY_NETSRVINFO1525_PATCH(&srvsvc_NetSrvInfo1525_Type);
19669 #endif
19670 #ifdef PY_NETSRVINFO1528_PATCH
19671         PY_NETSRVINFO1528_PATCH(&srvsvc_NetSrvInfo1528_Type);
19672 #endif
19673 #ifdef PY_NETSRVINFO1529_PATCH
19674         PY_NETSRVINFO1529_PATCH(&srvsvc_NetSrvInfo1529_Type);
19675 #endif
19676 #ifdef PY_NETSRVINFO1530_PATCH
19677         PY_NETSRVINFO1530_PATCH(&srvsvc_NetSrvInfo1530_Type);
19678 #endif
19679 #ifdef PY_NETSRVINFO1533_PATCH
19680         PY_NETSRVINFO1533_PATCH(&srvsvc_NetSrvInfo1533_Type);
19681 #endif
19682 #ifdef PY_NETSRVINFO1534_PATCH
19683         PY_NETSRVINFO1534_PATCH(&srvsvc_NetSrvInfo1534_Type);
19684 #endif
19685 #ifdef PY_NETSRVINFO1535_PATCH
19686         PY_NETSRVINFO1535_PATCH(&srvsvc_NetSrvInfo1535_Type);
19687 #endif
19688 #ifdef PY_NETSRVINFO1536_PATCH
19689         PY_NETSRVINFO1536_PATCH(&srvsvc_NetSrvInfo1536_Type);
19690 #endif
19691 #ifdef PY_NETSRVINFO1537_PATCH
19692         PY_NETSRVINFO1537_PATCH(&srvsvc_NetSrvInfo1537_Type);
19693 #endif
19694 #ifdef PY_NETSRVINFO1538_PATCH
19695         PY_NETSRVINFO1538_PATCH(&srvsvc_NetSrvInfo1538_Type);
19696 #endif
19697 #ifdef PY_NETSRVINFO1539_PATCH
19698         PY_NETSRVINFO1539_PATCH(&srvsvc_NetSrvInfo1539_Type);
19699 #endif
19700 #ifdef PY_NETSRVINFO1540_PATCH
19701         PY_NETSRVINFO1540_PATCH(&srvsvc_NetSrvInfo1540_Type);
19702 #endif
19703 #ifdef PY_NETSRVINFO1541_PATCH
19704         PY_NETSRVINFO1541_PATCH(&srvsvc_NetSrvInfo1541_Type);
19705 #endif
19706 #ifdef PY_NETSRVINFO1542_PATCH
19707         PY_NETSRVINFO1542_PATCH(&srvsvc_NetSrvInfo1542_Type);
19708 #endif
19709 #ifdef PY_NETSRVINFO1543_PATCH
19710         PY_NETSRVINFO1543_PATCH(&srvsvc_NetSrvInfo1543_Type);
19711 #endif
19712 #ifdef PY_NETSRVINFO1544_PATCH
19713         PY_NETSRVINFO1544_PATCH(&srvsvc_NetSrvInfo1544_Type);
19714 #endif
19715 #ifdef PY_NETSRVINFO1545_PATCH
19716         PY_NETSRVINFO1545_PATCH(&srvsvc_NetSrvInfo1545_Type);
19717 #endif
19718 #ifdef PY_NETSRVINFO1546_PATCH
19719         PY_NETSRVINFO1546_PATCH(&srvsvc_NetSrvInfo1546_Type);
19720 #endif
19721 #ifdef PY_NETSRVINFO1547_PATCH
19722         PY_NETSRVINFO1547_PATCH(&srvsvc_NetSrvInfo1547_Type);
19723 #endif
19724 #ifdef PY_NETSRVINFO1548_PATCH
19725         PY_NETSRVINFO1548_PATCH(&srvsvc_NetSrvInfo1548_Type);
19726 #endif
19727 #ifdef PY_NETSRVINFO1549_PATCH
19728         PY_NETSRVINFO1549_PATCH(&srvsvc_NetSrvInfo1549_Type);
19729 #endif
19730 #ifdef PY_NETSRVINFO1550_PATCH
19731         PY_NETSRVINFO1550_PATCH(&srvsvc_NetSrvInfo1550_Type);
19732 #endif
19733 #ifdef PY_NETSRVINFO1552_PATCH
19734         PY_NETSRVINFO1552_PATCH(&srvsvc_NetSrvInfo1552_Type);
19735 #endif
19736 #ifdef PY_NETSRVINFO1553_PATCH
19737         PY_NETSRVINFO1553_PATCH(&srvsvc_NetSrvInfo1553_Type);
19738 #endif
19739 #ifdef PY_NETSRVINFO1554_PATCH
19740         PY_NETSRVINFO1554_PATCH(&srvsvc_NetSrvInfo1554_Type);
19741 #endif
19742 #ifdef PY_NETSRVINFO1555_PATCH
19743         PY_NETSRVINFO1555_PATCH(&srvsvc_NetSrvInfo1555_Type);
19744 #endif
19745 #ifdef PY_NETSRVINFO1556_PATCH
19746         PY_NETSRVINFO1556_PATCH(&srvsvc_NetSrvInfo1556_Type);
19747 #endif
19748 #ifdef PY_NETDISKINFO0_PATCH
19749         PY_NETDISKINFO0_PATCH(&srvsvc_NetDiskInfo0_Type);
19750 #endif
19751 #ifdef PY_NETDISKINFO_PATCH
19752         PY_NETDISKINFO_PATCH(&srvsvc_NetDiskInfo_Type);
19753 #endif
19754 #ifdef PY_STATISTICS_PATCH
19755         PY_STATISTICS_PATCH(&srvsvc_Statistics_Type);
19756 #endif
19757 #ifdef PY_NETTRANSPORTINFO0_PATCH
19758         PY_NETTRANSPORTINFO0_PATCH(&srvsvc_NetTransportInfo0_Type);
19759 #endif
19760 #ifdef PY_NETTRANSPORTCTR0_PATCH
19761         PY_NETTRANSPORTCTR0_PATCH(&srvsvc_NetTransportCtr0_Type);
19762 #endif
19763 #ifdef PY_NETTRANSPORTINFO1_PATCH
19764         PY_NETTRANSPORTINFO1_PATCH(&srvsvc_NetTransportInfo1_Type);
19765 #endif
19766 #ifdef PY_NETTRANSPORTCTR1_PATCH
19767         PY_NETTRANSPORTCTR1_PATCH(&srvsvc_NetTransportCtr1_Type);
19768 #endif
19769 #ifdef PY_NETTRANSPORTINFO2_PATCH
19770         PY_NETTRANSPORTINFO2_PATCH(&srvsvc_NetTransportInfo2_Type);
19771 #endif
19772 #ifdef PY_NETTRANSPORTCTR2_PATCH
19773         PY_NETTRANSPORTCTR2_PATCH(&srvsvc_NetTransportCtr2_Type);
19774 #endif
19775 #ifdef PY_NETTRANSPORTINFO3_PATCH
19776         PY_NETTRANSPORTINFO3_PATCH(&srvsvc_NetTransportInfo3_Type);
19777 #endif
19778 #ifdef PY_NETTRANSPORTCTR3_PATCH
19779         PY_NETTRANSPORTCTR3_PATCH(&srvsvc_NetTransportCtr3_Type);
19780 #endif
19781 #ifdef PY_NETTRANSPORTINFOCTR_PATCH
19782         PY_NETTRANSPORTINFOCTR_PATCH(&srvsvc_NetTransportInfoCtr_Type);
19783 #endif
19784 #ifdef PY_NETREMOTETODINFO_PATCH
19785         PY_NETREMOTETODINFO_PATCH(&srvsvc_NetRemoteTODInfo_Type);
19786 #endif
19787 #ifdef PY_SRVSVC_PATCH
19788         PY_SRVSVC_PATCH(&srvsvc_InterfaceType);
19789 #endif
19790 #ifdef PY_ABSTRACT_SYNTAX_PATCH
19791         PY_ABSTRACT_SYNTAX_PATCH(&srvsvc_SyntaxType);
19792 #endif
19793
19794         m = Py_InitModule3("srvsvc", srvsvc_methods, "srvsvc DCE/RPC");
19795         if (m == NULL)
19796                 return;
19797
19798         PyModule_AddObject(m, "STYPE_TEMPORARY", PyInt_FromLong(0x40000000));
19799         PyModule_AddObject(m, "STYPE_HIDDEN", PyInt_FromLong(0x80000000));
19800         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_MANUAL_REINT", PyInt_FromLong(0x00000000));
19801         PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_MASK", PyInt_FromLong(0x00000030));
19802         PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_SHIFT", PyInt_FromLong(4));
19803         PyModule_AddObject(m, "STYPE_DISKTREE", PyInt_FromLong(STYPE_DISKTREE));
19804         PyModule_AddObject(m, "STYPE_DISKTREE_TEMPORARY", PyInt_FromLong(STYPE_DISKTREE_TEMPORARY));
19805         PyModule_AddObject(m, "STYPE_DISKTREE_HIDDEN", PyInt_FromLong(STYPE_DISKTREE_HIDDEN));
19806         PyModule_AddObject(m, "STYPE_PRINTQ", PyInt_FromLong(STYPE_PRINTQ));
19807         PyModule_AddObject(m, "STYPE_PRINTQ_TEMPORARY", PyInt_FromLong(STYPE_PRINTQ_TEMPORARY));
19808         PyModule_AddObject(m, "STYPE_PRINTQ_HIDDEN", PyInt_FromLong(STYPE_PRINTQ_HIDDEN));
19809         PyModule_AddObject(m, "STYPE_DEVICE", PyInt_FromLong(STYPE_DEVICE));
19810         PyModule_AddObject(m, "STYPE_DEVICE_TEMPORARY", PyInt_FromLong(STYPE_DEVICE_TEMPORARY));
19811         PyModule_AddObject(m, "STYPE_DEVICE_HIDDEN", PyInt_FromLong(STYPE_DEVICE_HIDDEN));
19812         PyModule_AddObject(m, "STYPE_IPC", PyInt_FromLong(STYPE_IPC));
19813         PyModule_AddObject(m, "STYPE_IPC_TEMPORARY", PyInt_FromLong(STYPE_IPC_TEMPORARY));
19814         PyModule_AddObject(m, "STYPE_IPC_HIDDEN", PyInt_FromLong(STYPE_IPC_HIDDEN));
19815         PyModule_AddObject(m, "SHARE_1005_IN_DFS", PyInt_FromLong(SHARE_1005_IN_DFS));
19816         PyModule_AddObject(m, "SHARE_1005_DFS_ROOT", PyInt_FromLong(SHARE_1005_DFS_ROOT));
19817         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_AUTO_REINT", PyInt_FromLong(SHARE_1005_CSC_CACHE_AUTO_REINT));
19818         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_VDO", PyInt_FromLong(SHARE_1005_CSC_CACHE_VDO));
19819         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_NONE", PyInt_FromLong(SHARE_1005_CSC_CACHE_NONE));
19820         PyModule_AddObject(m, "SHARE_1005_RESTRICT_EXCLUSIVE_OPENS", PyInt_FromLong(SHARE_1005_RESTRICT_EXCLUSIVE_OPENS));
19821         PyModule_AddObject(m, "SHARE_1005_FORCE_SHARED_DELETE", PyInt_FromLong(SHARE_1005_FORCE_SHARED_DELETE));
19822         PyModule_AddObject(m, "SHARE_1005_ALLOW_NAMESPACE_CACHING", PyInt_FromLong(SHARE_1005_ALLOW_NAMESPACE_CACHING));
19823         PyModule_AddObject(m, "SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM", PyInt_FromLong(SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM));
19824         PyModule_AddObject(m, "SHARE_1005_FORCE_LEVELII_OPLOCK", PyInt_FromLong(SHARE_1005_FORCE_LEVELII_OPLOCK));
19825         PyModule_AddObject(m, "SHARE_1005_ENABLE_HASH", PyInt_FromLong(SHARE_1005_ENABLE_HASH));
19826         PyModule_AddObject(m, "SHARE_1005_ENABLE_CA", PyInt_FromLong(SHARE_1005_ENABLE_CA));
19827         PyModule_AddObject(m, "SHARE_1005_ENCRYPT_DATA", PyInt_FromLong(SHARE_1005_ENCRYPT_DATA));
19828         PyModule_AddObject(m, "PLATFORM_ID_DOS", PyInt_FromLong(PLATFORM_ID_DOS));
19829         PyModule_AddObject(m, "PLATFORM_ID_OS2", PyInt_FromLong(PLATFORM_ID_OS2));
19830         PyModule_AddObject(m, "PLATFORM_ID_NT", PyInt_FromLong(PLATFORM_ID_NT));
19831         PyModule_AddObject(m, "PLATFORM_ID_OSF", PyInt_FromLong(PLATFORM_ID_OSF));
19832         PyModule_AddObject(m, "PLATFORM_ID_VMS", PyInt_FromLong(PLATFORM_ID_VMS));
19833         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
19834         PyModule_AddObject(m, "NetCharDevInfo0", (PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
19835         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
19836         PyModule_AddObject(m, "NetCharDevCtr0", (PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
19837         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
19838         PyModule_AddObject(m, "NetCharDevInfo1", (PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
19839         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
19840         PyModule_AddObject(m, "NetCharDevCtr1", (PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
19841         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
19842         PyModule_AddObject(m, "NetCharDevInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
19843         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
19844         PyModule_AddObject(m, "NetCharDevQInfo0", (PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
19845         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
19846         PyModule_AddObject(m, "NetCharDevQCtr0", (PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
19847         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
19848         PyModule_AddObject(m, "NetCharDevQInfo1", (PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
19849         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
19850         PyModule_AddObject(m, "NetCharDevQCtr1", (PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
19851         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
19852         PyModule_AddObject(m, "NetCharDevQInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
19853         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
19854         PyModule_AddObject(m, "NetConnInfo0", (PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
19855         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
19856         PyModule_AddObject(m, "NetConnCtr0", (PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
19857         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
19858         PyModule_AddObject(m, "NetConnInfo1", (PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
19859         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
19860         PyModule_AddObject(m, "NetConnCtr1", (PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
19861         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
19862         PyModule_AddObject(m, "NetConnInfoCtr", (PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
19863         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
19864         PyModule_AddObject(m, "NetFileInfo2", (PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
19865         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
19866         PyModule_AddObject(m, "NetFileCtr2", (PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
19867         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
19868         PyModule_AddObject(m, "NetFileInfo3", (PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
19869         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
19870         PyModule_AddObject(m, "NetFileCtr3", (PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
19871         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
19872         PyModule_AddObject(m, "NetFileInfoCtr", (PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
19873         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
19874         PyModule_AddObject(m, "NetSessInfo0", (PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
19875         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
19876         PyModule_AddObject(m, "NetSessCtr0", (PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
19877         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
19878         PyModule_AddObject(m, "NetSessInfo1", (PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
19879         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
19880         PyModule_AddObject(m, "NetSessCtr1", (PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
19881         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
19882         PyModule_AddObject(m, "NetSessInfo2", (PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
19883         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
19884         PyModule_AddObject(m, "NetSessCtr2", (PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
19885         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
19886         PyModule_AddObject(m, "NetSessInfo10", (PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
19887         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
19888         PyModule_AddObject(m, "NetSessCtr10", (PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
19889         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
19890         PyModule_AddObject(m, "NetSessInfo502", (PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
19891         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
19892         PyModule_AddObject(m, "NetSessCtr502", (PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
19893         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
19894         PyModule_AddObject(m, "NetSessInfoCtr", (PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
19895         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
19896         PyModule_AddObject(m, "NetShareInfo0", (PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
19897         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
19898         PyModule_AddObject(m, "NetShareCtr0", (PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
19899         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
19900         PyModule_AddObject(m, "NetShareInfo1", (PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
19901         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
19902         PyModule_AddObject(m, "NetShareCtr1", (PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
19903         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
19904         PyModule_AddObject(m, "NetShareInfo2", (PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
19905         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
19906         PyModule_AddObject(m, "NetShareCtr2", (PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
19907         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
19908         PyModule_AddObject(m, "NetShareInfo501", (PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
19909         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
19910         PyModule_AddObject(m, "NetShareCtr501", (PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
19911         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
19912         PyModule_AddObject(m, "NetShareInfo502", (PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
19913         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
19914         PyModule_AddObject(m, "NetShareCtr502", (PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
19915         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
19916         PyModule_AddObject(m, "NetShareInfo1004", (PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
19917         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
19918         PyModule_AddObject(m, "NetShareCtr1004", (PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
19919         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
19920         PyModule_AddObject(m, "NetShareInfo1005", (PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
19921         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
19922         PyModule_AddObject(m, "NetShareCtr1005", (PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
19923         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
19924         PyModule_AddObject(m, "NetShareInfo1006", (PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
19925         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
19926         PyModule_AddObject(m, "NetShareCtr1006", (PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
19927         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
19928         PyModule_AddObject(m, "NetShareInfo1007", (PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
19929         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
19930         PyModule_AddObject(m, "NetShareCtr1007", (PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
19931         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
19932         PyModule_AddObject(m, "NetShareCtr1501", (PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
19933         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
19934         PyModule_AddObject(m, "NetShareInfoCtr", (PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
19935         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
19936         PyModule_AddObject(m, "NetSrvInfo100", (PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
19937         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
19938         PyModule_AddObject(m, "NetSrvInfo101", (PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
19939         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
19940         PyModule_AddObject(m, "NetSrvInfo102", (PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
19941         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
19942         PyModule_AddObject(m, "NetSrvInfo402", (PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
19943         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
19944         PyModule_AddObject(m, "NetSrvInfo403", (PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
19945         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
19946         PyModule_AddObject(m, "NetSrvInfo502", (PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
19947         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
19948         PyModule_AddObject(m, "NetSrvInfo503", (PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
19949         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
19950         PyModule_AddObject(m, "NetSrvInfo599", (PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
19951         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
19952         PyModule_AddObject(m, "NetSrvInfo1005", (PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
19953         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
19954         PyModule_AddObject(m, "NetSrvInfo1010", (PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
19955         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
19956         PyModule_AddObject(m, "NetSrvInfo1016", (PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
19957         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
19958         PyModule_AddObject(m, "NetSrvInfo1017", (PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
19959         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
19960         PyModule_AddObject(m, "NetSrvInfo1018", (PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
19961         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
19962         PyModule_AddObject(m, "NetSrvInfo1107", (PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
19963         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
19964         PyModule_AddObject(m, "NetSrvInfo1501", (PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
19965         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
19966         PyModule_AddObject(m, "NetSrvInfo1502", (PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
19967         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
19968         PyModule_AddObject(m, "NetSrvInfo1503", (PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
19969         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
19970         PyModule_AddObject(m, "NetSrvInfo1506", (PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
19971         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
19972         PyModule_AddObject(m, "NetSrvInfo1509", (PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
19973         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
19974         PyModule_AddObject(m, "NetSrvInfo1510", (PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
19975         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
19976         PyModule_AddObject(m, "NetSrvInfo1511", (PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
19977         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
19978         PyModule_AddObject(m, "NetSrvInfo1512", (PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
19979         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
19980         PyModule_AddObject(m, "NetSrvInfo1513", (PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
19981         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
19982         PyModule_AddObject(m, "NetSrvInfo1514", (PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
19983         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
19984         PyModule_AddObject(m, "NetSrvInfo1515", (PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
19985         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
19986         PyModule_AddObject(m, "NetSrvInfo1516", (PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
19987         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
19988         PyModule_AddObject(m, "NetSrvInfo1518", (PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
19989         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
19990         PyModule_AddObject(m, "NetSrvInfo1520", (PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
19991         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
19992         PyModule_AddObject(m, "NetSrvInfo1521", (PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
19993         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
19994         PyModule_AddObject(m, "NetSrvInfo1522", (PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
19995         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
19996         PyModule_AddObject(m, "NetSrvInfo1523", (PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
19997         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
19998         PyModule_AddObject(m, "NetSrvInfo1524", (PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
19999         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
20000         PyModule_AddObject(m, "NetSrvInfo1525", (PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
20001         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
20002         PyModule_AddObject(m, "NetSrvInfo1528", (PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
20003         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
20004         PyModule_AddObject(m, "NetSrvInfo1529", (PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
20005         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
20006         PyModule_AddObject(m, "NetSrvInfo1530", (PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
20007         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
20008         PyModule_AddObject(m, "NetSrvInfo1533", (PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
20009         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
20010         PyModule_AddObject(m, "NetSrvInfo1534", (PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
20011         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
20012         PyModule_AddObject(m, "NetSrvInfo1535", (PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
20013         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
20014         PyModule_AddObject(m, "NetSrvInfo1536", (PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
20015         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
20016         PyModule_AddObject(m, "NetSrvInfo1537", (PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
20017         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
20018         PyModule_AddObject(m, "NetSrvInfo1538", (PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
20019         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
20020         PyModule_AddObject(m, "NetSrvInfo1539", (PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
20021         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
20022         PyModule_AddObject(m, "NetSrvInfo1540", (PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
20023         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
20024         PyModule_AddObject(m, "NetSrvInfo1541", (PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
20025         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
20026         PyModule_AddObject(m, "NetSrvInfo1542", (PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
20027         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
20028         PyModule_AddObject(m, "NetSrvInfo1543", (PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
20029         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
20030         PyModule_AddObject(m, "NetSrvInfo1544", (PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
20031         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
20032         PyModule_AddObject(m, "NetSrvInfo1545", (PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
20033         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
20034         PyModule_AddObject(m, "NetSrvInfo1546", (PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
20035         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
20036         PyModule_AddObject(m, "NetSrvInfo1547", (PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
20037         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
20038         PyModule_AddObject(m, "NetSrvInfo1548", (PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
20039         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
20040         PyModule_AddObject(m, "NetSrvInfo1549", (PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
20041         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
20042         PyModule_AddObject(m, "NetSrvInfo1550", (PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
20043         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
20044         PyModule_AddObject(m, "NetSrvInfo1552", (PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
20045         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
20046         PyModule_AddObject(m, "NetSrvInfo1553", (PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
20047         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
20048         PyModule_AddObject(m, "NetSrvInfo1554", (PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
20049         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
20050         PyModule_AddObject(m, "NetSrvInfo1555", (PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
20051         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
20052         PyModule_AddObject(m, "NetSrvInfo1556", (PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
20053         Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
20054         PyModule_AddObject(m, "NetDiskInfo0", (PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
20055         Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
20056         PyModule_AddObject(m, "NetDiskInfo", (PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
20057         Py_INCREF((PyObject *)(void *)&srvsvc_Statistics_Type);
20058         PyModule_AddObject(m, "Statistics", (PyObject *)(void *)&srvsvc_Statistics_Type);
20059         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
20060         PyModule_AddObject(m, "NetTransportInfo0", (PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
20061         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
20062         PyModule_AddObject(m, "NetTransportCtr0", (PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
20063         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
20064         PyModule_AddObject(m, "NetTransportInfo1", (PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
20065         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
20066         PyModule_AddObject(m, "NetTransportCtr1", (PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
20067         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
20068         PyModule_AddObject(m, "NetTransportInfo2", (PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
20069         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
20070         PyModule_AddObject(m, "NetTransportCtr2", (PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
20071         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
20072         PyModule_AddObject(m, "NetTransportInfo3", (PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
20073         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
20074         PyModule_AddObject(m, "NetTransportCtr3", (PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
20075         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
20076         PyModule_AddObject(m, "NetTransportInfoCtr", (PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
20077         Py_INCREF((PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
20078         PyModule_AddObject(m, "NetRemoteTODInfo", (PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
20079         Py_INCREF((PyObject *)(void *)&srvsvc_InterfaceType);
20080         PyModule_AddObject(m, "srvsvc", (PyObject *)(void *)&srvsvc_InterfaceType);
20081         Py_INCREF((PyObject *)(void *)&srvsvc_SyntaxType);
20082         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&srvsvc_SyntaxType);
20083 #ifdef PY_MOD_SRVSVC_PATCH
20084         PY_MOD_SRVSVC_PATCH(m);
20085 #endif
20086
20087 }