bin.gen_ndr/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 *sec_desc_buf_Type;
 140 static PyTypeObject *policy_handle_Type;
 141 static PyTypeObject *Object_Type;
 142 static PyTypeObject *ClientConnection_Type;
 143
 144 static PyObject *py_srvsvc_NetCharDevInfo0_get_device(PyObject *obj, void *closure)
 145 {
 146         struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(obj);
 147         PyObject *py_device;
 148         if (object->device == NULL) {
 149                 py_device = Py_None;
 150                 Py_INCREF(py_device);
 151         } else {
 152                 if (object->device == NULL) {
 153                         py_device = Py_None;
 154                         Py_INCREF(py_device);
 155                 } else {
 156                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 157                 }
 158         }
 159         return py_device;
 160 }
 161
 162 static int py_srvsvc_NetCharDevInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
 163 {
 164         struct srvsvc_NetCharDevInfo0 *object = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(py_obj);
 165         if (value == Py_None) {
 166                 object->device = NULL;
 167         } else {
 168                 object->device = NULL;
 169                 if (PyUnicode_Check(value)) {
 170                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 171                 } else if (PyString_Check(value)) {
 172                         object->device = PyString_AS_STRING(value);
 173                 } else {
 174                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 175                         return -1;
 176                 }
 177         }
 178         return 0;
 179 }
 180
 181 static PyGetSetDef py_srvsvc_NetCharDevInfo0_getsetters[] = {
 182         { discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo0_get_device, py_srvsvc_NetCharDevInfo0_set_device },
 183         { NULL }
 184 };
 185
 186 static PyObject *py_srvsvc_NetCharDevInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 187 {
 188         return pytalloc_new(struct srvsvc_NetCharDevInfo0, type);
 189 }
 190
 191
 192 static PyTypeObject srvsvc_NetCharDevInfo0_Type = {
 193         PyObject_HEAD_INIT(NULL) 0,
 194         .tp_name = "srvsvc.NetCharDevInfo0",
 195         .tp_getset = py_srvsvc_NetCharDevInfo0_getsetters,
 196         .tp_methods = NULL,
 197         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 198         .tp_basicsize = sizeof(pytalloc_Object),
 199         .tp_new = py_srvsvc_NetCharDevInfo0_new,
 200 };
 201
 202
 203 static PyObject *py_srvsvc_NetCharDevCtr0_get_count(PyObject *obj, void *closure)
 204 {
 205         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
 206         PyObject *py_count;
 207         py_count = PyInt_FromLong(object->count);
 208         return py_count;
 209 }
 210
 211 static int py_srvsvc_NetCharDevCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
 212 {
 213         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(py_obj);
 214         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 215         object->count = PyInt_AsLong(value);
 216         return 0;
 217 }
 218
 219 static PyObject *py_srvsvc_NetCharDevCtr0_get_array(PyObject *obj, void *closure)
 220 {
 221         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(obj);
 222         PyObject *py_array;
 223         if (object->array == NULL) {
 224                 py_array = Py_None;
 225                 Py_INCREF(py_array);
 226         } else {
 227                 py_array = PyList_New(object->count);
 228                 if (py_array == NULL) {
 229                         return NULL;
 230                 }
 231                 {
 232                         int array_cntr_1;
 233                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 234                                 PyObject *py_array_1;
 235                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo0_Type, object->array, &object->array[array_cntr_1]);
 236                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 237                         }
 238                 }
 239         }
 240         return py_array;
 241 }
 242
 243 static int py_srvsvc_NetCharDevCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
 244 {
 245         struct srvsvc_NetCharDevCtr0 *object = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(py_obj);
 246         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 247         if (value == Py_None) {
 248                 object->array = NULL;
 249         } else {
 250                 object->array = NULL;
 251                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 252                 {
 253                         int array_cntr_1;
 254                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 255                         if (!object->array) { return -1;; }
 256                         talloc_set_name_const(object->array, "ARRAY: object->array");
 257                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 258                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 259                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 260                                         PyErr_NoMemory();
 261                                         return -1;
 262                                 }
 263                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 264                         }
 265                 }
 266         }
 267         return 0;
 268 }
 269
 270 static PyGetSetDef py_srvsvc_NetCharDevCtr0_getsetters[] = {
 271         { discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr0_get_count, py_srvsvc_NetCharDevCtr0_set_count },
 272         { discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr0_get_array, py_srvsvc_NetCharDevCtr0_set_array },
 273         { NULL }
 274 };
 275
 276 static PyObject *py_srvsvc_NetCharDevCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 277 {
 278         return pytalloc_new(struct srvsvc_NetCharDevCtr0, type);
 279 }
 280
 281
 282 static PyTypeObject srvsvc_NetCharDevCtr0_Type = {
 283         PyObject_HEAD_INIT(NULL) 0,
 284         .tp_name = "srvsvc.NetCharDevCtr0",
 285         .tp_getset = py_srvsvc_NetCharDevCtr0_getsetters,
 286         .tp_methods = NULL,
 287         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 288         .tp_basicsize = sizeof(pytalloc_Object),
 289         .tp_new = py_srvsvc_NetCharDevCtr0_new,
 290 };
 291
 292
 293 static PyObject *py_srvsvc_NetCharDevInfo1_get_device(PyObject *obj, void *closure)
 294 {
 295         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 296         PyObject *py_device;
 297         if (object->device == NULL) {
 298                 py_device = Py_None;
 299                 Py_INCREF(py_device);
 300         } else {
 301                 if (object->device == NULL) {
 302                         py_device = Py_None;
 303                         Py_INCREF(py_device);
 304                 } else {
 305                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 306                 }
 307         }
 308         return py_device;
 309 }
 310
 311 static int py_srvsvc_NetCharDevInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
 312 {
 313         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 314         if (value == Py_None) {
 315                 object->device = NULL;
 316         } else {
 317                 object->device = NULL;
 318                 if (PyUnicode_Check(value)) {
 319                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 320                 } else if (PyString_Check(value)) {
 321                         object->device = PyString_AS_STRING(value);
 322                 } else {
 323                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 324                         return -1;
 325                 }
 326         }
 327         return 0;
 328 }
 329
 330 static PyObject *py_srvsvc_NetCharDevInfo1_get_status(PyObject *obj, void *closure)
 331 {
 332         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 333         PyObject *py_status;
 334         py_status = PyInt_FromLong(object->status);
 335         return py_status;
 336 }
 337
 338 static int py_srvsvc_NetCharDevInfo1_set_status(PyObject *py_obj, PyObject *value, void *closure)
 339 {
 340         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 341         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 342         object->status = PyInt_AsLong(value);
 343         return 0;
 344 }
 345
 346 static PyObject *py_srvsvc_NetCharDevInfo1_get_user(PyObject *obj, void *closure)
 347 {
 348         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 349         PyObject *py_user;
 350         if (object->user == NULL) {
 351                 py_user = Py_None;
 352                 Py_INCREF(py_user);
 353         } else {
 354                 if (object->user == NULL) {
 355                         py_user = Py_None;
 356                         Py_INCREF(py_user);
 357                 } else {
 358                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
 359                 }
 360         }
 361         return py_user;
 362 }
 363
 364 static int py_srvsvc_NetCharDevInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
 365 {
 366         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 367         if (value == Py_None) {
 368                 object->user = NULL;
 369         } else {
 370                 object->user = NULL;
 371                 if (PyUnicode_Check(value)) {
 372                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 373                 } else if (PyString_Check(value)) {
 374                         object->user = PyString_AS_STRING(value);
 375                 } else {
 376                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 377                         return -1;
 378                 }
 379         }
 380         return 0;
 381 }
 382
 383 static PyObject *py_srvsvc_NetCharDevInfo1_get_time(PyObject *obj, void *closure)
 384 {
 385         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(obj);
 386         PyObject *py_time;
 387         py_time = PyInt_FromLong(object->time);
 388         return py_time;
 389 }
 390
 391 static int py_srvsvc_NetCharDevInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
 392 {
 393         struct srvsvc_NetCharDevInfo1 *object = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(py_obj);
 394         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 395         object->time = PyInt_AsLong(value);
 396         return 0;
 397 }
 398
 399 static PyGetSetDef py_srvsvc_NetCharDevInfo1_getsetters[] = {
 400         { discard_const_p(char, "device"), py_srvsvc_NetCharDevInfo1_get_device, py_srvsvc_NetCharDevInfo1_set_device },
 401         { discard_const_p(char, "status"), py_srvsvc_NetCharDevInfo1_get_status, py_srvsvc_NetCharDevInfo1_set_status },
 402         { discard_const_p(char, "user"), py_srvsvc_NetCharDevInfo1_get_user, py_srvsvc_NetCharDevInfo1_set_user },
 403         { discard_const_p(char, "time"), py_srvsvc_NetCharDevInfo1_get_time, py_srvsvc_NetCharDevInfo1_set_time },
 404         { NULL }
 405 };
 406
 407 static PyObject *py_srvsvc_NetCharDevInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 408 {
 409         return pytalloc_new(struct srvsvc_NetCharDevInfo1, type);
 410 }
 411
 412
 413 static PyTypeObject srvsvc_NetCharDevInfo1_Type = {
 414         PyObject_HEAD_INIT(NULL) 0,
 415         .tp_name = "srvsvc.NetCharDevInfo1",
 416         .tp_getset = py_srvsvc_NetCharDevInfo1_getsetters,
 417         .tp_methods = NULL,
 418         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 419         .tp_basicsize = sizeof(pytalloc_Object),
 420         .tp_new = py_srvsvc_NetCharDevInfo1_new,
 421 };
 422
 423
 424 static PyObject *py_srvsvc_NetCharDevCtr1_get_count(PyObject *obj, void *closure)
 425 {
 426         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
 427         PyObject *py_count;
 428         py_count = PyInt_FromLong(object->count);
 429         return py_count;
 430 }
 431
 432 static int py_srvsvc_NetCharDevCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
 433 {
 434         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(py_obj);
 435         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 436         object->count = PyInt_AsLong(value);
 437         return 0;
 438 }
 439
 440 static PyObject *py_srvsvc_NetCharDevCtr1_get_array(PyObject *obj, void *closure)
 441 {
 442         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(obj);
 443         PyObject *py_array;
 444         if (object->array == NULL) {
 445                 py_array = Py_None;
 446                 Py_INCREF(py_array);
 447         } else {
 448                 py_array = PyList_New(object->count);
 449                 if (py_array == NULL) {
 450                         return NULL;
 451                 }
 452                 {
 453                         int array_cntr_1;
 454                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 455                                 PyObject *py_array_1;
 456                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevInfo1_Type, object->array, &object->array[array_cntr_1]);
 457                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 458                         }
 459                 }
 460         }
 461         return py_array;
 462 }
 463
 464 static int py_srvsvc_NetCharDevCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
 465 {
 466         struct srvsvc_NetCharDevCtr1 *object = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(py_obj);
 467         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 468         if (value == Py_None) {
 469                 object->array = NULL;
 470         } else {
 471                 object->array = NULL;
 472                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 473                 {
 474                         int array_cntr_1;
 475                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 476                         if (!object->array) { return -1;; }
 477                         talloc_set_name_const(object->array, "ARRAY: object->array");
 478                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 479                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 480                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 481                                         PyErr_NoMemory();
 482                                         return -1;
 483                                 }
 484                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 485                         }
 486                 }
 487         }
 488         return 0;
 489 }
 490
 491 static PyGetSetDef py_srvsvc_NetCharDevCtr1_getsetters[] = {
 492         { discard_const_p(char, "count"), py_srvsvc_NetCharDevCtr1_get_count, py_srvsvc_NetCharDevCtr1_set_count },
 493         { discard_const_p(char, "array"), py_srvsvc_NetCharDevCtr1_get_array, py_srvsvc_NetCharDevCtr1_set_array },
 494         { NULL }
 495 };
 496
 497 static PyObject *py_srvsvc_NetCharDevCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 498 {
 499         return pytalloc_new(struct srvsvc_NetCharDevCtr1, type);
 500 }
 501
 502
 503 static PyTypeObject srvsvc_NetCharDevCtr1_Type = {
 504         PyObject_HEAD_INIT(NULL) 0,
 505         .tp_name = "srvsvc.NetCharDevCtr1",
 506         .tp_getset = py_srvsvc_NetCharDevCtr1_getsetters,
 507         .tp_methods = NULL,
 508         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 509         .tp_basicsize = sizeof(pytalloc_Object),
 510         .tp_new = py_srvsvc_NetCharDevCtr1_new,
 511 };
 512
 513 PyObject *py_import_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevInfo *in)
 514 {
 515         PyObject *ret;
 516
 517         switch (level) {
 518                 case 0:
 519                         if (in->info0 == NULL) {
 520                                 ret = Py_None;
 521                                 Py_INCREF(ret);
 522                         } else {
 523                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevInfo0_Type, in->info0, in->info0);
 524                         }
 525                         return ret;
 526
 527                 case 1:
 528                         if (in->info1 == NULL) {
 529                                 ret = Py_None;
 530                                 Py_INCREF(ret);
 531                         } else {
 532                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevInfo1_Type, in->info1, in->info1);
 533                         }
 534                         return ret;
 535
 536                 default:
 537                         ret = Py_None;
 538                         Py_INCREF(ret);
 539                         return ret;
 540
 541         }
 542         PyErr_SetString(PyExc_TypeError, "unknown union level");
 543         return NULL;
 544 }
 545
 546 union srvsvc_NetCharDevInfo *py_export_srvsvc_NetCharDevInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 547 {
 548         union srvsvc_NetCharDevInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevInfo);
 549         switch (level) {
 550                 case 0:
 551                         if (in == Py_None) {
 552                                 ret->info0 = NULL;
 553                         } else {
 554                                 ret->info0 = NULL;
 555                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo0_Type, in, talloc_free(ret); return NULL;);
 556                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 557                                         PyErr_NoMemory();
 558                                         talloc_free(ret); return NULL;
 559                                 }
 560                                 ret->info0 = (struct srvsvc_NetCharDevInfo0 *)pytalloc_get_ptr(in);
 561                         }
 562                         break;
 563
 564                 case 1:
 565                         if (in == Py_None) {
 566                                 ret->info1 = NULL;
 567                         } else {
 568                                 ret->info1 = NULL;
 569                                 PY_CHECK_TYPE(&srvsvc_NetCharDevInfo1_Type, in, talloc_free(ret); return NULL;);
 570                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 571                                         PyErr_NoMemory();
 572                                         talloc_free(ret); return NULL;
 573                                 }
 574                                 ret->info1 = (struct srvsvc_NetCharDevInfo1 *)pytalloc_get_ptr(in);
 575                         }
 576                         break;
 577
 578                 default:
 579                         break;
 580
 581         }
 582
 583         return ret;
 584 }
 585
 586 PyObject *py_import_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevCtr *in)
 587 {
 588         PyObject *ret;
 589
 590         switch (level) {
 591                 case 0:
 592                         if (in->ctr0 == NULL) {
 593                                 ret = Py_None;
 594                                 Py_INCREF(ret);
 595                         } else {
 596                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr0_Type, in->ctr0, in->ctr0);
 597                         }
 598                         return ret;
 599
 600                 case 1:
 601                         if (in->ctr1 == NULL) {
 602                                 ret = Py_None;
 603                                 Py_INCREF(ret);
 604                         } else {
 605                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevCtr1_Type, in->ctr1, in->ctr1);
 606                         }
 607                         return ret;
 608
 609                 default:
 610                         ret = Py_None;
 611                         Py_INCREF(ret);
 612                         return ret;
 613
 614         }
 615         PyErr_SetString(PyExc_TypeError, "unknown union level");
 616         return NULL;
 617 }
 618
 619 union srvsvc_NetCharDevCtr *py_export_srvsvc_NetCharDevCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 620 {
 621         union srvsvc_NetCharDevCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevCtr);
 622         switch (level) {
 623                 case 0:
 624                         if (in == Py_None) {
 625                                 ret->ctr0 = NULL;
 626                         } else {
 627                                 ret->ctr0 = NULL;
 628                                 PY_CHECK_TYPE(&srvsvc_NetCharDevCtr0_Type, in, talloc_free(ret); return NULL;);
 629                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 630                                         PyErr_NoMemory();
 631                                         talloc_free(ret); return NULL;
 632                                 }
 633                                 ret->ctr0 = (struct srvsvc_NetCharDevCtr0 *)pytalloc_get_ptr(in);
 634                         }
 635                         break;
 636
 637                 case 1:
 638                         if (in == Py_None) {
 639                                 ret->ctr1 = NULL;
 640                         } else {
 641                                 ret->ctr1 = NULL;
 642                                 PY_CHECK_TYPE(&srvsvc_NetCharDevCtr1_Type, in, talloc_free(ret); return NULL;);
 643                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 644                                         PyErr_NoMemory();
 645                                         talloc_free(ret); return NULL;
 646                                 }
 647                                 ret->ctr1 = (struct srvsvc_NetCharDevCtr1 *)pytalloc_get_ptr(in);
 648                         }
 649                         break;
 650
 651                 default:
 652                         break;
 653
 654         }
 655
 656         return ret;
 657 }
 658
 659
 660 static PyObject *py_srvsvc_NetCharDevInfoCtr_get_level(PyObject *obj, void *closure)
 661 {
 662         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
 663         PyObject *py_level;
 664         py_level = PyInt_FromLong(object->level);
 665         return py_level;
 666 }
 667
 668 static int py_srvsvc_NetCharDevInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
 669 {
 670         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_obj);
 671         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 672         object->level = PyInt_AsLong(value);
 673         return 0;
 674 }
 675
 676 static PyObject *py_srvsvc_NetCharDevInfoCtr_get_ctr(PyObject *obj, void *closure)
 677 {
 678         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(obj);
 679         PyObject *py_ctr;
 680         py_ctr = py_import_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
 681         if (py_ctr == NULL) {
 682                 return NULL;
 683         }
 684         return py_ctr;
 685 }
 686
 687 static int py_srvsvc_NetCharDevInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
 688 {
 689         struct srvsvc_NetCharDevInfoCtr *object = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_obj);
 690         {
 691                 union srvsvc_NetCharDevCtr *ctr_switch_0;
 692                 ctr_switch_0 = py_export_srvsvc_NetCharDevCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
 693                 if (ctr_switch_0 == NULL) {
 694                         return -1;
 695                 }
 696                 object->ctr = *ctr_switch_0;
 697         }
 698         return 0;
 699 }
 700
 701 static PyGetSetDef py_srvsvc_NetCharDevInfoCtr_getsetters[] = {
 702         { discard_const_p(char, "level"), py_srvsvc_NetCharDevInfoCtr_get_level, py_srvsvc_NetCharDevInfoCtr_set_level },
 703         { discard_const_p(char, "ctr"), py_srvsvc_NetCharDevInfoCtr_get_ctr, py_srvsvc_NetCharDevInfoCtr_set_ctr },
 704         { NULL }
 705 };
 706
 707 static PyObject *py_srvsvc_NetCharDevInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 708 {
 709         return pytalloc_new(struct srvsvc_NetCharDevInfoCtr, type);
 710 }
 711
 712
 713 static PyTypeObject srvsvc_NetCharDevInfoCtr_Type = {
 714         PyObject_HEAD_INIT(NULL) 0,
 715         .tp_name = "srvsvc.NetCharDevInfoCtr",
 716         .tp_getset = py_srvsvc_NetCharDevInfoCtr_getsetters,
 717         .tp_methods = NULL,
 718         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 719         .tp_basicsize = sizeof(pytalloc_Object),
 720         .tp_new = py_srvsvc_NetCharDevInfoCtr_new,
 721 };
 722
 723
 724 static PyObject *py_srvsvc_NetCharDevQInfo0_get_device(PyObject *obj, void *closure)
 725 {
 726         struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(obj);
 727         PyObject *py_device;
 728         if (object->device == NULL) {
 729                 py_device = Py_None;
 730                 Py_INCREF(py_device);
 731         } else {
 732                 if (object->device == NULL) {
 733                         py_device = Py_None;
 734                         Py_INCREF(py_device);
 735                 } else {
 736                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 737                 }
 738         }
 739         return py_device;
 740 }
 741
 742 static int py_srvsvc_NetCharDevQInfo0_set_device(PyObject *py_obj, PyObject *value, void *closure)
 743 {
 744         struct srvsvc_NetCharDevQInfo0 *object = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(py_obj);
 745         if (value == Py_None) {
 746                 object->device = NULL;
 747         } else {
 748                 object->device = NULL;
 749                 if (PyUnicode_Check(value)) {
 750                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 751                 } else if (PyString_Check(value)) {
 752                         object->device = PyString_AS_STRING(value);
 753                 } else {
 754                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 755                         return -1;
 756                 }
 757         }
 758         return 0;
 759 }
 760
 761 static PyGetSetDef py_srvsvc_NetCharDevQInfo0_getsetters[] = {
 762         { discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo0_get_device, py_srvsvc_NetCharDevQInfo0_set_device },
 763         { NULL }
 764 };
 765
 766 static PyObject *py_srvsvc_NetCharDevQInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 767 {
 768         return pytalloc_new(struct srvsvc_NetCharDevQInfo0, type);
 769 }
 770
 771
 772 static PyTypeObject srvsvc_NetCharDevQInfo0_Type = {
 773         PyObject_HEAD_INIT(NULL) 0,
 774         .tp_name = "srvsvc.NetCharDevQInfo0",
 775         .tp_getset = py_srvsvc_NetCharDevQInfo0_getsetters,
 776         .tp_methods = NULL,
 777         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 778         .tp_basicsize = sizeof(pytalloc_Object),
 779         .tp_new = py_srvsvc_NetCharDevQInfo0_new,
 780 };
 781
 782
 783 static PyObject *py_srvsvc_NetCharDevQCtr0_get_count(PyObject *obj, void *closure)
 784 {
 785         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
 786         PyObject *py_count;
 787         py_count = PyInt_FromLong(object->count);
 788         return py_count;
 789 }
 790
 791 static int py_srvsvc_NetCharDevQCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
 792 {
 793         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(py_obj);
 794         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 795         object->count = PyInt_AsLong(value);
 796         return 0;
 797 }
 798
 799 static PyObject *py_srvsvc_NetCharDevQCtr0_get_array(PyObject *obj, void *closure)
 800 {
 801         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(obj);
 802         PyObject *py_array;
 803         if (object->array == NULL) {
 804                 py_array = Py_None;
 805                 Py_INCREF(py_array);
 806         } else {
 807                 py_array = PyList_New(object->count);
 808                 if (py_array == NULL) {
 809                         return NULL;
 810                 }
 811                 {
 812                         int array_cntr_1;
 813                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
 814                                 PyObject *py_array_1;
 815                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo0_Type, object->array, &object->array[array_cntr_1]);
 816                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
 817                         }
 818                 }
 819         }
 820         return py_array;
 821 }
 822
 823 static int py_srvsvc_NetCharDevQCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
 824 {
 825         struct srvsvc_NetCharDevQCtr0 *object = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(py_obj);
 826         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
 827         if (value == Py_None) {
 828                 object->array = NULL;
 829         } else {
 830                 object->array = NULL;
 831                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 832                 {
 833                         int array_cntr_1;
 834                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
 835                         if (!object->array) { return -1;; }
 836                         talloc_set_name_const(object->array, "ARRAY: object->array");
 837                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
 838                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
 839                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
 840                                         PyErr_NoMemory();
 841                                         return -1;
 842                                 }
 843                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
 844                         }
 845                 }
 846         }
 847         return 0;
 848 }
 849
 850 static PyGetSetDef py_srvsvc_NetCharDevQCtr0_getsetters[] = {
 851         { discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr0_get_count, py_srvsvc_NetCharDevQCtr0_set_count },
 852         { discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr0_get_array, py_srvsvc_NetCharDevQCtr0_set_array },
 853         { NULL }
 854 };
 855
 856 static PyObject *py_srvsvc_NetCharDevQCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 857 {
 858         return pytalloc_new(struct srvsvc_NetCharDevQCtr0, type);
 859 }
 860
 861
 862 static PyTypeObject srvsvc_NetCharDevQCtr0_Type = {
 863         PyObject_HEAD_INIT(NULL) 0,
 864         .tp_name = "srvsvc.NetCharDevQCtr0",
 865         .tp_getset = py_srvsvc_NetCharDevQCtr0_getsetters,
 866         .tp_methods = NULL,
 867         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 868         .tp_basicsize = sizeof(pytalloc_Object),
 869         .tp_new = py_srvsvc_NetCharDevQCtr0_new,
 870 };
 871
 872
 873 static PyObject *py_srvsvc_NetCharDevQInfo1_get_device(PyObject *obj, void *closure)
 874 {
 875         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 876         PyObject *py_device;
 877         if (object->device == NULL) {
 878                 py_device = Py_None;
 879                 Py_INCREF(py_device);
 880         } else {
 881                 if (object->device == NULL) {
 882                         py_device = Py_None;
 883                         Py_INCREF(py_device);
 884                 } else {
 885                         py_device = PyUnicode_Decode(object->device, strlen(object->device), "utf-8", "ignore");
 886                 }
 887         }
 888         return py_device;
 889 }
 890
 891 static int py_srvsvc_NetCharDevQInfo1_set_device(PyObject *py_obj, PyObject *value, void *closure)
 892 {
 893         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 894         if (value == Py_None) {
 895                 object->device = NULL;
 896         } else {
 897                 object->device = NULL;
 898                 if (PyUnicode_Check(value)) {
 899                         object->device = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 900                 } else if (PyString_Check(value)) {
 901                         object->device = PyString_AS_STRING(value);
 902                 } else {
 903                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 904                         return -1;
 905                 }
 906         }
 907         return 0;
 908 }
 909
 910 static PyObject *py_srvsvc_NetCharDevQInfo1_get_priority(PyObject *obj, void *closure)
 911 {
 912         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 913         PyObject *py_priority;
 914         py_priority = PyInt_FromLong(object->priority);
 915         return py_priority;
 916 }
 917
 918 static int py_srvsvc_NetCharDevQInfo1_set_priority(PyObject *py_obj, PyObject *value, void *closure)
 919 {
 920         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 921         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 922         object->priority = PyInt_AsLong(value);
 923         return 0;
 924 }
 925
 926 static PyObject *py_srvsvc_NetCharDevQInfo1_get_devices(PyObject *obj, void *closure)
 927 {
 928         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 929         PyObject *py_devices;
 930         if (object->devices == NULL) {
 931                 py_devices = Py_None;
 932                 Py_INCREF(py_devices);
 933         } else {
 934                 if (object->devices == NULL) {
 935                         py_devices = Py_None;
 936                         Py_INCREF(py_devices);
 937                 } else {
 938                         py_devices = PyUnicode_Decode(object->devices, strlen(object->devices), "utf-8", "ignore");
 939                 }
 940         }
 941         return py_devices;
 942 }
 943
 944 static int py_srvsvc_NetCharDevQInfo1_set_devices(PyObject *py_obj, PyObject *value, void *closure)
 945 {
 946         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 947         if (value == Py_None) {
 948                 object->devices = NULL;
 949         } else {
 950                 object->devices = NULL;
 951                 if (PyUnicode_Check(value)) {
 952                         object->devices = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 953                 } else if (PyString_Check(value)) {
 954                         object->devices = PyString_AS_STRING(value);
 955                 } else {
 956                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 957                         return -1;
 958                 }
 959         }
 960         return 0;
 961 }
 962
 963 static PyObject *py_srvsvc_NetCharDevQInfo1_get_users(PyObject *obj, void *closure)
 964 {
 965         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 966         PyObject *py_users;
 967         py_users = PyInt_FromLong(object->users);
 968         return py_users;
 969 }
 970
 971 static int py_srvsvc_NetCharDevQInfo1_set_users(PyObject *py_obj, PyObject *value, void *closure)
 972 {
 973         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 974         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 975         object->users = PyInt_AsLong(value);
 976         return 0;
 977 }
 978
 979 static PyObject *py_srvsvc_NetCharDevQInfo1_get_num_ahead(PyObject *obj, void *closure)
 980 {
 981         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(obj);
 982         PyObject *py_num_ahead;
 983         py_num_ahead = PyInt_FromLong(object->num_ahead);
 984         return py_num_ahead;
 985 }
 986
 987 static int py_srvsvc_NetCharDevQInfo1_set_num_ahead(PyObject *py_obj, PyObject *value, void *closure)
 988 {
 989         struct srvsvc_NetCharDevQInfo1 *object = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(py_obj);
 990         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 991         object->num_ahead = PyInt_AsLong(value);
 992         return 0;
 993 }
 994
 995 static PyGetSetDef py_srvsvc_NetCharDevQInfo1_getsetters[] = {
 996         { discard_const_p(char, "device"), py_srvsvc_NetCharDevQInfo1_get_device, py_srvsvc_NetCharDevQInfo1_set_device },
 997         { discard_const_p(char, "priority"), py_srvsvc_NetCharDevQInfo1_get_priority, py_srvsvc_NetCharDevQInfo1_set_priority },
 998         { discard_const_p(char, "devices"), py_srvsvc_NetCharDevQInfo1_get_devices, py_srvsvc_NetCharDevQInfo1_set_devices },
 999         { discard_const_p(char, "users"), py_srvsvc_NetCharDevQInfo1_get_users, py_srvsvc_NetCharDevQInfo1_set_users },
1000         { discard_const_p(char, "num_ahead"), py_srvsvc_NetCharDevQInfo1_get_num_ahead, py_srvsvc_NetCharDevQInfo1_set_num_ahead },
1001         { NULL }
1002 };
1003
1004 static PyObject *py_srvsvc_NetCharDevQInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1005 {
1006         return pytalloc_new(struct srvsvc_NetCharDevQInfo1, type);
1007 }
1008
1009
1010 static PyTypeObject srvsvc_NetCharDevQInfo1_Type = {
1011         PyObject_HEAD_INIT(NULL) 0,
1012         .tp_name = "srvsvc.NetCharDevQInfo1",
1013         .tp_getset = py_srvsvc_NetCharDevQInfo1_getsetters,
1014         .tp_methods = NULL,
1015         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1016         .tp_basicsize = sizeof(pytalloc_Object),
1017         .tp_new = py_srvsvc_NetCharDevQInfo1_new,
1018 };
1019
1020
1021 static PyObject *py_srvsvc_NetCharDevQCtr1_get_count(PyObject *obj, void *closure)
1022 {
1023         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
1024         PyObject *py_count;
1025         py_count = PyInt_FromLong(object->count);
1026         return py_count;
1027 }
1028
1029 static int py_srvsvc_NetCharDevQCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
1030 {
1031         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(py_obj);
1032         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1033         object->count = PyInt_AsLong(value);
1034         return 0;
1035 }
1036
1037 static PyObject *py_srvsvc_NetCharDevQCtr1_get_array(PyObject *obj, void *closure)
1038 {
1039         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(obj);
1040         PyObject *py_array;
1041         if (object->array == NULL) {
1042                 py_array = Py_None;
1043                 Py_INCREF(py_array);
1044         } else {
1045                 py_array = PyList_New(object->count);
1046                 if (py_array == NULL) {
1047                         return NULL;
1048                 }
1049                 {
1050                         int array_cntr_1;
1051                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1052                                 PyObject *py_array_1;
1053                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo1_Type, object->array, &object->array[array_cntr_1]);
1054                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1055                         }
1056                 }
1057         }
1058         return py_array;
1059 }
1060
1061 static int py_srvsvc_NetCharDevQCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
1062 {
1063         struct srvsvc_NetCharDevQCtr1 *object = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(py_obj);
1064         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1065         if (value == Py_None) {
1066                 object->array = NULL;
1067         } else {
1068                 object->array = NULL;
1069                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1070                 {
1071                         int array_cntr_1;
1072                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1073                         if (!object->array) { return -1;; }
1074                         talloc_set_name_const(object->array, "ARRAY: object->array");
1075                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1076                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1077                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1078                                         PyErr_NoMemory();
1079                                         return -1;
1080                                 }
1081                                 object->array[array_cntr_1] = *(struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1082                         }
1083                 }
1084         }
1085         return 0;
1086 }
1087
1088 static PyGetSetDef py_srvsvc_NetCharDevQCtr1_getsetters[] = {
1089         { discard_const_p(char, "count"), py_srvsvc_NetCharDevQCtr1_get_count, py_srvsvc_NetCharDevQCtr1_set_count },
1090         { discard_const_p(char, "array"), py_srvsvc_NetCharDevQCtr1_get_array, py_srvsvc_NetCharDevQCtr1_set_array },
1091         { NULL }
1092 };
1093
1094 static PyObject *py_srvsvc_NetCharDevQCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1095 {
1096         return pytalloc_new(struct srvsvc_NetCharDevQCtr1, type);
1097 }
1098
1099
1100 static PyTypeObject srvsvc_NetCharDevQCtr1_Type = {
1101         PyObject_HEAD_INIT(NULL) 0,
1102         .tp_name = "srvsvc.NetCharDevQCtr1",
1103         .tp_getset = py_srvsvc_NetCharDevQCtr1_getsetters,
1104         .tp_methods = NULL,
1105         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1106         .tp_basicsize = sizeof(pytalloc_Object),
1107         .tp_new = py_srvsvc_NetCharDevQCtr1_new,
1108 };
1109
1110 PyObject *py_import_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQInfo *in)
1111 {
1112         PyObject *ret;
1113
1114         switch (level) {
1115                 case 0:
1116                         if (in->info0 == NULL) {
1117                                 ret = Py_None;
1118                                 Py_INCREF(ret);
1119                         } else {
1120                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo0_Type, in->info0, in->info0);
1121                         }
1122                         return ret;
1123
1124                 case 1:
1125                         if (in->info1 == NULL) {
1126                                 ret = Py_None;
1127                                 Py_INCREF(ret);
1128                         } else {
1129                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQInfo1_Type, in->info1, in->info1);
1130                         }
1131                         return ret;
1132
1133                 default:
1134                         ret = Py_None;
1135                         Py_INCREF(ret);
1136                         return ret;
1137
1138         }
1139         PyErr_SetString(PyExc_TypeError, "unknown union level");
1140         return NULL;
1141 }
1142
1143 union srvsvc_NetCharDevQInfo *py_export_srvsvc_NetCharDevQInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1144 {
1145         union srvsvc_NetCharDevQInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQInfo);
1146         switch (level) {
1147                 case 0:
1148                         if (in == Py_None) {
1149                                 ret->info0 = NULL;
1150                         } else {
1151                                 ret->info0 = NULL;
1152                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo0_Type, in, talloc_free(ret); return NULL;);
1153                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1154                                         PyErr_NoMemory();
1155                                         talloc_free(ret); return NULL;
1156                                 }
1157                                 ret->info0 = (struct srvsvc_NetCharDevQInfo0 *)pytalloc_get_ptr(in);
1158                         }
1159                         break;
1160
1161                 case 1:
1162                         if (in == Py_None) {
1163                                 ret->info1 = NULL;
1164                         } else {
1165                                 ret->info1 = NULL;
1166                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQInfo1_Type, in, talloc_free(ret); return NULL;);
1167                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1168                                         PyErr_NoMemory();
1169                                         talloc_free(ret); return NULL;
1170                                 }
1171                                 ret->info1 = (struct srvsvc_NetCharDevQInfo1 *)pytalloc_get_ptr(in);
1172                         }
1173                         break;
1174
1175                 default:
1176                         break;
1177
1178         }
1179
1180         return ret;
1181 }
1182
1183 PyObject *py_import_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetCharDevQCtr *in)
1184 {
1185         PyObject *ret;
1186
1187         switch (level) {
1188                 case 0:
1189                         if (in->ctr0 == NULL) {
1190                                 ret = Py_None;
1191                                 Py_INCREF(ret);
1192                         } else {
1193                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr0_Type, in->ctr0, in->ctr0);
1194                         }
1195                         return ret;
1196
1197                 case 1:
1198                         if (in->ctr1 == NULL) {
1199                                 ret = Py_None;
1200                                 Py_INCREF(ret);
1201                         } else {
1202                                 ret = pytalloc_reference_ex(&srvsvc_NetCharDevQCtr1_Type, in->ctr1, in->ctr1);
1203                         }
1204                         return ret;
1205
1206                 default:
1207                         ret = Py_None;
1208                         Py_INCREF(ret);
1209                         return ret;
1210
1211         }
1212         PyErr_SetString(PyExc_TypeError, "unknown union level");
1213         return NULL;
1214 }
1215
1216 union srvsvc_NetCharDevQCtr *py_export_srvsvc_NetCharDevQCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1217 {
1218         union srvsvc_NetCharDevQCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetCharDevQCtr);
1219         switch (level) {
1220                 case 0:
1221                         if (in == Py_None) {
1222                                 ret->ctr0 = NULL;
1223                         } else {
1224                                 ret->ctr0 = NULL;
1225                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr0_Type, in, talloc_free(ret); return NULL;);
1226                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1227                                         PyErr_NoMemory();
1228                                         talloc_free(ret); return NULL;
1229                                 }
1230                                 ret->ctr0 = (struct srvsvc_NetCharDevQCtr0 *)pytalloc_get_ptr(in);
1231                         }
1232                         break;
1233
1234                 case 1:
1235                         if (in == Py_None) {
1236                                 ret->ctr1 = NULL;
1237                         } else {
1238                                 ret->ctr1 = NULL;
1239                                 PY_CHECK_TYPE(&srvsvc_NetCharDevQCtr1_Type, in, talloc_free(ret); return NULL;);
1240                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1241                                         PyErr_NoMemory();
1242                                         talloc_free(ret); return NULL;
1243                                 }
1244                                 ret->ctr1 = (struct srvsvc_NetCharDevQCtr1 *)pytalloc_get_ptr(in);
1245                         }
1246                         break;
1247
1248                 default:
1249                         break;
1250
1251         }
1252
1253         return ret;
1254 }
1255
1256
1257 static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_level(PyObject *obj, void *closure)
1258 {
1259         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
1260         PyObject *py_level;
1261         py_level = PyInt_FromLong(object->level);
1262         return py_level;
1263 }
1264
1265 static int py_srvsvc_NetCharDevQInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
1266 {
1267         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_obj);
1268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1269         object->level = PyInt_AsLong(value);
1270         return 0;
1271 }
1272
1273 static PyObject *py_srvsvc_NetCharDevQInfoCtr_get_ctr(PyObject *obj, void *closure)
1274 {
1275         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(obj);
1276         PyObject *py_ctr;
1277         py_ctr = py_import_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
1278         if (py_ctr == NULL) {
1279                 return NULL;
1280         }
1281         return py_ctr;
1282 }
1283
1284 static int py_srvsvc_NetCharDevQInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
1285 {
1286         struct srvsvc_NetCharDevQInfoCtr *object = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_obj);
1287         {
1288                 union srvsvc_NetCharDevQCtr *ctr_switch_0;
1289                 ctr_switch_0 = py_export_srvsvc_NetCharDevQCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
1290                 if (ctr_switch_0 == NULL) {
1291                         return -1;
1292                 }
1293                 object->ctr = *ctr_switch_0;
1294         }
1295         return 0;
1296 }
1297
1298 static PyGetSetDef py_srvsvc_NetCharDevQInfoCtr_getsetters[] = {
1299         { discard_const_p(char, "level"), py_srvsvc_NetCharDevQInfoCtr_get_level, py_srvsvc_NetCharDevQInfoCtr_set_level },
1300         { discard_const_p(char, "ctr"), py_srvsvc_NetCharDevQInfoCtr_get_ctr, py_srvsvc_NetCharDevQInfoCtr_set_ctr },
1301         { NULL }
1302 };
1303
1304 static PyObject *py_srvsvc_NetCharDevQInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1305 {
1306         return pytalloc_new(struct srvsvc_NetCharDevQInfoCtr, type);
1307 }
1308
1309
1310 static PyTypeObject srvsvc_NetCharDevQInfoCtr_Type = {
1311         PyObject_HEAD_INIT(NULL) 0,
1312         .tp_name = "srvsvc.NetCharDevQInfoCtr",
1313         .tp_getset = py_srvsvc_NetCharDevQInfoCtr_getsetters,
1314         .tp_methods = NULL,
1315         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1316         .tp_basicsize = sizeof(pytalloc_Object),
1317         .tp_new = py_srvsvc_NetCharDevQInfoCtr_new,
1318 };
1319
1320
1321 static PyObject *py_srvsvc_NetConnInfo0_get_conn_id(PyObject *obj, void *closure)
1322 {
1323         struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(obj);
1324         PyObject *py_conn_id;
1325         py_conn_id = PyInt_FromLong(object->conn_id);
1326         return py_conn_id;
1327 }
1328
1329 static int py_srvsvc_NetConnInfo0_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
1330 {
1331         struct srvsvc_NetConnInfo0 *object = (struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(py_obj);
1332         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1333         object->conn_id = PyInt_AsLong(value);
1334         return 0;
1335 }
1336
1337 static PyGetSetDef py_srvsvc_NetConnInfo0_getsetters[] = {
1338         { discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo0_get_conn_id, py_srvsvc_NetConnInfo0_set_conn_id },
1339         { NULL }
1340 };
1341
1342 static PyObject *py_srvsvc_NetConnInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1343 {
1344         return pytalloc_new(struct srvsvc_NetConnInfo0, type);
1345 }
1346
1347
1348 static PyTypeObject srvsvc_NetConnInfo0_Type = {
1349         PyObject_HEAD_INIT(NULL) 0,
1350         .tp_name = "srvsvc.NetConnInfo0",
1351         .tp_getset = py_srvsvc_NetConnInfo0_getsetters,
1352         .tp_methods = NULL,
1353         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1354         .tp_basicsize = sizeof(pytalloc_Object),
1355         .tp_new = py_srvsvc_NetConnInfo0_new,
1356 };
1357
1358
1359 static PyObject *py_srvsvc_NetConnCtr0_get_count(PyObject *obj, void *closure)
1360 {
1361         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
1362         PyObject *py_count;
1363         py_count = PyInt_FromLong(object->count);
1364         return py_count;
1365 }
1366
1367 static int py_srvsvc_NetConnCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
1368 {
1369         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(py_obj);
1370         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1371         object->count = PyInt_AsLong(value);
1372         return 0;
1373 }
1374
1375 static PyObject *py_srvsvc_NetConnCtr0_get_array(PyObject *obj, void *closure)
1376 {
1377         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(obj);
1378         PyObject *py_array;
1379         if (object->array == NULL) {
1380                 py_array = Py_None;
1381                 Py_INCREF(py_array);
1382         } else {
1383                 py_array = PyList_New(object->count);
1384                 if (py_array == NULL) {
1385                         return NULL;
1386                 }
1387                 {
1388                         int array_cntr_1;
1389                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1390                                 PyObject *py_array_1;
1391                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo0_Type, object->array, &object->array[array_cntr_1]);
1392                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1393                         }
1394                 }
1395         }
1396         return py_array;
1397 }
1398
1399 static int py_srvsvc_NetConnCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
1400 {
1401         struct srvsvc_NetConnCtr0 *object = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(py_obj);
1402         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1403         if (value == Py_None) {
1404                 object->array = NULL;
1405         } else {
1406                 object->array = NULL;
1407                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1408                 {
1409                         int array_cntr_1;
1410                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1411                         if (!object->array) { return -1;; }
1412                         talloc_set_name_const(object->array, "ARRAY: object->array");
1413                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1414                                 PY_CHECK_TYPE(&srvsvc_NetConnInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1415                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1416                                         PyErr_NoMemory();
1417                                         return -1;
1418                                 }
1419                                 object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1420                         }
1421                 }
1422         }
1423         return 0;
1424 }
1425
1426 static PyGetSetDef py_srvsvc_NetConnCtr0_getsetters[] = {
1427         { discard_const_p(char, "count"), py_srvsvc_NetConnCtr0_get_count, py_srvsvc_NetConnCtr0_set_count },
1428         { discard_const_p(char, "array"), py_srvsvc_NetConnCtr0_get_array, py_srvsvc_NetConnCtr0_set_array },
1429         { NULL }
1430 };
1431
1432 static PyObject *py_srvsvc_NetConnCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1433 {
1434         return pytalloc_new(struct srvsvc_NetConnCtr0, type);
1435 }
1436
1437
1438 static PyTypeObject srvsvc_NetConnCtr0_Type = {
1439         PyObject_HEAD_INIT(NULL) 0,
1440         .tp_name = "srvsvc.NetConnCtr0",
1441         .tp_getset = py_srvsvc_NetConnCtr0_getsetters,
1442         .tp_methods = NULL,
1443         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1444         .tp_basicsize = sizeof(pytalloc_Object),
1445         .tp_new = py_srvsvc_NetConnCtr0_new,
1446 };
1447
1448
1449 static PyObject *py_srvsvc_NetConnInfo1_get_conn_id(PyObject *obj, void *closure)
1450 {
1451         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1452         PyObject *py_conn_id;
1453         py_conn_id = PyInt_FromLong(object->conn_id);
1454         return py_conn_id;
1455 }
1456
1457 static int py_srvsvc_NetConnInfo1_set_conn_id(PyObject *py_obj, PyObject *value, void *closure)
1458 {
1459         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1460         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1461         object->conn_id = PyInt_AsLong(value);
1462         return 0;
1463 }
1464
1465 static PyObject *py_srvsvc_NetConnInfo1_get_conn_type(PyObject *obj, void *closure)
1466 {
1467         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1468         PyObject *py_conn_type;
1469         py_conn_type = PyInt_FromLong(object->conn_type);
1470         return py_conn_type;
1471 }
1472
1473 static int py_srvsvc_NetConnInfo1_set_conn_type(PyObject *py_obj, PyObject *value, void *closure)
1474 {
1475         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1476         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1477         object->conn_type = PyInt_AsLong(value);
1478         return 0;
1479 }
1480
1481 static PyObject *py_srvsvc_NetConnInfo1_get_num_open(PyObject *obj, void *closure)
1482 {
1483         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1484         PyObject *py_num_open;
1485         py_num_open = PyInt_FromLong(object->num_open);
1486         return py_num_open;
1487 }
1488
1489 static int py_srvsvc_NetConnInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
1490 {
1491         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1492         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1493         object->num_open = PyInt_AsLong(value);
1494         return 0;
1495 }
1496
1497 static PyObject *py_srvsvc_NetConnInfo1_get_num_users(PyObject *obj, void *closure)
1498 {
1499         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1500         PyObject *py_num_users;
1501         py_num_users = PyInt_FromLong(object->num_users);
1502         return py_num_users;
1503 }
1504
1505 static int py_srvsvc_NetConnInfo1_set_num_users(PyObject *py_obj, PyObject *value, void *closure)
1506 {
1507         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1508         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1509         object->num_users = PyInt_AsLong(value);
1510         return 0;
1511 }
1512
1513 static PyObject *py_srvsvc_NetConnInfo1_get_conn_time(PyObject *obj, void *closure)
1514 {
1515         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1516         PyObject *py_conn_time;
1517         py_conn_time = PyInt_FromLong(object->conn_time);
1518         return py_conn_time;
1519 }
1520
1521 static int py_srvsvc_NetConnInfo1_set_conn_time(PyObject *py_obj, PyObject *value, void *closure)
1522 {
1523         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1524         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1525         object->conn_time = PyInt_AsLong(value);
1526         return 0;
1527 }
1528
1529 static PyObject *py_srvsvc_NetConnInfo1_get_user(PyObject *obj, void *closure)
1530 {
1531         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1532         PyObject *py_user;
1533         if (object->user == NULL) {
1534                 py_user = Py_None;
1535                 Py_INCREF(py_user);
1536         } else {
1537                 if (object->user == NULL) {
1538                         py_user = Py_None;
1539                         Py_INCREF(py_user);
1540                 } else {
1541                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
1542                 }
1543         }
1544         return py_user;
1545 }
1546
1547 static int py_srvsvc_NetConnInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
1548 {
1549         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1550         if (value == Py_None) {
1551                 object->user = NULL;
1552         } else {
1553                 object->user = NULL;
1554                 if (PyUnicode_Check(value)) {
1555                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
1556                 } else if (PyString_Check(value)) {
1557                         object->user = PyString_AS_STRING(value);
1558                 } else {
1559                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
1560                         return -1;
1561                 }
1562         }
1563         return 0;
1564 }
1565
1566 static PyObject *py_srvsvc_NetConnInfo1_get_share(PyObject *obj, void *closure)
1567 {
1568         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(obj);
1569         PyObject *py_share;
1570         if (object->share == NULL) {
1571                 py_share = Py_None;
1572                 Py_INCREF(py_share);
1573         } else {
1574                 if (object->share == NULL) {
1575                         py_share = Py_None;
1576                         Py_INCREF(py_share);
1577                 } else {
1578                         py_share = PyUnicode_Decode(object->share, strlen(object->share), "utf-8", "ignore");
1579                 }
1580         }
1581         return py_share;
1582 }
1583
1584 static int py_srvsvc_NetConnInfo1_set_share(PyObject *py_obj, PyObject *value, void *closure)
1585 {
1586         struct srvsvc_NetConnInfo1 *object = (struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(py_obj);
1587         if (value == Py_None) {
1588                 object->share = NULL;
1589         } else {
1590                 object->share = NULL;
1591                 if (PyUnicode_Check(value)) {
1592                         object->share = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
1593                 } else if (PyString_Check(value)) {
1594                         object->share = PyString_AS_STRING(value);
1595                 } else {
1596                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
1597                         return -1;
1598                 }
1599         }
1600         return 0;
1601 }
1602
1603 static PyGetSetDef py_srvsvc_NetConnInfo1_getsetters[] = {
1604         { discard_const_p(char, "conn_id"), py_srvsvc_NetConnInfo1_get_conn_id, py_srvsvc_NetConnInfo1_set_conn_id },
1605         { discard_const_p(char, "conn_type"), py_srvsvc_NetConnInfo1_get_conn_type, py_srvsvc_NetConnInfo1_set_conn_type },
1606         { discard_const_p(char, "num_open"), py_srvsvc_NetConnInfo1_get_num_open, py_srvsvc_NetConnInfo1_set_num_open },
1607         { discard_const_p(char, "num_users"), py_srvsvc_NetConnInfo1_get_num_users, py_srvsvc_NetConnInfo1_set_num_users },
1608         { discard_const_p(char, "conn_time"), py_srvsvc_NetConnInfo1_get_conn_time, py_srvsvc_NetConnInfo1_set_conn_time },
1609         { discard_const_p(char, "user"), py_srvsvc_NetConnInfo1_get_user, py_srvsvc_NetConnInfo1_set_user },
1610         { discard_const_p(char, "share"), py_srvsvc_NetConnInfo1_get_share, py_srvsvc_NetConnInfo1_set_share },
1611         { NULL }
1612 };
1613
1614 static PyObject *py_srvsvc_NetConnInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1615 {
1616         return pytalloc_new(struct srvsvc_NetConnInfo1, type);
1617 }
1618
1619
1620 static PyTypeObject srvsvc_NetConnInfo1_Type = {
1621         PyObject_HEAD_INIT(NULL) 0,
1622         .tp_name = "srvsvc.NetConnInfo1",
1623         .tp_getset = py_srvsvc_NetConnInfo1_getsetters,
1624         .tp_methods = NULL,
1625         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1626         .tp_basicsize = sizeof(pytalloc_Object),
1627         .tp_new = py_srvsvc_NetConnInfo1_new,
1628 };
1629
1630
1631 static PyObject *py_srvsvc_NetConnCtr1_get_count(PyObject *obj, void *closure)
1632 {
1633         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
1634         PyObject *py_count;
1635         py_count = PyInt_FromLong(object->count);
1636         return py_count;
1637 }
1638
1639 static int py_srvsvc_NetConnCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
1640 {
1641         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(py_obj);
1642         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1643         object->count = PyInt_AsLong(value);
1644         return 0;
1645 }
1646
1647 static PyObject *py_srvsvc_NetConnCtr1_get_array(PyObject *obj, void *closure)
1648 {
1649         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(obj);
1650         PyObject *py_array;
1651         if (object->array == NULL) {
1652                 py_array = Py_None;
1653                 Py_INCREF(py_array);
1654         } else {
1655                 py_array = PyList_New(object->count);
1656                 if (py_array == NULL) {
1657                         return NULL;
1658                 }
1659                 {
1660                         int array_cntr_1;
1661                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1662                                 PyObject *py_array_1;
1663                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetConnInfo1_Type, object->array, &object->array[array_cntr_1]);
1664                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1665                         }
1666                 }
1667         }
1668         return py_array;
1669 }
1670
1671 static int py_srvsvc_NetConnCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
1672 {
1673         struct srvsvc_NetConnCtr1 *object = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(py_obj);
1674         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1675         if (value == Py_None) {
1676                 object->array = NULL;
1677         } else {
1678                 object->array = NULL;
1679                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1680                 {
1681                         int array_cntr_1;
1682                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1683                         if (!object->array) { return -1;; }
1684                         talloc_set_name_const(object->array, "ARRAY: object->array");
1685                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1686                                 PY_CHECK_TYPE(&srvsvc_NetConnInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1687                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1688                                         PyErr_NoMemory();
1689                                         return -1;
1690                                 }
1691                                 object->array[array_cntr_1] = *(struct srvsvc_NetConnInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1692                         }
1693                 }
1694         }
1695         return 0;
1696 }
1697
1698 static PyGetSetDef py_srvsvc_NetConnCtr1_getsetters[] = {
1699         { discard_const_p(char, "count"), py_srvsvc_NetConnCtr1_get_count, py_srvsvc_NetConnCtr1_set_count },
1700         { discard_const_p(char, "array"), py_srvsvc_NetConnCtr1_get_array, py_srvsvc_NetConnCtr1_set_array },
1701         { NULL }
1702 };
1703
1704 static PyObject *py_srvsvc_NetConnCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1705 {
1706         return pytalloc_new(struct srvsvc_NetConnCtr1, type);
1707 }
1708
1709
1710 static PyTypeObject srvsvc_NetConnCtr1_Type = {
1711         PyObject_HEAD_INIT(NULL) 0,
1712         .tp_name = "srvsvc.NetConnCtr1",
1713         .tp_getset = py_srvsvc_NetConnCtr1_getsetters,
1714         .tp_methods = NULL,
1715         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1716         .tp_basicsize = sizeof(pytalloc_Object),
1717         .tp_new = py_srvsvc_NetConnCtr1_new,
1718 };
1719
1720 PyObject *py_import_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetConnCtr *in)
1721 {
1722         PyObject *ret;
1723
1724         switch (level) {
1725                 case 0:
1726                         if (in->ctr0 == NULL) {
1727                                 ret = Py_None;
1728                                 Py_INCREF(ret);
1729                         } else {
1730                                 ret = pytalloc_reference_ex(&srvsvc_NetConnCtr0_Type, in->ctr0, in->ctr0);
1731                         }
1732                         return ret;
1733
1734                 case 1:
1735                         if (in->ctr1 == NULL) {
1736                                 ret = Py_None;
1737                                 Py_INCREF(ret);
1738                         } else {
1739                                 ret = pytalloc_reference_ex(&srvsvc_NetConnCtr1_Type, in->ctr1, in->ctr1);
1740                         }
1741                         return ret;
1742
1743                 default:
1744                         ret = Py_None;
1745                         Py_INCREF(ret);
1746                         return ret;
1747
1748         }
1749         PyErr_SetString(PyExc_TypeError, "unknown union level");
1750         return NULL;
1751 }
1752
1753 union srvsvc_NetConnCtr *py_export_srvsvc_NetConnCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1754 {
1755         union srvsvc_NetConnCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetConnCtr);
1756         switch (level) {
1757                 case 0:
1758                         if (in == Py_None) {
1759                                 ret->ctr0 = NULL;
1760                         } else {
1761                                 ret->ctr0 = NULL;
1762                                 PY_CHECK_TYPE(&srvsvc_NetConnCtr0_Type, in, talloc_free(ret); return NULL;);
1763                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1764                                         PyErr_NoMemory();
1765                                         talloc_free(ret); return NULL;
1766                                 }
1767                                 ret->ctr0 = (struct srvsvc_NetConnCtr0 *)pytalloc_get_ptr(in);
1768                         }
1769                         break;
1770
1771                 case 1:
1772                         if (in == Py_None) {
1773                                 ret->ctr1 = NULL;
1774                         } else {
1775                                 ret->ctr1 = NULL;
1776                                 PY_CHECK_TYPE(&srvsvc_NetConnCtr1_Type, in, talloc_free(ret); return NULL;);
1777                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1778                                         PyErr_NoMemory();
1779                                         talloc_free(ret); return NULL;
1780                                 }
1781                                 ret->ctr1 = (struct srvsvc_NetConnCtr1 *)pytalloc_get_ptr(in);
1782                         }
1783                         break;
1784
1785                 default:
1786                         break;
1787
1788         }
1789
1790         return ret;
1791 }
1792
1793
1794 static PyObject *py_srvsvc_NetConnInfoCtr_get_level(PyObject *obj, void *closure)
1795 {
1796         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
1797         PyObject *py_level;
1798         py_level = PyInt_FromLong(object->level);
1799         return py_level;
1800 }
1801
1802 static int py_srvsvc_NetConnInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
1803 {
1804         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_obj);
1805         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1806         object->level = PyInt_AsLong(value);
1807         return 0;
1808 }
1809
1810 static PyObject *py_srvsvc_NetConnInfoCtr_get_ctr(PyObject *obj, void *closure)
1811 {
1812         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(obj);
1813         PyObject *py_ctr;
1814         py_ctr = py_import_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
1815         if (py_ctr == NULL) {
1816                 return NULL;
1817         }
1818         return py_ctr;
1819 }
1820
1821 static int py_srvsvc_NetConnInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
1822 {
1823         struct srvsvc_NetConnInfoCtr *object = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_obj);
1824         {
1825                 union srvsvc_NetConnCtr *ctr_switch_0;
1826                 ctr_switch_0 = py_export_srvsvc_NetConnCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
1827                 if (ctr_switch_0 == NULL) {
1828                         return -1;
1829                 }
1830                 object->ctr = *ctr_switch_0;
1831         }
1832         return 0;
1833 }
1834
1835 static PyGetSetDef py_srvsvc_NetConnInfoCtr_getsetters[] = {
1836         { discard_const_p(char, "level"), py_srvsvc_NetConnInfoCtr_get_level, py_srvsvc_NetConnInfoCtr_set_level },
1837         { discard_const_p(char, "ctr"), py_srvsvc_NetConnInfoCtr_get_ctr, py_srvsvc_NetConnInfoCtr_set_ctr },
1838         { NULL }
1839 };
1840
1841 static PyObject *py_srvsvc_NetConnInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1842 {
1843         return pytalloc_new(struct srvsvc_NetConnInfoCtr, type);
1844 }
1845
1846
1847 static PyTypeObject srvsvc_NetConnInfoCtr_Type = {
1848         PyObject_HEAD_INIT(NULL) 0,
1849         .tp_name = "srvsvc.NetConnInfoCtr",
1850         .tp_getset = py_srvsvc_NetConnInfoCtr_getsetters,
1851         .tp_methods = NULL,
1852         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1853         .tp_basicsize = sizeof(pytalloc_Object),
1854         .tp_new = py_srvsvc_NetConnInfoCtr_new,
1855 };
1856
1857
1858 static PyObject *py_srvsvc_NetFileInfo2_get_fid(PyObject *obj, void *closure)
1859 {
1860         struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(obj);
1861         PyObject *py_fid;
1862         py_fid = PyInt_FromLong(object->fid);
1863         return py_fid;
1864 }
1865
1866 static int py_srvsvc_NetFileInfo2_set_fid(PyObject *py_obj, PyObject *value, void *closure)
1867 {
1868         struct srvsvc_NetFileInfo2 *object = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(py_obj);
1869         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1870         object->fid = PyInt_AsLong(value);
1871         return 0;
1872 }
1873
1874 static PyGetSetDef py_srvsvc_NetFileInfo2_getsetters[] = {
1875         { discard_const_p(char, "fid"), py_srvsvc_NetFileInfo2_get_fid, py_srvsvc_NetFileInfo2_set_fid },
1876         { NULL }
1877 };
1878
1879 static PyObject *py_srvsvc_NetFileInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1880 {
1881         return pytalloc_new(struct srvsvc_NetFileInfo2, type);
1882 }
1883
1884
1885 static PyTypeObject srvsvc_NetFileInfo2_Type = {
1886         PyObject_HEAD_INIT(NULL) 0,
1887         .tp_name = "srvsvc.NetFileInfo2",
1888         .tp_getset = py_srvsvc_NetFileInfo2_getsetters,
1889         .tp_methods = NULL,
1890         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1891         .tp_basicsize = sizeof(pytalloc_Object),
1892         .tp_new = py_srvsvc_NetFileInfo2_new,
1893 };
1894
1895
1896 static PyObject *py_srvsvc_NetFileCtr2_get_count(PyObject *obj, void *closure)
1897 {
1898         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
1899         PyObject *py_count;
1900         py_count = PyInt_FromLong(object->count);
1901         return py_count;
1902 }
1903
1904 static int py_srvsvc_NetFileCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
1905 {
1906         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(py_obj);
1907         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1908         object->count = PyInt_AsLong(value);
1909         return 0;
1910 }
1911
1912 static PyObject *py_srvsvc_NetFileCtr2_get_array(PyObject *obj, void *closure)
1913 {
1914         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(obj);
1915         PyObject *py_array;
1916         if (object->array == NULL) {
1917                 py_array = Py_None;
1918                 Py_INCREF(py_array);
1919         } else {
1920                 py_array = PyList_New(object->count);
1921                 if (py_array == NULL) {
1922                         return NULL;
1923                 }
1924                 {
1925                         int array_cntr_1;
1926                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
1927                                 PyObject *py_array_1;
1928                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, object->array, &object->array[array_cntr_1]);
1929                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
1930                         }
1931                 }
1932         }
1933         return py_array;
1934 }
1935
1936 static int py_srvsvc_NetFileCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
1937 {
1938         struct srvsvc_NetFileCtr2 *object = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(py_obj);
1939         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
1940         if (value == Py_None) {
1941                 object->array = NULL;
1942         } else {
1943                 object->array = NULL;
1944                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1945                 {
1946                         int array_cntr_1;
1947                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
1948                         if (!object->array) { return -1;; }
1949                         talloc_set_name_const(object->array, "ARRAY: object->array");
1950                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
1951                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
1952                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
1953                                         PyErr_NoMemory();
1954                                         return -1;
1955                                 }
1956                                 object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
1957                         }
1958                 }
1959         }
1960         return 0;
1961 }
1962
1963 static PyGetSetDef py_srvsvc_NetFileCtr2_getsetters[] = {
1964         { discard_const_p(char, "count"), py_srvsvc_NetFileCtr2_get_count, py_srvsvc_NetFileCtr2_set_count },
1965         { discard_const_p(char, "array"), py_srvsvc_NetFileCtr2_get_array, py_srvsvc_NetFileCtr2_set_array },
1966         { NULL }
1967 };
1968
1969 static PyObject *py_srvsvc_NetFileCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1970 {
1971         return pytalloc_new(struct srvsvc_NetFileCtr2, type);
1972 }
1973
1974
1975 static PyTypeObject srvsvc_NetFileCtr2_Type = {
1976         PyObject_HEAD_INIT(NULL) 0,
1977         .tp_name = "srvsvc.NetFileCtr2",
1978         .tp_getset = py_srvsvc_NetFileCtr2_getsetters,
1979         .tp_methods = NULL,
1980         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1981         .tp_basicsize = sizeof(pytalloc_Object),
1982         .tp_new = py_srvsvc_NetFileCtr2_new,
1983 };
1984
1985
1986 static PyObject *py_srvsvc_NetFileInfo3_get_fid(PyObject *obj, void *closure)
1987 {
1988         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
1989         PyObject *py_fid;
1990         py_fid = PyInt_FromLong(object->fid);
1991         return py_fid;
1992 }
1993
1994 static int py_srvsvc_NetFileInfo3_set_fid(PyObject *py_obj, PyObject *value, void *closure)
1995 {
1996         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
1997         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1998         object->fid = PyInt_AsLong(value);
1999         return 0;
2000 }
2001
2002 static PyObject *py_srvsvc_NetFileInfo3_get_permissions(PyObject *obj, void *closure)
2003 {
2004         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2005         PyObject *py_permissions;
2006         py_permissions = PyInt_FromLong(object->permissions);
2007         return py_permissions;
2008 }
2009
2010 static int py_srvsvc_NetFileInfo3_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
2011 {
2012         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2013         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2014         object->permissions = PyInt_AsLong(value);
2015         return 0;
2016 }
2017
2018 static PyObject *py_srvsvc_NetFileInfo3_get_num_locks(PyObject *obj, void *closure)
2019 {
2020         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2021         PyObject *py_num_locks;
2022         py_num_locks = PyInt_FromLong(object->num_locks);
2023         return py_num_locks;
2024 }
2025
2026 static int py_srvsvc_NetFileInfo3_set_num_locks(PyObject *py_obj, PyObject *value, void *closure)
2027 {
2028         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2029         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2030         object->num_locks = PyInt_AsLong(value);
2031         return 0;
2032 }
2033
2034 static PyObject *py_srvsvc_NetFileInfo3_get_path(PyObject *obj, void *closure)
2035 {
2036         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2037         PyObject *py_path;
2038         if (object->path == NULL) {
2039                 py_path = Py_None;
2040                 Py_INCREF(py_path);
2041         } else {
2042                 if (object->path == NULL) {
2043                         py_path = Py_None;
2044                         Py_INCREF(py_path);
2045                 } else {
2046                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
2047                 }
2048         }
2049         return py_path;
2050 }
2051
2052 static int py_srvsvc_NetFileInfo3_set_path(PyObject *py_obj, PyObject *value, void *closure)
2053 {
2054         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2055         if (value == Py_None) {
2056                 object->path = NULL;
2057         } else {
2058                 object->path = NULL;
2059                 if (PyUnicode_Check(value)) {
2060                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2061                 } else if (PyString_Check(value)) {
2062                         object->path = PyString_AS_STRING(value);
2063                 } else {
2064                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2065                         return -1;
2066                 }
2067         }
2068         return 0;
2069 }
2070
2071 static PyObject *py_srvsvc_NetFileInfo3_get_user(PyObject *obj, void *closure)
2072 {
2073         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(obj);
2074         PyObject *py_user;
2075         if (object->user == NULL) {
2076                 py_user = Py_None;
2077                 Py_INCREF(py_user);
2078         } else {
2079                 if (object->user == NULL) {
2080                         py_user = Py_None;
2081                         Py_INCREF(py_user);
2082                 } else {
2083                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2084                 }
2085         }
2086         return py_user;
2087 }
2088
2089 static int py_srvsvc_NetFileInfo3_set_user(PyObject *py_obj, PyObject *value, void *closure)
2090 {
2091         struct srvsvc_NetFileInfo3 *object = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(py_obj);
2092         if (value == Py_None) {
2093                 object->user = NULL;
2094         } else {
2095                 object->user = NULL;
2096                 if (PyUnicode_Check(value)) {
2097                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2098                 } else if (PyString_Check(value)) {
2099                         object->user = PyString_AS_STRING(value);
2100                 } else {
2101                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2102                         return -1;
2103                 }
2104         }
2105         return 0;
2106 }
2107
2108 static PyGetSetDef py_srvsvc_NetFileInfo3_getsetters[] = {
2109         { discard_const_p(char, "fid"), py_srvsvc_NetFileInfo3_get_fid, py_srvsvc_NetFileInfo3_set_fid },
2110         { discard_const_p(char, "permissions"), py_srvsvc_NetFileInfo3_get_permissions, py_srvsvc_NetFileInfo3_set_permissions },
2111         { discard_const_p(char, "num_locks"), py_srvsvc_NetFileInfo3_get_num_locks, py_srvsvc_NetFileInfo3_set_num_locks },
2112         { discard_const_p(char, "path"), py_srvsvc_NetFileInfo3_get_path, py_srvsvc_NetFileInfo3_set_path },
2113         { discard_const_p(char, "user"), py_srvsvc_NetFileInfo3_get_user, py_srvsvc_NetFileInfo3_set_user },
2114         { NULL }
2115 };
2116
2117 static PyObject *py_srvsvc_NetFileInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2118 {
2119         return pytalloc_new(struct srvsvc_NetFileInfo3, type);
2120 }
2121
2122
2123 static PyTypeObject srvsvc_NetFileInfo3_Type = {
2124         PyObject_HEAD_INIT(NULL) 0,
2125         .tp_name = "srvsvc.NetFileInfo3",
2126         .tp_getset = py_srvsvc_NetFileInfo3_getsetters,
2127         .tp_methods = NULL,
2128         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2129         .tp_basicsize = sizeof(pytalloc_Object),
2130         .tp_new = py_srvsvc_NetFileInfo3_new,
2131 };
2132
2133
2134 static PyObject *py_srvsvc_NetFileCtr3_get_count(PyObject *obj, void *closure)
2135 {
2136         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
2137         PyObject *py_count;
2138         py_count = PyInt_FromLong(object->count);
2139         return py_count;
2140 }
2141
2142 static int py_srvsvc_NetFileCtr3_set_count(PyObject *py_obj, PyObject *value, void *closure)
2143 {
2144         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(py_obj);
2145         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2146         object->count = PyInt_AsLong(value);
2147         return 0;
2148 }
2149
2150 static PyObject *py_srvsvc_NetFileCtr3_get_array(PyObject *obj, void *closure)
2151 {
2152         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(obj);
2153         PyObject *py_array;
2154         if (object->array == NULL) {
2155                 py_array = Py_None;
2156                 Py_INCREF(py_array);
2157         } else {
2158                 py_array = PyList_New(object->count);
2159                 if (py_array == NULL) {
2160                         return NULL;
2161                 }
2162                 {
2163                         int array_cntr_1;
2164                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2165                                 PyObject *py_array_1;
2166                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetFileInfo3_Type, object->array, &object->array[array_cntr_1]);
2167                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2168                         }
2169                 }
2170         }
2171         return py_array;
2172 }
2173
2174 static int py_srvsvc_NetFileCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
2175 {
2176         struct srvsvc_NetFileCtr3 *object = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(py_obj);
2177         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2178         if (value == Py_None) {
2179                 object->array = NULL;
2180         } else {
2181                 object->array = NULL;
2182                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2183                 {
2184                         int array_cntr_1;
2185                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2186                         if (!object->array) { return -1;; }
2187                         talloc_set_name_const(object->array, "ARRAY: object->array");
2188                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2189                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2190                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2191                                         PyErr_NoMemory();
2192                                         return -1;
2193                                 }
2194                                 object->array[array_cntr_1] = *(struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2195                         }
2196                 }
2197         }
2198         return 0;
2199 }
2200
2201 static PyGetSetDef py_srvsvc_NetFileCtr3_getsetters[] = {
2202         { discard_const_p(char, "count"), py_srvsvc_NetFileCtr3_get_count, py_srvsvc_NetFileCtr3_set_count },
2203         { discard_const_p(char, "array"), py_srvsvc_NetFileCtr3_get_array, py_srvsvc_NetFileCtr3_set_array },
2204         { NULL }
2205 };
2206
2207 static PyObject *py_srvsvc_NetFileCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2208 {
2209         return pytalloc_new(struct srvsvc_NetFileCtr3, type);
2210 }
2211
2212
2213 static PyTypeObject srvsvc_NetFileCtr3_Type = {
2214         PyObject_HEAD_INIT(NULL) 0,
2215         .tp_name = "srvsvc.NetFileCtr3",
2216         .tp_getset = py_srvsvc_NetFileCtr3_getsetters,
2217         .tp_methods = NULL,
2218         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2219         .tp_basicsize = sizeof(pytalloc_Object),
2220         .tp_new = py_srvsvc_NetFileCtr3_new,
2221 };
2222
2223 PyObject *py_import_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileInfo *in)
2224 {
2225         PyObject *ret;
2226
2227         switch (level) {
2228                 case 2:
2229                         if (in->info2 == NULL) {
2230                                 ret = Py_None;
2231                                 Py_INCREF(ret);
2232                         } else {
2233                                 ret = pytalloc_reference_ex(&srvsvc_NetFileInfo2_Type, in->info2, in->info2);
2234                         }
2235                         return ret;
2236
2237                 case 3:
2238                         if (in->info3 == NULL) {
2239                                 ret = Py_None;
2240                                 Py_INCREF(ret);
2241                         } else {
2242                                 ret = pytalloc_reference_ex(&srvsvc_NetFileInfo3_Type, in->info3, in->info3);
2243                         }
2244                         return ret;
2245
2246                 default:
2247                         ret = Py_None;
2248                         Py_INCREF(ret);
2249                         return ret;
2250
2251         }
2252         PyErr_SetString(PyExc_TypeError, "unknown union level");
2253         return NULL;
2254 }
2255
2256 union srvsvc_NetFileInfo *py_export_srvsvc_NetFileInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2257 {
2258         union srvsvc_NetFileInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetFileInfo);
2259         switch (level) {
2260                 case 2:
2261                         if (in == Py_None) {
2262                                 ret->info2 = NULL;
2263                         } else {
2264                                 ret->info2 = NULL;
2265                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo2_Type, in, talloc_free(ret); return NULL;);
2266                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2267                                         PyErr_NoMemory();
2268                                         talloc_free(ret); return NULL;
2269                                 }
2270                                 ret->info2 = (struct srvsvc_NetFileInfo2 *)pytalloc_get_ptr(in);
2271                         }
2272                         break;
2273
2274                 case 3:
2275                         if (in == Py_None) {
2276                                 ret->info3 = NULL;
2277                         } else {
2278                                 ret->info3 = NULL;
2279                                 PY_CHECK_TYPE(&srvsvc_NetFileInfo3_Type, in, talloc_free(ret); return NULL;);
2280                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2281                                         PyErr_NoMemory();
2282                                         talloc_free(ret); return NULL;
2283                                 }
2284                                 ret->info3 = (struct srvsvc_NetFileInfo3 *)pytalloc_get_ptr(in);
2285                         }
2286                         break;
2287
2288                 default:
2289                         break;
2290
2291         }
2292
2293         return ret;
2294 }
2295
2296 PyObject *py_import_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetFileCtr *in)
2297 {
2298         PyObject *ret;
2299
2300         switch (level) {
2301                 case 2:
2302                         if (in->ctr2 == NULL) {
2303                                 ret = Py_None;
2304                                 Py_INCREF(ret);
2305                         } else {
2306                                 ret = pytalloc_reference_ex(&srvsvc_NetFileCtr2_Type, in->ctr2, in->ctr2);
2307                         }
2308                         return ret;
2309
2310                 case 3:
2311                         if (in->ctr3 == NULL) {
2312                                 ret = Py_None;
2313                                 Py_INCREF(ret);
2314                         } else {
2315                                 ret = pytalloc_reference_ex(&srvsvc_NetFileCtr3_Type, in->ctr3, in->ctr3);
2316                         }
2317                         return ret;
2318
2319                 default:
2320                         ret = Py_None;
2321                         Py_INCREF(ret);
2322                         return ret;
2323
2324         }
2325         PyErr_SetString(PyExc_TypeError, "unknown union level");
2326         return NULL;
2327 }
2328
2329 union srvsvc_NetFileCtr *py_export_srvsvc_NetFileCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2330 {
2331         union srvsvc_NetFileCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetFileCtr);
2332         switch (level) {
2333                 case 2:
2334                         if (in == Py_None) {
2335                                 ret->ctr2 = NULL;
2336                         } else {
2337                                 ret->ctr2 = NULL;
2338                                 PY_CHECK_TYPE(&srvsvc_NetFileCtr2_Type, in, talloc_free(ret); return NULL;);
2339                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2340                                         PyErr_NoMemory();
2341                                         talloc_free(ret); return NULL;
2342                                 }
2343                                 ret->ctr2 = (struct srvsvc_NetFileCtr2 *)pytalloc_get_ptr(in);
2344                         }
2345                         break;
2346
2347                 case 3:
2348                         if (in == Py_None) {
2349                                 ret->ctr3 = NULL;
2350                         } else {
2351                                 ret->ctr3 = NULL;
2352                                 PY_CHECK_TYPE(&srvsvc_NetFileCtr3_Type, in, talloc_free(ret); return NULL;);
2353                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2354                                         PyErr_NoMemory();
2355                                         talloc_free(ret); return NULL;
2356                                 }
2357                                 ret->ctr3 = (struct srvsvc_NetFileCtr3 *)pytalloc_get_ptr(in);
2358                         }
2359                         break;
2360
2361                 default:
2362                         break;
2363
2364         }
2365
2366         return ret;
2367 }
2368
2369
2370 static PyObject *py_srvsvc_NetFileInfoCtr_get_level(PyObject *obj, void *closure)
2371 {
2372         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
2373         PyObject *py_level;
2374         py_level = PyInt_FromLong(object->level);
2375         return py_level;
2376 }
2377
2378 static int py_srvsvc_NetFileInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
2379 {
2380         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_obj);
2381         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2382         object->level = PyInt_AsLong(value);
2383         return 0;
2384 }
2385
2386 static PyObject *py_srvsvc_NetFileInfoCtr_get_ctr(PyObject *obj, void *closure)
2387 {
2388         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(obj);
2389         PyObject *py_ctr;
2390         py_ctr = py_import_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
2391         if (py_ctr == NULL) {
2392                 return NULL;
2393         }
2394         return py_ctr;
2395 }
2396
2397 static int py_srvsvc_NetFileInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
2398 {
2399         struct srvsvc_NetFileInfoCtr *object = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_obj);
2400         {
2401                 union srvsvc_NetFileCtr *ctr_switch_0;
2402                 ctr_switch_0 = py_export_srvsvc_NetFileCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
2403                 if (ctr_switch_0 == NULL) {
2404                         return -1;
2405                 }
2406                 object->ctr = *ctr_switch_0;
2407         }
2408         return 0;
2409 }
2410
2411 static PyGetSetDef py_srvsvc_NetFileInfoCtr_getsetters[] = {
2412         { discard_const_p(char, "level"), py_srvsvc_NetFileInfoCtr_get_level, py_srvsvc_NetFileInfoCtr_set_level },
2413         { discard_const_p(char, "ctr"), py_srvsvc_NetFileInfoCtr_get_ctr, py_srvsvc_NetFileInfoCtr_set_ctr },
2414         { NULL }
2415 };
2416
2417 static PyObject *py_srvsvc_NetFileInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2418 {
2419         return pytalloc_new(struct srvsvc_NetFileInfoCtr, type);
2420 }
2421
2422
2423 static PyTypeObject srvsvc_NetFileInfoCtr_Type = {
2424         PyObject_HEAD_INIT(NULL) 0,
2425         .tp_name = "srvsvc.NetFileInfoCtr",
2426         .tp_getset = py_srvsvc_NetFileInfoCtr_getsetters,
2427         .tp_methods = NULL,
2428         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2429         .tp_basicsize = sizeof(pytalloc_Object),
2430         .tp_new = py_srvsvc_NetFileInfoCtr_new,
2431 };
2432
2433
2434 static PyObject *py_srvsvc_NetSessInfo0_get_client(PyObject *obj, void *closure)
2435 {
2436         struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(obj);
2437         PyObject *py_client;
2438         if (object->client == NULL) {
2439                 py_client = Py_None;
2440                 Py_INCREF(py_client);
2441         } else {
2442                 if (object->client == NULL) {
2443                         py_client = Py_None;
2444                         Py_INCREF(py_client);
2445                 } else {
2446                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2447                 }
2448         }
2449         return py_client;
2450 }
2451
2452 static int py_srvsvc_NetSessInfo0_set_client(PyObject *py_obj, PyObject *value, void *closure)
2453 {
2454         struct srvsvc_NetSessInfo0 *object = (struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(py_obj);
2455         if (value == Py_None) {
2456                 object->client = NULL;
2457         } else {
2458                 object->client = NULL;
2459                 if (PyUnicode_Check(value)) {
2460                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2461                 } else if (PyString_Check(value)) {
2462                         object->client = PyString_AS_STRING(value);
2463                 } else {
2464                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2465                         return -1;
2466                 }
2467         }
2468         return 0;
2469 }
2470
2471 static PyGetSetDef py_srvsvc_NetSessInfo0_getsetters[] = {
2472         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo0_get_client, py_srvsvc_NetSessInfo0_set_client },
2473         { NULL }
2474 };
2475
2476 static PyObject *py_srvsvc_NetSessInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2477 {
2478         return pytalloc_new(struct srvsvc_NetSessInfo0, type);
2479 }
2480
2481
2482 static PyTypeObject srvsvc_NetSessInfo0_Type = {
2483         PyObject_HEAD_INIT(NULL) 0,
2484         .tp_name = "srvsvc.NetSessInfo0",
2485         .tp_getset = py_srvsvc_NetSessInfo0_getsetters,
2486         .tp_methods = NULL,
2487         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2488         .tp_basicsize = sizeof(pytalloc_Object),
2489         .tp_new = py_srvsvc_NetSessInfo0_new,
2490 };
2491
2492
2493 static PyObject *py_srvsvc_NetSessCtr0_get_count(PyObject *obj, void *closure)
2494 {
2495         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
2496         PyObject *py_count;
2497         py_count = PyInt_FromLong(object->count);
2498         return py_count;
2499 }
2500
2501 static int py_srvsvc_NetSessCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
2502 {
2503         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(py_obj);
2504         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2505         object->count = PyInt_AsLong(value);
2506         return 0;
2507 }
2508
2509 static PyObject *py_srvsvc_NetSessCtr0_get_array(PyObject *obj, void *closure)
2510 {
2511         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(obj);
2512         PyObject *py_array;
2513         if (object->array == NULL) {
2514                 py_array = Py_None;
2515                 Py_INCREF(py_array);
2516         } else {
2517                 py_array = PyList_New(object->count);
2518                 if (py_array == NULL) {
2519                         return NULL;
2520                 }
2521                 {
2522                         int array_cntr_1;
2523                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2524                                 PyObject *py_array_1;
2525                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo0_Type, object->array, &object->array[array_cntr_1]);
2526                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2527                         }
2528                 }
2529         }
2530         return py_array;
2531 }
2532
2533 static int py_srvsvc_NetSessCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
2534 {
2535         struct srvsvc_NetSessCtr0 *object = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(py_obj);
2536         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2537         if (value == Py_None) {
2538                 object->array = NULL;
2539         } else {
2540                 object->array = NULL;
2541                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2542                 {
2543                         int array_cntr_1;
2544                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2545                         if (!object->array) { return -1;; }
2546                         talloc_set_name_const(object->array, "ARRAY: object->array");
2547                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2548                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2549                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2550                                         PyErr_NoMemory();
2551                                         return -1;
2552                                 }
2553                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2554                         }
2555                 }
2556         }
2557         return 0;
2558 }
2559
2560 static PyGetSetDef py_srvsvc_NetSessCtr0_getsetters[] = {
2561         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr0_get_count, py_srvsvc_NetSessCtr0_set_count },
2562         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr0_get_array, py_srvsvc_NetSessCtr0_set_array },
2563         { NULL }
2564 };
2565
2566 static PyObject *py_srvsvc_NetSessCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2567 {
2568         return pytalloc_new(struct srvsvc_NetSessCtr0, type);
2569 }
2570
2571
2572 static PyTypeObject srvsvc_NetSessCtr0_Type = {
2573         PyObject_HEAD_INIT(NULL) 0,
2574         .tp_name = "srvsvc.NetSessCtr0",
2575         .tp_getset = py_srvsvc_NetSessCtr0_getsetters,
2576         .tp_methods = NULL,
2577         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2578         .tp_basicsize = sizeof(pytalloc_Object),
2579         .tp_new = py_srvsvc_NetSessCtr0_new,
2580 };
2581
2582
2583 static PyObject *py_srvsvc_NetSessInfo1_get_client(PyObject *obj, void *closure)
2584 {
2585         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2586         PyObject *py_client;
2587         if (object->client == NULL) {
2588                 py_client = Py_None;
2589                 Py_INCREF(py_client);
2590         } else {
2591                 if (object->client == NULL) {
2592                         py_client = Py_None;
2593                         Py_INCREF(py_client);
2594                 } else {
2595                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2596                 }
2597         }
2598         return py_client;
2599 }
2600
2601 static int py_srvsvc_NetSessInfo1_set_client(PyObject *py_obj, PyObject *value, void *closure)
2602 {
2603         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2604         if (value == Py_None) {
2605                 object->client = NULL;
2606         } else {
2607                 object->client = NULL;
2608                 if (PyUnicode_Check(value)) {
2609                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2610                 } else if (PyString_Check(value)) {
2611                         object->client = PyString_AS_STRING(value);
2612                 } else {
2613                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2614                         return -1;
2615                 }
2616         }
2617         return 0;
2618 }
2619
2620 static PyObject *py_srvsvc_NetSessInfo1_get_user(PyObject *obj, void *closure)
2621 {
2622         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2623         PyObject *py_user;
2624         if (object->user == NULL) {
2625                 py_user = Py_None;
2626                 Py_INCREF(py_user);
2627         } else {
2628                 if (object->user == NULL) {
2629                         py_user = Py_None;
2630                         Py_INCREF(py_user);
2631                 } else {
2632                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2633                 }
2634         }
2635         return py_user;
2636 }
2637
2638 static int py_srvsvc_NetSessInfo1_set_user(PyObject *py_obj, PyObject *value, void *closure)
2639 {
2640         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2641         if (value == Py_None) {
2642                 object->user = NULL;
2643         } else {
2644                 object->user = NULL;
2645                 if (PyUnicode_Check(value)) {
2646                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2647                 } else if (PyString_Check(value)) {
2648                         object->user = PyString_AS_STRING(value);
2649                 } else {
2650                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2651                         return -1;
2652                 }
2653         }
2654         return 0;
2655 }
2656
2657 static PyObject *py_srvsvc_NetSessInfo1_get_num_open(PyObject *obj, void *closure)
2658 {
2659         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2660         PyObject *py_num_open;
2661         py_num_open = PyInt_FromLong(object->num_open);
2662         return py_num_open;
2663 }
2664
2665 static int py_srvsvc_NetSessInfo1_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
2666 {
2667         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2668         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2669         object->num_open = PyInt_AsLong(value);
2670         return 0;
2671 }
2672
2673 static PyObject *py_srvsvc_NetSessInfo1_get_time(PyObject *obj, void *closure)
2674 {
2675         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2676         PyObject *py_time;
2677         py_time = PyInt_FromLong(object->time);
2678         return py_time;
2679 }
2680
2681 static int py_srvsvc_NetSessInfo1_set_time(PyObject *py_obj, PyObject *value, void *closure)
2682 {
2683         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2684         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2685         object->time = PyInt_AsLong(value);
2686         return 0;
2687 }
2688
2689 static PyObject *py_srvsvc_NetSessInfo1_get_idle_time(PyObject *obj, void *closure)
2690 {
2691         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2692         PyObject *py_idle_time;
2693         py_idle_time = PyInt_FromLong(object->idle_time);
2694         return py_idle_time;
2695 }
2696
2697 static int py_srvsvc_NetSessInfo1_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
2698 {
2699         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2700         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2701         object->idle_time = PyInt_AsLong(value);
2702         return 0;
2703 }
2704
2705 static PyObject *py_srvsvc_NetSessInfo1_get_user_flags(PyObject *obj, void *closure)
2706 {
2707         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(obj);
2708         PyObject *py_user_flags;
2709         py_user_flags = PyInt_FromLong(object->user_flags);
2710         return py_user_flags;
2711 }
2712
2713 static int py_srvsvc_NetSessInfo1_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
2714 {
2715         struct srvsvc_NetSessInfo1 *object = (struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(py_obj);
2716         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2717         object->user_flags = PyInt_AsLong(value);
2718         return 0;
2719 }
2720
2721 static PyGetSetDef py_srvsvc_NetSessInfo1_getsetters[] = {
2722         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo1_get_client, py_srvsvc_NetSessInfo1_set_client },
2723         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo1_get_user, py_srvsvc_NetSessInfo1_set_user },
2724         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo1_get_num_open, py_srvsvc_NetSessInfo1_set_num_open },
2725         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo1_get_time, py_srvsvc_NetSessInfo1_set_time },
2726         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo1_get_idle_time, py_srvsvc_NetSessInfo1_set_idle_time },
2727         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo1_get_user_flags, py_srvsvc_NetSessInfo1_set_user_flags },
2728         { NULL }
2729 };
2730
2731 static PyObject *py_srvsvc_NetSessInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2732 {
2733         return pytalloc_new(struct srvsvc_NetSessInfo1, type);
2734 }
2735
2736
2737 static PyTypeObject srvsvc_NetSessInfo1_Type = {
2738         PyObject_HEAD_INIT(NULL) 0,
2739         .tp_name = "srvsvc.NetSessInfo1",
2740         .tp_getset = py_srvsvc_NetSessInfo1_getsetters,
2741         .tp_methods = NULL,
2742         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2743         .tp_basicsize = sizeof(pytalloc_Object),
2744         .tp_new = py_srvsvc_NetSessInfo1_new,
2745 };
2746
2747
2748 static PyObject *py_srvsvc_NetSessCtr1_get_count(PyObject *obj, void *closure)
2749 {
2750         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
2751         PyObject *py_count;
2752         py_count = PyInt_FromLong(object->count);
2753         return py_count;
2754 }
2755
2756 static int py_srvsvc_NetSessCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
2757 {
2758         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(py_obj);
2759         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2760         object->count = PyInt_AsLong(value);
2761         return 0;
2762 }
2763
2764 static PyObject *py_srvsvc_NetSessCtr1_get_array(PyObject *obj, void *closure)
2765 {
2766         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(obj);
2767         PyObject *py_array;
2768         if (object->array == NULL) {
2769                 py_array = Py_None;
2770                 Py_INCREF(py_array);
2771         } else {
2772                 py_array = PyList_New(object->count);
2773                 if (py_array == NULL) {
2774                         return NULL;
2775                 }
2776                 {
2777                         int array_cntr_1;
2778                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
2779                                 PyObject *py_array_1;
2780                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo1_Type, object->array, &object->array[array_cntr_1]);
2781                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
2782                         }
2783                 }
2784         }
2785         return py_array;
2786 }
2787
2788 static int py_srvsvc_NetSessCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
2789 {
2790         struct srvsvc_NetSessCtr1 *object = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(py_obj);
2791         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
2792         if (value == Py_None) {
2793                 object->array = NULL;
2794         } else {
2795                 object->array = NULL;
2796                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2797                 {
2798                         int array_cntr_1;
2799                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
2800                         if (!object->array) { return -1;; }
2801                         talloc_set_name_const(object->array, "ARRAY: object->array");
2802                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
2803                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
2804                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
2805                                         PyErr_NoMemory();
2806                                         return -1;
2807                                 }
2808                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
2809                         }
2810                 }
2811         }
2812         return 0;
2813 }
2814
2815 static PyGetSetDef py_srvsvc_NetSessCtr1_getsetters[] = {
2816         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr1_get_count, py_srvsvc_NetSessCtr1_set_count },
2817         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr1_get_array, py_srvsvc_NetSessCtr1_set_array },
2818         { NULL }
2819 };
2820
2821 static PyObject *py_srvsvc_NetSessCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2822 {
2823         return pytalloc_new(struct srvsvc_NetSessCtr1, type);
2824 }
2825
2826
2827 static PyTypeObject srvsvc_NetSessCtr1_Type = {
2828         PyObject_HEAD_INIT(NULL) 0,
2829         .tp_name = "srvsvc.NetSessCtr1",
2830         .tp_getset = py_srvsvc_NetSessCtr1_getsetters,
2831         .tp_methods = NULL,
2832         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2833         .tp_basicsize = sizeof(pytalloc_Object),
2834         .tp_new = py_srvsvc_NetSessCtr1_new,
2835 };
2836
2837
2838 static PyObject *py_srvsvc_NetSessInfo2_get_client(PyObject *obj, void *closure)
2839 {
2840         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2841         PyObject *py_client;
2842         if (object->client == NULL) {
2843                 py_client = Py_None;
2844                 Py_INCREF(py_client);
2845         } else {
2846                 if (object->client == NULL) {
2847                         py_client = Py_None;
2848                         Py_INCREF(py_client);
2849                 } else {
2850                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
2851                 }
2852         }
2853         return py_client;
2854 }
2855
2856 static int py_srvsvc_NetSessInfo2_set_client(PyObject *py_obj, PyObject *value, void *closure)
2857 {
2858         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2859         if (value == Py_None) {
2860                 object->client = NULL;
2861         } else {
2862                 object->client = NULL;
2863                 if (PyUnicode_Check(value)) {
2864                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2865                 } else if (PyString_Check(value)) {
2866                         object->client = PyString_AS_STRING(value);
2867                 } else {
2868                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2869                         return -1;
2870                 }
2871         }
2872         return 0;
2873 }
2874
2875 static PyObject *py_srvsvc_NetSessInfo2_get_user(PyObject *obj, void *closure)
2876 {
2877         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2878         PyObject *py_user;
2879         if (object->user == NULL) {
2880                 py_user = Py_None;
2881                 Py_INCREF(py_user);
2882         } else {
2883                 if (object->user == NULL) {
2884                         py_user = Py_None;
2885                         Py_INCREF(py_user);
2886                 } else {
2887                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
2888                 }
2889         }
2890         return py_user;
2891 }
2892
2893 static int py_srvsvc_NetSessInfo2_set_user(PyObject *py_obj, PyObject *value, void *closure)
2894 {
2895         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2896         if (value == Py_None) {
2897                 object->user = NULL;
2898         } else {
2899                 object->user = NULL;
2900                 if (PyUnicode_Check(value)) {
2901                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2902                 } else if (PyString_Check(value)) {
2903                         object->user = PyString_AS_STRING(value);
2904                 } else {
2905                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
2906                         return -1;
2907                 }
2908         }
2909         return 0;
2910 }
2911
2912 static PyObject *py_srvsvc_NetSessInfo2_get_num_open(PyObject *obj, void *closure)
2913 {
2914         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2915         PyObject *py_num_open;
2916         py_num_open = PyInt_FromLong(object->num_open);
2917         return py_num_open;
2918 }
2919
2920 static int py_srvsvc_NetSessInfo2_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
2921 {
2922         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2923         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2924         object->num_open = PyInt_AsLong(value);
2925         return 0;
2926 }
2927
2928 static PyObject *py_srvsvc_NetSessInfo2_get_time(PyObject *obj, void *closure)
2929 {
2930         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2931         PyObject *py_time;
2932         py_time = PyInt_FromLong(object->time);
2933         return py_time;
2934 }
2935
2936 static int py_srvsvc_NetSessInfo2_set_time(PyObject *py_obj, PyObject *value, void *closure)
2937 {
2938         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2939         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2940         object->time = PyInt_AsLong(value);
2941         return 0;
2942 }
2943
2944 static PyObject *py_srvsvc_NetSessInfo2_get_idle_time(PyObject *obj, void *closure)
2945 {
2946         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2947         PyObject *py_idle_time;
2948         py_idle_time = PyInt_FromLong(object->idle_time);
2949         return py_idle_time;
2950 }
2951
2952 static int py_srvsvc_NetSessInfo2_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
2953 {
2954         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2955         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2956         object->idle_time = PyInt_AsLong(value);
2957         return 0;
2958 }
2959
2960 static PyObject *py_srvsvc_NetSessInfo2_get_user_flags(PyObject *obj, void *closure)
2961 {
2962         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2963         PyObject *py_user_flags;
2964         py_user_flags = PyInt_FromLong(object->user_flags);
2965         return py_user_flags;
2966 }
2967
2968 static int py_srvsvc_NetSessInfo2_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
2969 {
2970         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2971         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2972         object->user_flags = PyInt_AsLong(value);
2973         return 0;
2974 }
2975
2976 static PyObject *py_srvsvc_NetSessInfo2_get_client_type(PyObject *obj, void *closure)
2977 {
2978         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(obj);
2979         PyObject *py_client_type;
2980         if (object->client_type == NULL) {
2981                 py_client_type = Py_None;
2982                 Py_INCREF(py_client_type);
2983         } else {
2984                 if (object->client_type == NULL) {
2985                         py_client_type = Py_None;
2986                         Py_INCREF(py_client_type);
2987                 } else {
2988                         py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
2989                 }
2990         }
2991         return py_client_type;
2992 }
2993
2994 static int py_srvsvc_NetSessInfo2_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
2995 {
2996         struct srvsvc_NetSessInfo2 *object = (struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(py_obj);
2997         if (value == Py_None) {
2998                 object->client_type = NULL;
2999         } else {
3000                 object->client_type = NULL;
3001                 if (PyUnicode_Check(value)) {
3002                         object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3003                 } else if (PyString_Check(value)) {
3004                         object->client_type = PyString_AS_STRING(value);
3005                 } else {
3006                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3007                         return -1;
3008                 }
3009         }
3010         return 0;
3011 }
3012
3013 static PyGetSetDef py_srvsvc_NetSessInfo2_getsetters[] = {
3014         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo2_get_client, py_srvsvc_NetSessInfo2_set_client },
3015         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo2_get_user, py_srvsvc_NetSessInfo2_set_user },
3016         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo2_get_num_open, py_srvsvc_NetSessInfo2_set_num_open },
3017         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo2_get_time, py_srvsvc_NetSessInfo2_set_time },
3018         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo2_get_idle_time, py_srvsvc_NetSessInfo2_set_idle_time },
3019         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo2_get_user_flags, py_srvsvc_NetSessInfo2_set_user_flags },
3020         { discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo2_get_client_type, py_srvsvc_NetSessInfo2_set_client_type },
3021         { NULL }
3022 };
3023
3024 static PyObject *py_srvsvc_NetSessInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3025 {
3026         return pytalloc_new(struct srvsvc_NetSessInfo2, type);
3027 }
3028
3029
3030 static PyTypeObject srvsvc_NetSessInfo2_Type = {
3031         PyObject_HEAD_INIT(NULL) 0,
3032         .tp_name = "srvsvc.NetSessInfo2",
3033         .tp_getset = py_srvsvc_NetSessInfo2_getsetters,
3034         .tp_methods = NULL,
3035         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3036         .tp_basicsize = sizeof(pytalloc_Object),
3037         .tp_new = py_srvsvc_NetSessInfo2_new,
3038 };
3039
3040
3041 static PyObject *py_srvsvc_NetSessCtr2_get_count(PyObject *obj, void *closure)
3042 {
3043         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
3044         PyObject *py_count;
3045         py_count = PyInt_FromLong(object->count);
3046         return py_count;
3047 }
3048
3049 static int py_srvsvc_NetSessCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
3050 {
3051         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(py_obj);
3052         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3053         object->count = PyInt_AsLong(value);
3054         return 0;
3055 }
3056
3057 static PyObject *py_srvsvc_NetSessCtr2_get_array(PyObject *obj, void *closure)
3058 {
3059         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(obj);
3060         PyObject *py_array;
3061         if (object->array == NULL) {
3062                 py_array = Py_None;
3063                 Py_INCREF(py_array);
3064         } else {
3065                 py_array = PyList_New(object->count);
3066                 if (py_array == NULL) {
3067                         return NULL;
3068                 }
3069                 {
3070                         int array_cntr_1;
3071                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3072                                 PyObject *py_array_1;
3073                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo2_Type, object->array, &object->array[array_cntr_1]);
3074                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3075                         }
3076                 }
3077         }
3078         return py_array;
3079 }
3080
3081 static int py_srvsvc_NetSessCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
3082 {
3083         struct srvsvc_NetSessCtr2 *object = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(py_obj);
3084         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3085         if (value == Py_None) {
3086                 object->array = NULL;
3087         } else {
3088                 object->array = NULL;
3089                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3090                 {
3091                         int array_cntr_1;
3092                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3093                         if (!object->array) { return -1;; }
3094                         talloc_set_name_const(object->array, "ARRAY: object->array");
3095                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3096                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3097                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3098                                         PyErr_NoMemory();
3099                                         return -1;
3100                                 }
3101                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3102                         }
3103                 }
3104         }
3105         return 0;
3106 }
3107
3108 static PyGetSetDef py_srvsvc_NetSessCtr2_getsetters[] = {
3109         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr2_get_count, py_srvsvc_NetSessCtr2_set_count },
3110         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr2_get_array, py_srvsvc_NetSessCtr2_set_array },
3111         { NULL }
3112 };
3113
3114 static PyObject *py_srvsvc_NetSessCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3115 {
3116         return pytalloc_new(struct srvsvc_NetSessCtr2, type);
3117 }
3118
3119
3120 static PyTypeObject srvsvc_NetSessCtr2_Type = {
3121         PyObject_HEAD_INIT(NULL) 0,
3122         .tp_name = "srvsvc.NetSessCtr2",
3123         .tp_getset = py_srvsvc_NetSessCtr2_getsetters,
3124         .tp_methods = NULL,
3125         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3126         .tp_basicsize = sizeof(pytalloc_Object),
3127         .tp_new = py_srvsvc_NetSessCtr2_new,
3128 };
3129
3130
3131 static PyObject *py_srvsvc_NetSessInfo10_get_client(PyObject *obj, void *closure)
3132 {
3133         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3134         PyObject *py_client;
3135         if (object->client == NULL) {
3136                 py_client = Py_None;
3137                 Py_INCREF(py_client);
3138         } else {
3139                 if (object->client == NULL) {
3140                         py_client = Py_None;
3141                         Py_INCREF(py_client);
3142                 } else {
3143                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
3144                 }
3145         }
3146         return py_client;
3147 }
3148
3149 static int py_srvsvc_NetSessInfo10_set_client(PyObject *py_obj, PyObject *value, void *closure)
3150 {
3151         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3152         if (value == Py_None) {
3153                 object->client = NULL;
3154         } else {
3155                 object->client = NULL;
3156                 if (PyUnicode_Check(value)) {
3157                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3158                 } else if (PyString_Check(value)) {
3159                         object->client = PyString_AS_STRING(value);
3160                 } else {
3161                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3162                         return -1;
3163                 }
3164         }
3165         return 0;
3166 }
3167
3168 static PyObject *py_srvsvc_NetSessInfo10_get_user(PyObject *obj, void *closure)
3169 {
3170         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3171         PyObject *py_user;
3172         if (object->user == NULL) {
3173                 py_user = Py_None;
3174                 Py_INCREF(py_user);
3175         } else {
3176                 if (object->user == NULL) {
3177                         py_user = Py_None;
3178                         Py_INCREF(py_user);
3179                 } else {
3180                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
3181                 }
3182         }
3183         return py_user;
3184 }
3185
3186 static int py_srvsvc_NetSessInfo10_set_user(PyObject *py_obj, PyObject *value, void *closure)
3187 {
3188         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3189         if (value == Py_None) {
3190                 object->user = NULL;
3191         } else {
3192                 object->user = NULL;
3193                 if (PyUnicode_Check(value)) {
3194                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3195                 } else if (PyString_Check(value)) {
3196                         object->user = PyString_AS_STRING(value);
3197                 } else {
3198                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3199                         return -1;
3200                 }
3201         }
3202         return 0;
3203 }
3204
3205 static PyObject *py_srvsvc_NetSessInfo10_get_time(PyObject *obj, void *closure)
3206 {
3207         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3208         PyObject *py_time;
3209         py_time = PyInt_FromLong(object->time);
3210         return py_time;
3211 }
3212
3213 static int py_srvsvc_NetSessInfo10_set_time(PyObject *py_obj, PyObject *value, void *closure)
3214 {
3215         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3216         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3217         object->time = PyInt_AsLong(value);
3218         return 0;
3219 }
3220
3221 static PyObject *py_srvsvc_NetSessInfo10_get_idle_time(PyObject *obj, void *closure)
3222 {
3223         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(obj);
3224         PyObject *py_idle_time;
3225         py_idle_time = PyInt_FromLong(object->idle_time);
3226         return py_idle_time;
3227 }
3228
3229 static int py_srvsvc_NetSessInfo10_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
3230 {
3231         struct srvsvc_NetSessInfo10 *object = (struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(py_obj);
3232         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3233         object->idle_time = PyInt_AsLong(value);
3234         return 0;
3235 }
3236
3237 static PyGetSetDef py_srvsvc_NetSessInfo10_getsetters[] = {
3238         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo10_get_client, py_srvsvc_NetSessInfo10_set_client },
3239         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo10_get_user, py_srvsvc_NetSessInfo10_set_user },
3240         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo10_get_time, py_srvsvc_NetSessInfo10_set_time },
3241         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo10_get_idle_time, py_srvsvc_NetSessInfo10_set_idle_time },
3242         { NULL }
3243 };
3244
3245 static PyObject *py_srvsvc_NetSessInfo10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3246 {
3247         return pytalloc_new(struct srvsvc_NetSessInfo10, type);
3248 }
3249
3250
3251 static PyTypeObject srvsvc_NetSessInfo10_Type = {
3252         PyObject_HEAD_INIT(NULL) 0,
3253         .tp_name = "srvsvc.NetSessInfo10",
3254         .tp_getset = py_srvsvc_NetSessInfo10_getsetters,
3255         .tp_methods = NULL,
3256         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3257         .tp_basicsize = sizeof(pytalloc_Object),
3258         .tp_new = py_srvsvc_NetSessInfo10_new,
3259 };
3260
3261
3262 static PyObject *py_srvsvc_NetSessCtr10_get_count(PyObject *obj, void *closure)
3263 {
3264         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
3265         PyObject *py_count;
3266         py_count = PyInt_FromLong(object->count);
3267         return py_count;
3268 }
3269
3270 static int py_srvsvc_NetSessCtr10_set_count(PyObject *py_obj, PyObject *value, void *closure)
3271 {
3272         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(py_obj);
3273         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3274         object->count = PyInt_AsLong(value);
3275         return 0;
3276 }
3277
3278 static PyObject *py_srvsvc_NetSessCtr10_get_array(PyObject *obj, void *closure)
3279 {
3280         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(obj);
3281         PyObject *py_array;
3282         if (object->array == NULL) {
3283                 py_array = Py_None;
3284                 Py_INCREF(py_array);
3285         } else {
3286                 py_array = PyList_New(object->count);
3287                 if (py_array == NULL) {
3288                         return NULL;
3289                 }
3290                 {
3291                         int array_cntr_1;
3292                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3293                                 PyObject *py_array_1;
3294                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo10_Type, object->array, &object->array[array_cntr_1]);
3295                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3296                         }
3297                 }
3298         }
3299         return py_array;
3300 }
3301
3302 static int py_srvsvc_NetSessCtr10_set_array(PyObject *py_obj, PyObject *value, void *closure)
3303 {
3304         struct srvsvc_NetSessCtr10 *object = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(py_obj);
3305         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3306         if (value == Py_None) {
3307                 object->array = NULL;
3308         } else {
3309                 object->array = NULL;
3310                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3311                 {
3312                         int array_cntr_1;
3313                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3314                         if (!object->array) { return -1;; }
3315                         talloc_set_name_const(object->array, "ARRAY: object->array");
3316                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3317                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo10_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3318                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3319                                         PyErr_NoMemory();
3320                                         return -1;
3321                                 }
3322                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo10 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3323                         }
3324                 }
3325         }
3326         return 0;
3327 }
3328
3329 static PyGetSetDef py_srvsvc_NetSessCtr10_getsetters[] = {
3330         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr10_get_count, py_srvsvc_NetSessCtr10_set_count },
3331         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr10_get_array, py_srvsvc_NetSessCtr10_set_array },
3332         { NULL }
3333 };
3334
3335 static PyObject *py_srvsvc_NetSessCtr10_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3336 {
3337         return pytalloc_new(struct srvsvc_NetSessCtr10, type);
3338 }
3339
3340
3341 static PyTypeObject srvsvc_NetSessCtr10_Type = {
3342         PyObject_HEAD_INIT(NULL) 0,
3343         .tp_name = "srvsvc.NetSessCtr10",
3344         .tp_getset = py_srvsvc_NetSessCtr10_getsetters,
3345         .tp_methods = NULL,
3346         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3347         .tp_basicsize = sizeof(pytalloc_Object),
3348         .tp_new = py_srvsvc_NetSessCtr10_new,
3349 };
3350
3351
3352 static PyObject *py_srvsvc_NetSessInfo502_get_client(PyObject *obj, void *closure)
3353 {
3354         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3355         PyObject *py_client;
3356         if (object->client == NULL) {
3357                 py_client = Py_None;
3358                 Py_INCREF(py_client);
3359         } else {
3360                 if (object->client == NULL) {
3361                         py_client = Py_None;
3362                         Py_INCREF(py_client);
3363                 } else {
3364                         py_client = PyUnicode_Decode(object->client, strlen(object->client), "utf-8", "ignore");
3365                 }
3366         }
3367         return py_client;
3368 }
3369
3370 static int py_srvsvc_NetSessInfo502_set_client(PyObject *py_obj, PyObject *value, void *closure)
3371 {
3372         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3373         if (value == Py_None) {
3374                 object->client = NULL;
3375         } else {
3376                 object->client = NULL;
3377                 if (PyUnicode_Check(value)) {
3378                         object->client = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3379                 } else if (PyString_Check(value)) {
3380                         object->client = PyString_AS_STRING(value);
3381                 } else {
3382                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3383                         return -1;
3384                 }
3385         }
3386         return 0;
3387 }
3388
3389 static PyObject *py_srvsvc_NetSessInfo502_get_user(PyObject *obj, void *closure)
3390 {
3391         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3392         PyObject *py_user;
3393         if (object->user == NULL) {
3394                 py_user = Py_None;
3395                 Py_INCREF(py_user);
3396         } else {
3397                 if (object->user == NULL) {
3398                         py_user = Py_None;
3399                         Py_INCREF(py_user);
3400                 } else {
3401                         py_user = PyUnicode_Decode(object->user, strlen(object->user), "utf-8", "ignore");
3402                 }
3403         }
3404         return py_user;
3405 }
3406
3407 static int py_srvsvc_NetSessInfo502_set_user(PyObject *py_obj, PyObject *value, void *closure)
3408 {
3409         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3410         if (value == Py_None) {
3411                 object->user = NULL;
3412         } else {
3413                 object->user = NULL;
3414                 if (PyUnicode_Check(value)) {
3415                         object->user = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3416                 } else if (PyString_Check(value)) {
3417                         object->user = PyString_AS_STRING(value);
3418                 } else {
3419                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3420                         return -1;
3421                 }
3422         }
3423         return 0;
3424 }
3425
3426 static PyObject *py_srvsvc_NetSessInfo502_get_num_open(PyObject *obj, void *closure)
3427 {
3428         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3429         PyObject *py_num_open;
3430         py_num_open = PyInt_FromLong(object->num_open);
3431         return py_num_open;
3432 }
3433
3434 static int py_srvsvc_NetSessInfo502_set_num_open(PyObject *py_obj, PyObject *value, void *closure)
3435 {
3436         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3437         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3438         object->num_open = PyInt_AsLong(value);
3439         return 0;
3440 }
3441
3442 static PyObject *py_srvsvc_NetSessInfo502_get_time(PyObject *obj, void *closure)
3443 {
3444         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3445         PyObject *py_time;
3446         py_time = PyInt_FromLong(object->time);
3447         return py_time;
3448 }
3449
3450 static int py_srvsvc_NetSessInfo502_set_time(PyObject *py_obj, PyObject *value, void *closure)
3451 {
3452         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3453         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3454         object->time = PyInt_AsLong(value);
3455         return 0;
3456 }
3457
3458 static PyObject *py_srvsvc_NetSessInfo502_get_idle_time(PyObject *obj, void *closure)
3459 {
3460         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3461         PyObject *py_idle_time;
3462         py_idle_time = PyInt_FromLong(object->idle_time);
3463         return py_idle_time;
3464 }
3465
3466 static int py_srvsvc_NetSessInfo502_set_idle_time(PyObject *py_obj, PyObject *value, void *closure)
3467 {
3468         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3469         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3470         object->idle_time = PyInt_AsLong(value);
3471         return 0;
3472 }
3473
3474 static PyObject *py_srvsvc_NetSessInfo502_get_user_flags(PyObject *obj, void *closure)
3475 {
3476         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3477         PyObject *py_user_flags;
3478         py_user_flags = PyInt_FromLong(object->user_flags);
3479         return py_user_flags;
3480 }
3481
3482 static int py_srvsvc_NetSessInfo502_set_user_flags(PyObject *py_obj, PyObject *value, void *closure)
3483 {
3484         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3485         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3486         object->user_flags = PyInt_AsLong(value);
3487         return 0;
3488 }
3489
3490 static PyObject *py_srvsvc_NetSessInfo502_get_client_type(PyObject *obj, void *closure)
3491 {
3492         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3493         PyObject *py_client_type;
3494         if (object->client_type == NULL) {
3495                 py_client_type = Py_None;
3496                 Py_INCREF(py_client_type);
3497         } else {
3498                 if (object->client_type == NULL) {
3499                         py_client_type = Py_None;
3500                         Py_INCREF(py_client_type);
3501                 } else {
3502                         py_client_type = PyUnicode_Decode(object->client_type, strlen(object->client_type), "utf-8", "ignore");
3503                 }
3504         }
3505         return py_client_type;
3506 }
3507
3508 static int py_srvsvc_NetSessInfo502_set_client_type(PyObject *py_obj, PyObject *value, void *closure)
3509 {
3510         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3511         if (value == Py_None) {
3512                 object->client_type = NULL;
3513         } else {
3514                 object->client_type = NULL;
3515                 if (PyUnicode_Check(value)) {
3516                         object->client_type = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3517                 } else if (PyString_Check(value)) {
3518                         object->client_type = PyString_AS_STRING(value);
3519                 } else {
3520                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3521                         return -1;
3522                 }
3523         }
3524         return 0;
3525 }
3526
3527 static PyObject *py_srvsvc_NetSessInfo502_get_transport(PyObject *obj, void *closure)
3528 {
3529         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(obj);
3530         PyObject *py_transport;
3531         if (object->transport == NULL) {
3532                 py_transport = Py_None;
3533                 Py_INCREF(py_transport);
3534         } else {
3535                 if (object->transport == NULL) {
3536                         py_transport = Py_None;
3537                         Py_INCREF(py_transport);
3538                 } else {
3539                         py_transport = PyUnicode_Decode(object->transport, strlen(object->transport), "utf-8", "ignore");
3540                 }
3541         }
3542         return py_transport;
3543 }
3544
3545 static int py_srvsvc_NetSessInfo502_set_transport(PyObject *py_obj, PyObject *value, void *closure)
3546 {
3547         struct srvsvc_NetSessInfo502 *object = (struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(py_obj);
3548         if (value == Py_None) {
3549                 object->transport = NULL;
3550         } else {
3551                 object->transport = NULL;
3552                 if (PyUnicode_Check(value)) {
3553                         object->transport = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3554                 } else if (PyString_Check(value)) {
3555                         object->transport = PyString_AS_STRING(value);
3556                 } else {
3557                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3558                         return -1;
3559                 }
3560         }
3561         return 0;
3562 }
3563
3564 static PyGetSetDef py_srvsvc_NetSessInfo502_getsetters[] = {
3565         { discard_const_p(char, "client"), py_srvsvc_NetSessInfo502_get_client, py_srvsvc_NetSessInfo502_set_client },
3566         { discard_const_p(char, "user"), py_srvsvc_NetSessInfo502_get_user, py_srvsvc_NetSessInfo502_set_user },
3567         { discard_const_p(char, "num_open"), py_srvsvc_NetSessInfo502_get_num_open, py_srvsvc_NetSessInfo502_set_num_open },
3568         { discard_const_p(char, "time"), py_srvsvc_NetSessInfo502_get_time, py_srvsvc_NetSessInfo502_set_time },
3569         { discard_const_p(char, "idle_time"), py_srvsvc_NetSessInfo502_get_idle_time, py_srvsvc_NetSessInfo502_set_idle_time },
3570         { discard_const_p(char, "user_flags"), py_srvsvc_NetSessInfo502_get_user_flags, py_srvsvc_NetSessInfo502_set_user_flags },
3571         { discard_const_p(char, "client_type"), py_srvsvc_NetSessInfo502_get_client_type, py_srvsvc_NetSessInfo502_set_client_type },
3572         { discard_const_p(char, "transport"), py_srvsvc_NetSessInfo502_get_transport, py_srvsvc_NetSessInfo502_set_transport },
3573         { NULL }
3574 };
3575
3576 static PyObject *py_srvsvc_NetSessInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3577 {
3578         return pytalloc_new(struct srvsvc_NetSessInfo502, type);
3579 }
3580
3581
3582 static PyTypeObject srvsvc_NetSessInfo502_Type = {
3583         PyObject_HEAD_INIT(NULL) 0,
3584         .tp_name = "srvsvc.NetSessInfo502",
3585         .tp_getset = py_srvsvc_NetSessInfo502_getsetters,
3586         .tp_methods = NULL,
3587         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3588         .tp_basicsize = sizeof(pytalloc_Object),
3589         .tp_new = py_srvsvc_NetSessInfo502_new,
3590 };
3591
3592
3593 static PyObject *py_srvsvc_NetSessCtr502_get_count(PyObject *obj, void *closure)
3594 {
3595         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
3596         PyObject *py_count;
3597         py_count = PyInt_FromLong(object->count);
3598         return py_count;
3599 }
3600
3601 static int py_srvsvc_NetSessCtr502_set_count(PyObject *py_obj, PyObject *value, void *closure)
3602 {
3603         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(py_obj);
3604         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3605         object->count = PyInt_AsLong(value);
3606         return 0;
3607 }
3608
3609 static PyObject *py_srvsvc_NetSessCtr502_get_array(PyObject *obj, void *closure)
3610 {
3611         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(obj);
3612         PyObject *py_array;
3613         if (object->array == NULL) {
3614                 py_array = Py_None;
3615                 Py_INCREF(py_array);
3616         } else {
3617                 py_array = PyList_New(object->count);
3618                 if (py_array == NULL) {
3619                         return NULL;
3620                 }
3621                 {
3622                         int array_cntr_1;
3623                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3624                                 PyObject *py_array_1;
3625                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetSessInfo502_Type, object->array, &object->array[array_cntr_1]);
3626                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3627                         }
3628                 }
3629         }
3630         return py_array;
3631 }
3632
3633 static int py_srvsvc_NetSessCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
3634 {
3635         struct srvsvc_NetSessCtr502 *object = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(py_obj);
3636         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3637         if (value == Py_None) {
3638                 object->array = NULL;
3639         } else {
3640                 object->array = NULL;
3641                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3642                 {
3643                         int array_cntr_1;
3644                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
3645                         if (!object->array) { return -1;; }
3646                         talloc_set_name_const(object->array, "ARRAY: object->array");
3647                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
3648                                 PY_CHECK_TYPE(&srvsvc_NetSessInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
3649                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
3650                                         PyErr_NoMemory();
3651                                         return -1;
3652                                 }
3653                                 object->array[array_cntr_1] = *(struct srvsvc_NetSessInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
3654                         }
3655                 }
3656         }
3657         return 0;
3658 }
3659
3660 static PyGetSetDef py_srvsvc_NetSessCtr502_getsetters[] = {
3661         { discard_const_p(char, "count"), py_srvsvc_NetSessCtr502_get_count, py_srvsvc_NetSessCtr502_set_count },
3662         { discard_const_p(char, "array"), py_srvsvc_NetSessCtr502_get_array, py_srvsvc_NetSessCtr502_set_array },
3663         { NULL }
3664 };
3665
3666 static PyObject *py_srvsvc_NetSessCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3667 {
3668         return pytalloc_new(struct srvsvc_NetSessCtr502, type);
3669 }
3670
3671
3672 static PyTypeObject srvsvc_NetSessCtr502_Type = {
3673         PyObject_HEAD_INIT(NULL) 0,
3674         .tp_name = "srvsvc.NetSessCtr502",
3675         .tp_getset = py_srvsvc_NetSessCtr502_getsetters,
3676         .tp_methods = NULL,
3677         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3678         .tp_basicsize = sizeof(pytalloc_Object),
3679         .tp_new = py_srvsvc_NetSessCtr502_new,
3680 };
3681
3682 PyObject *py_import_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSessCtr *in)
3683 {
3684         PyObject *ret;
3685
3686         switch (level) {
3687                 case 0:
3688                         if (in->ctr0 == NULL) {
3689                                 ret = Py_None;
3690                                 Py_INCREF(ret);
3691                         } else {
3692                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr0_Type, in->ctr0, in->ctr0);
3693                         }
3694                         return ret;
3695
3696                 case 1:
3697                         if (in->ctr1 == NULL) {
3698                                 ret = Py_None;
3699                                 Py_INCREF(ret);
3700                         } else {
3701                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr1_Type, in->ctr1, in->ctr1);
3702                         }
3703                         return ret;
3704
3705                 case 2:
3706                         if (in->ctr2 == NULL) {
3707                                 ret = Py_None;
3708                                 Py_INCREF(ret);
3709                         } else {
3710                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr2_Type, in->ctr2, in->ctr2);
3711                         }
3712                         return ret;
3713
3714                 case 10:
3715                         if (in->ctr10 == NULL) {
3716                                 ret = Py_None;
3717                                 Py_INCREF(ret);
3718                         } else {
3719                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr10_Type, in->ctr10, in->ctr10);
3720                         }
3721                         return ret;
3722
3723                 case 502:
3724                         if (in->ctr502 == NULL) {
3725                                 ret = Py_None;
3726                                 Py_INCREF(ret);
3727                         } else {
3728                                 ret = pytalloc_reference_ex(&srvsvc_NetSessCtr502_Type, in->ctr502, in->ctr502);
3729                         }
3730                         return ret;
3731
3732                 default:
3733                         ret = Py_None;
3734                         Py_INCREF(ret);
3735                         return ret;
3736
3737         }
3738         PyErr_SetString(PyExc_TypeError, "unknown union level");
3739         return NULL;
3740 }
3741
3742 union srvsvc_NetSessCtr *py_export_srvsvc_NetSessCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
3743 {
3744         union srvsvc_NetSessCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetSessCtr);
3745         switch (level) {
3746                 case 0:
3747                         if (in == Py_None) {
3748                                 ret->ctr0 = NULL;
3749                         } else {
3750                                 ret->ctr0 = NULL;
3751                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr0_Type, in, talloc_free(ret); return NULL;);
3752                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3753                                         PyErr_NoMemory();
3754                                         talloc_free(ret); return NULL;
3755                                 }
3756                                 ret->ctr0 = (struct srvsvc_NetSessCtr0 *)pytalloc_get_ptr(in);
3757                         }
3758                         break;
3759
3760                 case 1:
3761                         if (in == Py_None) {
3762                                 ret->ctr1 = NULL;
3763                         } else {
3764                                 ret->ctr1 = NULL;
3765                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr1_Type, in, talloc_free(ret); return NULL;);
3766                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3767                                         PyErr_NoMemory();
3768                                         talloc_free(ret); return NULL;
3769                                 }
3770                                 ret->ctr1 = (struct srvsvc_NetSessCtr1 *)pytalloc_get_ptr(in);
3771                         }
3772                         break;
3773
3774                 case 2:
3775                         if (in == Py_None) {
3776                                 ret->ctr2 = NULL;
3777                         } else {
3778                                 ret->ctr2 = NULL;
3779                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr2_Type, in, talloc_free(ret); return NULL;);
3780                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3781                                         PyErr_NoMemory();
3782                                         talloc_free(ret); return NULL;
3783                                 }
3784                                 ret->ctr2 = (struct srvsvc_NetSessCtr2 *)pytalloc_get_ptr(in);
3785                         }
3786                         break;
3787
3788                 case 10:
3789                         if (in == Py_None) {
3790                                 ret->ctr10 = NULL;
3791                         } else {
3792                                 ret->ctr10 = NULL;
3793                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr10_Type, in, talloc_free(ret); return NULL;);
3794                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3795                                         PyErr_NoMemory();
3796                                         talloc_free(ret); return NULL;
3797                                 }
3798                                 ret->ctr10 = (struct srvsvc_NetSessCtr10 *)pytalloc_get_ptr(in);
3799                         }
3800                         break;
3801
3802                 case 502:
3803                         if (in == Py_None) {
3804                                 ret->ctr502 = NULL;
3805                         } else {
3806                                 ret->ctr502 = NULL;
3807                                 PY_CHECK_TYPE(&srvsvc_NetSessCtr502_Type, in, talloc_free(ret); return NULL;);
3808                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
3809                                         PyErr_NoMemory();
3810                                         talloc_free(ret); return NULL;
3811                                 }
3812                                 ret->ctr502 = (struct srvsvc_NetSessCtr502 *)pytalloc_get_ptr(in);
3813                         }
3814                         break;
3815
3816                 default:
3817                         break;
3818
3819         }
3820
3821         return ret;
3822 }
3823
3824
3825 static PyObject *py_srvsvc_NetSessInfoCtr_get_level(PyObject *obj, void *closure)
3826 {
3827         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
3828         PyObject *py_level;
3829         py_level = PyInt_FromLong(object->level);
3830         return py_level;
3831 }
3832
3833 static int py_srvsvc_NetSessInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
3834 {
3835         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_obj);
3836         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3837         object->level = PyInt_AsLong(value);
3838         return 0;
3839 }
3840
3841 static PyObject *py_srvsvc_NetSessInfoCtr_get_ctr(PyObject *obj, void *closure)
3842 {
3843         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(obj);
3844         PyObject *py_ctr;
3845         py_ctr = py_import_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
3846         if (py_ctr == NULL) {
3847                 return NULL;
3848         }
3849         return py_ctr;
3850 }
3851
3852 static int py_srvsvc_NetSessInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
3853 {
3854         struct srvsvc_NetSessInfoCtr *object = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_obj);
3855         {
3856                 union srvsvc_NetSessCtr *ctr_switch_0;
3857                 ctr_switch_0 = py_export_srvsvc_NetSessCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
3858                 if (ctr_switch_0 == NULL) {
3859                         return -1;
3860                 }
3861                 object->ctr = *ctr_switch_0;
3862         }
3863         return 0;
3864 }
3865
3866 static PyGetSetDef py_srvsvc_NetSessInfoCtr_getsetters[] = {
3867         { discard_const_p(char, "level"), py_srvsvc_NetSessInfoCtr_get_level, py_srvsvc_NetSessInfoCtr_set_level },
3868         { discard_const_p(char, "ctr"), py_srvsvc_NetSessInfoCtr_get_ctr, py_srvsvc_NetSessInfoCtr_set_ctr },
3869         { NULL }
3870 };
3871
3872 static PyObject *py_srvsvc_NetSessInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3873 {
3874         return pytalloc_new(struct srvsvc_NetSessInfoCtr, type);
3875 }
3876
3877
3878 static PyTypeObject srvsvc_NetSessInfoCtr_Type = {
3879         PyObject_HEAD_INIT(NULL) 0,
3880         .tp_name = "srvsvc.NetSessInfoCtr",
3881         .tp_getset = py_srvsvc_NetSessInfoCtr_getsetters,
3882         .tp_methods = NULL,
3883         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3884         .tp_basicsize = sizeof(pytalloc_Object),
3885         .tp_new = py_srvsvc_NetSessInfoCtr_new,
3886 };
3887
3888
3889 static PyObject *py_srvsvc_NetShareInfo0_get_name(PyObject *obj, void *closure)
3890 {
3891         struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(obj);
3892         PyObject *py_name;
3893         if (object->name == NULL) {
3894                 py_name = Py_None;
3895                 Py_INCREF(py_name);
3896         } else {
3897                 if (object->name == NULL) {
3898                         py_name = Py_None;
3899                         Py_INCREF(py_name);
3900                 } else {
3901                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
3902                 }
3903         }
3904         return py_name;
3905 }
3906
3907 static int py_srvsvc_NetShareInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
3908 {
3909         struct srvsvc_NetShareInfo0 *object = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(py_obj);
3910         if (value == Py_None) {
3911                 object->name = NULL;
3912         } else {
3913                 object->name = NULL;
3914                 if (PyUnicode_Check(value)) {
3915                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3916                 } else if (PyString_Check(value)) {
3917                         object->name = PyString_AS_STRING(value);
3918                 } else {
3919                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
3920                         return -1;
3921                 }
3922         }
3923         return 0;
3924 }
3925
3926 static PyGetSetDef py_srvsvc_NetShareInfo0_getsetters[] = {
3927         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo0_get_name, py_srvsvc_NetShareInfo0_set_name },
3928         { NULL }
3929 };
3930
3931 static PyObject *py_srvsvc_NetShareInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3932 {
3933         return pytalloc_new(struct srvsvc_NetShareInfo0, type);
3934 }
3935
3936
3937 static PyTypeObject srvsvc_NetShareInfo0_Type = {
3938         PyObject_HEAD_INIT(NULL) 0,
3939         .tp_name = "srvsvc.NetShareInfo0",
3940         .tp_getset = py_srvsvc_NetShareInfo0_getsetters,
3941         .tp_methods = NULL,
3942         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3943         .tp_basicsize = sizeof(pytalloc_Object),
3944         .tp_new = py_srvsvc_NetShareInfo0_new,
3945 };
3946
3947
3948 static PyObject *py_srvsvc_NetShareCtr0_get_count(PyObject *obj, void *closure)
3949 {
3950         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
3951         PyObject *py_count;
3952         py_count = PyInt_FromLong(object->count);
3953         return py_count;
3954 }
3955
3956 static int py_srvsvc_NetShareCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
3957 {
3958         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(py_obj);
3959         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3960         object->count = PyInt_AsLong(value);
3961         return 0;
3962 }
3963
3964 static PyObject *py_srvsvc_NetShareCtr0_get_array(PyObject *obj, void *closure)
3965 {
3966         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(obj);
3967         PyObject *py_array;
3968         if (object->array == NULL) {
3969                 py_array = Py_None;
3970                 Py_INCREF(py_array);
3971         } else {
3972                 py_array = PyList_New(object->count);
3973                 if (py_array == NULL) {
3974                         return NULL;
3975                 }
3976                 {
3977                         int array_cntr_1;
3978                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
3979                                 PyObject *py_array_1;
3980                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo0_Type, object->array, &object->array[array_cntr_1]);
3981                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
3982                         }
3983                 }
3984         }
3985         return py_array;
3986 }
3987
3988 static int py_srvsvc_NetShareCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
3989 {
3990         struct srvsvc_NetShareCtr0 *object = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(py_obj);
3991         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
3992         if (value == Py_None) {
3993                 object->array = NULL;
3994         } else {
3995                 object->array = NULL;
3996                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3997                 {
3998                         int array_cntr_1;
3999                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4000                         if (!object->array) { return -1;; }
4001                         talloc_set_name_const(object->array, "ARRAY: object->array");
4002                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4003                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4004                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4005                                         PyErr_NoMemory();
4006                                         return -1;
4007                                 }
4008                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4009                         }
4010                 }
4011         }
4012         return 0;
4013 }
4014
4015 static PyGetSetDef py_srvsvc_NetShareCtr0_getsetters[] = {
4016         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr0_get_count, py_srvsvc_NetShareCtr0_set_count },
4017         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr0_get_array, py_srvsvc_NetShareCtr0_set_array },
4018         { NULL }
4019 };
4020
4021 static PyObject *py_srvsvc_NetShareCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4022 {
4023         return pytalloc_new(struct srvsvc_NetShareCtr0, type);
4024 }
4025
4026
4027 static PyTypeObject srvsvc_NetShareCtr0_Type = {
4028         PyObject_HEAD_INIT(NULL) 0,
4029         .tp_name = "srvsvc.NetShareCtr0",
4030         .tp_getset = py_srvsvc_NetShareCtr0_getsetters,
4031         .tp_methods = NULL,
4032         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4033         .tp_basicsize = sizeof(pytalloc_Object),
4034         .tp_new = py_srvsvc_NetShareCtr0_new,
4035 };
4036
4037
4038 static PyObject *py_srvsvc_NetShareInfo1_get_name(PyObject *obj, void *closure)
4039 {
4040         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4041         PyObject *py_name;
4042         if (object->name == NULL) {
4043                 py_name = Py_None;
4044                 Py_INCREF(py_name);
4045         } else {
4046                 if (object->name == NULL) {
4047                         py_name = Py_None;
4048                         Py_INCREF(py_name);
4049                 } else {
4050                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4051                 }
4052         }
4053         return py_name;
4054 }
4055
4056 static int py_srvsvc_NetShareInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
4057 {
4058         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4059         if (value == Py_None) {
4060                 object->name = NULL;
4061         } else {
4062                 object->name = NULL;
4063                 if (PyUnicode_Check(value)) {
4064                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4065                 } else if (PyString_Check(value)) {
4066                         object->name = PyString_AS_STRING(value);
4067                 } else {
4068                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4069                         return -1;
4070                 }
4071         }
4072         return 0;
4073 }
4074
4075 static PyObject *py_srvsvc_NetShareInfo1_get_type(PyObject *obj, void *closure)
4076 {
4077         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4078         PyObject *py_type;
4079         py_type = PyInt_FromLong(object->type);
4080         return py_type;
4081 }
4082
4083 static int py_srvsvc_NetShareInfo1_set_type(PyObject *py_obj, PyObject *value, void *closure)
4084 {
4085         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4086         if (PyLong_Check(value)) {
4087                 object->type = PyLong_AsLongLong(value);
4088         } else if (PyInt_Check(value)) {
4089                 object->type = PyInt_AsLong(value);
4090         } else {
4091                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4092                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4093                 return -1;
4094         }
4095         return 0;
4096 }
4097
4098 static PyObject *py_srvsvc_NetShareInfo1_get_comment(PyObject *obj, void *closure)
4099 {
4100         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(obj);
4101         PyObject *py_comment;
4102         if (object->comment == NULL) {
4103                 py_comment = Py_None;
4104                 Py_INCREF(py_comment);
4105         } else {
4106                 if (object->comment == NULL) {
4107                         py_comment = Py_None;
4108                         Py_INCREF(py_comment);
4109                 } else {
4110                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4111                 }
4112         }
4113         return py_comment;
4114 }
4115
4116 static int py_srvsvc_NetShareInfo1_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4117 {
4118         struct srvsvc_NetShareInfo1 *object = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(py_obj);
4119         if (value == Py_None) {
4120                 object->comment = NULL;
4121         } else {
4122                 object->comment = NULL;
4123                 if (PyUnicode_Check(value)) {
4124                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4125                 } else if (PyString_Check(value)) {
4126                         object->comment = PyString_AS_STRING(value);
4127                 } else {
4128                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4129                         return -1;
4130                 }
4131         }
4132         return 0;
4133 }
4134
4135 static PyGetSetDef py_srvsvc_NetShareInfo1_getsetters[] = {
4136         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo1_get_name, py_srvsvc_NetShareInfo1_set_name },
4137         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo1_get_type, py_srvsvc_NetShareInfo1_set_type },
4138         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1_get_comment, py_srvsvc_NetShareInfo1_set_comment },
4139         { NULL }
4140 };
4141
4142 static PyObject *py_srvsvc_NetShareInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4143 {
4144         return pytalloc_new(struct srvsvc_NetShareInfo1, type);
4145 }
4146
4147
4148 static PyTypeObject srvsvc_NetShareInfo1_Type = {
4149         PyObject_HEAD_INIT(NULL) 0,
4150         .tp_name = "srvsvc.NetShareInfo1",
4151         .tp_getset = py_srvsvc_NetShareInfo1_getsetters,
4152         .tp_methods = NULL,
4153         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4154         .tp_basicsize = sizeof(pytalloc_Object),
4155         .tp_new = py_srvsvc_NetShareInfo1_new,
4156 };
4157
4158
4159 static PyObject *py_srvsvc_NetShareCtr1_get_count(PyObject *obj, void *closure)
4160 {
4161         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
4162         PyObject *py_count;
4163         py_count = PyInt_FromLong(object->count);
4164         return py_count;
4165 }
4166
4167 static int py_srvsvc_NetShareCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
4168 {
4169         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(py_obj);
4170         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4171         object->count = PyInt_AsLong(value);
4172         return 0;
4173 }
4174
4175 static PyObject *py_srvsvc_NetShareCtr1_get_array(PyObject *obj, void *closure)
4176 {
4177         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(obj);
4178         PyObject *py_array;
4179         if (object->array == NULL) {
4180                 py_array = Py_None;
4181                 Py_INCREF(py_array);
4182         } else {
4183                 py_array = PyList_New(object->count);
4184                 if (py_array == NULL) {
4185                         return NULL;
4186                 }
4187                 {
4188                         int array_cntr_1;
4189                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4190                                 PyObject *py_array_1;
4191                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1_Type, object->array, &object->array[array_cntr_1]);
4192                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4193                         }
4194                 }
4195         }
4196         return py_array;
4197 }
4198
4199 static int py_srvsvc_NetShareCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
4200 {
4201         struct srvsvc_NetShareCtr1 *object = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(py_obj);
4202         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4203         if (value == Py_None) {
4204                 object->array = NULL;
4205         } else {
4206                 object->array = NULL;
4207                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4208                 {
4209                         int array_cntr_1;
4210                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4211                         if (!object->array) { return -1;; }
4212                         talloc_set_name_const(object->array, "ARRAY: object->array");
4213                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4214                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4215                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4216                                         PyErr_NoMemory();
4217                                         return -1;
4218                                 }
4219                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4220                         }
4221                 }
4222         }
4223         return 0;
4224 }
4225
4226 static PyGetSetDef py_srvsvc_NetShareCtr1_getsetters[] = {
4227         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1_get_count, py_srvsvc_NetShareCtr1_set_count },
4228         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1_get_array, py_srvsvc_NetShareCtr1_set_array },
4229         { NULL }
4230 };
4231
4232 static PyObject *py_srvsvc_NetShareCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4233 {
4234         return pytalloc_new(struct srvsvc_NetShareCtr1, type);
4235 }
4236
4237
4238 static PyTypeObject srvsvc_NetShareCtr1_Type = {
4239         PyObject_HEAD_INIT(NULL) 0,
4240         .tp_name = "srvsvc.NetShareCtr1",
4241         .tp_getset = py_srvsvc_NetShareCtr1_getsetters,
4242         .tp_methods = NULL,
4243         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4244         .tp_basicsize = sizeof(pytalloc_Object),
4245         .tp_new = py_srvsvc_NetShareCtr1_new,
4246 };
4247
4248
4249 static PyObject *py_srvsvc_NetShareInfo2_get_name(PyObject *obj, void *closure)
4250 {
4251         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4252         PyObject *py_name;
4253         if (object->name == NULL) {
4254                 py_name = Py_None;
4255                 Py_INCREF(py_name);
4256         } else {
4257                 if (object->name == NULL) {
4258                         py_name = Py_None;
4259                         Py_INCREF(py_name);
4260                 } else {
4261                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4262                 }
4263         }
4264         return py_name;
4265 }
4266
4267 static int py_srvsvc_NetShareInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
4268 {
4269         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4270         if (value == Py_None) {
4271                 object->name = NULL;
4272         } else {
4273                 object->name = NULL;
4274                 if (PyUnicode_Check(value)) {
4275                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4276                 } else if (PyString_Check(value)) {
4277                         object->name = PyString_AS_STRING(value);
4278                 } else {
4279                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4280                         return -1;
4281                 }
4282         }
4283         return 0;
4284 }
4285
4286 static PyObject *py_srvsvc_NetShareInfo2_get_type(PyObject *obj, void *closure)
4287 {
4288         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4289         PyObject *py_type;
4290         py_type = PyInt_FromLong(object->type);
4291         return py_type;
4292 }
4293
4294 static int py_srvsvc_NetShareInfo2_set_type(PyObject *py_obj, PyObject *value, void *closure)
4295 {
4296         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4297         if (PyLong_Check(value)) {
4298                 object->type = PyLong_AsLongLong(value);
4299         } else if (PyInt_Check(value)) {
4300                 object->type = PyInt_AsLong(value);
4301         } else {
4302                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4303                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4304                 return -1;
4305         }
4306         return 0;
4307 }
4308
4309 static PyObject *py_srvsvc_NetShareInfo2_get_comment(PyObject *obj, void *closure)
4310 {
4311         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4312         PyObject *py_comment;
4313         if (object->comment == NULL) {
4314                 py_comment = Py_None;
4315                 Py_INCREF(py_comment);
4316         } else {
4317                 if (object->comment == NULL) {
4318                         py_comment = Py_None;
4319                         Py_INCREF(py_comment);
4320                 } else {
4321                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4322                 }
4323         }
4324         return py_comment;
4325 }
4326
4327 static int py_srvsvc_NetShareInfo2_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4328 {
4329         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4330         if (value == Py_None) {
4331                 object->comment = NULL;
4332         } else {
4333                 object->comment = NULL;
4334                 if (PyUnicode_Check(value)) {
4335                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4336                 } else if (PyString_Check(value)) {
4337                         object->comment = PyString_AS_STRING(value);
4338                 } else {
4339                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4340                         return -1;
4341                 }
4342         }
4343         return 0;
4344 }
4345
4346 static PyObject *py_srvsvc_NetShareInfo2_get_permissions(PyObject *obj, void *closure)
4347 {
4348         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4349         PyObject *py_permissions;
4350         py_permissions = PyInt_FromLong(object->permissions);
4351         return py_permissions;
4352 }
4353
4354 static int py_srvsvc_NetShareInfo2_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
4355 {
4356         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4357         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4358         object->permissions = PyInt_AsLong(value);
4359         return 0;
4360 }
4361
4362 static PyObject *py_srvsvc_NetShareInfo2_get_max_users(PyObject *obj, void *closure)
4363 {
4364         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4365         PyObject *py_max_users;
4366         py_max_users = PyInt_FromLong(object->max_users);
4367         return py_max_users;
4368 }
4369
4370 static int py_srvsvc_NetShareInfo2_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
4371 {
4372         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4373         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4374         object->max_users = PyInt_AsLong(value);
4375         return 0;
4376 }
4377
4378 static PyObject *py_srvsvc_NetShareInfo2_get_current_users(PyObject *obj, void *closure)
4379 {
4380         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4381         PyObject *py_current_users;
4382         py_current_users = PyInt_FromLong(object->current_users);
4383         return py_current_users;
4384 }
4385
4386 static int py_srvsvc_NetShareInfo2_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
4387 {
4388         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4389         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4390         object->current_users = PyInt_AsLong(value);
4391         return 0;
4392 }
4393
4394 static PyObject *py_srvsvc_NetShareInfo2_get_path(PyObject *obj, void *closure)
4395 {
4396         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4397         PyObject *py_path;
4398         if (object->path == NULL) {
4399                 py_path = Py_None;
4400                 Py_INCREF(py_path);
4401         } else {
4402                 if (object->path == NULL) {
4403                         py_path = Py_None;
4404                         Py_INCREF(py_path);
4405                 } else {
4406                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
4407                 }
4408         }
4409         return py_path;
4410 }
4411
4412 static int py_srvsvc_NetShareInfo2_set_path(PyObject *py_obj, PyObject *value, void *closure)
4413 {
4414         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4415         if (value == Py_None) {
4416                 object->path = NULL;
4417         } else {
4418                 object->path = NULL;
4419                 if (PyUnicode_Check(value)) {
4420                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4421                 } else if (PyString_Check(value)) {
4422                         object->path = PyString_AS_STRING(value);
4423                 } else {
4424                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4425                         return -1;
4426                 }
4427         }
4428         return 0;
4429 }
4430
4431 static PyObject *py_srvsvc_NetShareInfo2_get_password(PyObject *obj, void *closure)
4432 {
4433         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(obj);
4434         PyObject *py_password;
4435         if (object->password == NULL) {
4436                 py_password = Py_None;
4437                 Py_INCREF(py_password);
4438         } else {
4439                 if (object->password == NULL) {
4440                         py_password = Py_None;
4441                         Py_INCREF(py_password);
4442                 } else {
4443                         py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
4444                 }
4445         }
4446         return py_password;
4447 }
4448
4449 static int py_srvsvc_NetShareInfo2_set_password(PyObject *py_obj, PyObject *value, void *closure)
4450 {
4451         struct srvsvc_NetShareInfo2 *object = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(py_obj);
4452         if (value == Py_None) {
4453                 object->password = NULL;
4454         } else {
4455                 object->password = NULL;
4456                 if (PyUnicode_Check(value)) {
4457                         object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4458                 } else if (PyString_Check(value)) {
4459                         object->password = PyString_AS_STRING(value);
4460                 } else {
4461                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4462                         return -1;
4463                 }
4464         }
4465         return 0;
4466 }
4467
4468 static PyGetSetDef py_srvsvc_NetShareInfo2_getsetters[] = {
4469         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo2_get_name, py_srvsvc_NetShareInfo2_set_name },
4470         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo2_get_type, py_srvsvc_NetShareInfo2_set_type },
4471         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo2_get_comment, py_srvsvc_NetShareInfo2_set_comment },
4472         { discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo2_get_permissions, py_srvsvc_NetShareInfo2_set_permissions },
4473         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo2_get_max_users, py_srvsvc_NetShareInfo2_set_max_users },
4474         { discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo2_get_current_users, py_srvsvc_NetShareInfo2_set_current_users },
4475         { discard_const_p(char, "path"), py_srvsvc_NetShareInfo2_get_path, py_srvsvc_NetShareInfo2_set_path },
4476         { discard_const_p(char, "password"), py_srvsvc_NetShareInfo2_get_password, py_srvsvc_NetShareInfo2_set_password },
4477         { NULL }
4478 };
4479
4480 static PyObject *py_srvsvc_NetShareInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4481 {
4482         return pytalloc_new(struct srvsvc_NetShareInfo2, type);
4483 }
4484
4485
4486 static PyTypeObject srvsvc_NetShareInfo2_Type = {
4487         PyObject_HEAD_INIT(NULL) 0,
4488         .tp_name = "srvsvc.NetShareInfo2",
4489         .tp_getset = py_srvsvc_NetShareInfo2_getsetters,
4490         .tp_methods = NULL,
4491         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4492         .tp_basicsize = sizeof(pytalloc_Object),
4493         .tp_new = py_srvsvc_NetShareInfo2_new,
4494 };
4495
4496
4497 static PyObject *py_srvsvc_NetShareCtr2_get_count(PyObject *obj, void *closure)
4498 {
4499         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
4500         PyObject *py_count;
4501         py_count = PyInt_FromLong(object->count);
4502         return py_count;
4503 }
4504
4505 static int py_srvsvc_NetShareCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
4506 {
4507         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(py_obj);
4508         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4509         object->count = PyInt_AsLong(value);
4510         return 0;
4511 }
4512
4513 static PyObject *py_srvsvc_NetShareCtr2_get_array(PyObject *obj, void *closure)
4514 {
4515         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(obj);
4516         PyObject *py_array;
4517         if (object->array == NULL) {
4518                 py_array = Py_None;
4519                 Py_INCREF(py_array);
4520         } else {
4521                 py_array = PyList_New(object->count);
4522                 if (py_array == NULL) {
4523                         return NULL;
4524                 }
4525                 {
4526                         int array_cntr_1;
4527                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4528                                 PyObject *py_array_1;
4529                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo2_Type, object->array, &object->array[array_cntr_1]);
4530                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4531                         }
4532                 }
4533         }
4534         return py_array;
4535 }
4536
4537 static int py_srvsvc_NetShareCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
4538 {
4539         struct srvsvc_NetShareCtr2 *object = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(py_obj);
4540         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4541         if (value == Py_None) {
4542                 object->array = NULL;
4543         } else {
4544                 object->array = NULL;
4545                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4546                 {
4547                         int array_cntr_1;
4548                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4549                         if (!object->array) { return -1;; }
4550                         talloc_set_name_const(object->array, "ARRAY: object->array");
4551                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4552                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4553                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4554                                         PyErr_NoMemory();
4555                                         return -1;
4556                                 }
4557                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4558                         }
4559                 }
4560         }
4561         return 0;
4562 }
4563
4564 static PyGetSetDef py_srvsvc_NetShareCtr2_getsetters[] = {
4565         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr2_get_count, py_srvsvc_NetShareCtr2_set_count },
4566         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr2_get_array, py_srvsvc_NetShareCtr2_set_array },
4567         { NULL }
4568 };
4569
4570 static PyObject *py_srvsvc_NetShareCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4571 {
4572         return pytalloc_new(struct srvsvc_NetShareCtr2, type);
4573 }
4574
4575
4576 static PyTypeObject srvsvc_NetShareCtr2_Type = {
4577         PyObject_HEAD_INIT(NULL) 0,
4578         .tp_name = "srvsvc.NetShareCtr2",
4579         .tp_getset = py_srvsvc_NetShareCtr2_getsetters,
4580         .tp_methods = NULL,
4581         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4582         .tp_basicsize = sizeof(pytalloc_Object),
4583         .tp_new = py_srvsvc_NetShareCtr2_new,
4584 };
4585
4586
4587 static PyObject *py_srvsvc_NetShareInfo501_get_name(PyObject *obj, void *closure)
4588 {
4589         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4590         PyObject *py_name;
4591         if (object->name == NULL) {
4592                 py_name = Py_None;
4593                 Py_INCREF(py_name);
4594         } else {
4595                 if (object->name == NULL) {
4596                         py_name = Py_None;
4597                         Py_INCREF(py_name);
4598                 } else {
4599                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4600                 }
4601         }
4602         return py_name;
4603 }
4604
4605 static int py_srvsvc_NetShareInfo501_set_name(PyObject *py_obj, PyObject *value, void *closure)
4606 {
4607         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4608         if (value == Py_None) {
4609                 object->name = NULL;
4610         } else {
4611                 object->name = NULL;
4612                 if (PyUnicode_Check(value)) {
4613                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4614                 } else if (PyString_Check(value)) {
4615                         object->name = PyString_AS_STRING(value);
4616                 } else {
4617                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4618                         return -1;
4619                 }
4620         }
4621         return 0;
4622 }
4623
4624 static PyObject *py_srvsvc_NetShareInfo501_get_type(PyObject *obj, void *closure)
4625 {
4626         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4627         PyObject *py_type;
4628         py_type = PyInt_FromLong(object->type);
4629         return py_type;
4630 }
4631
4632 static int py_srvsvc_NetShareInfo501_set_type(PyObject *py_obj, PyObject *value, void *closure)
4633 {
4634         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4635         if (PyLong_Check(value)) {
4636                 object->type = PyLong_AsLongLong(value);
4637         } else if (PyInt_Check(value)) {
4638                 object->type = PyInt_AsLong(value);
4639         } else {
4640                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4641                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4642                 return -1;
4643         }
4644         return 0;
4645 }
4646
4647 static PyObject *py_srvsvc_NetShareInfo501_get_comment(PyObject *obj, void *closure)
4648 {
4649         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4650         PyObject *py_comment;
4651         if (object->comment == NULL) {
4652                 py_comment = Py_None;
4653                 Py_INCREF(py_comment);
4654         } else {
4655                 if (object->comment == NULL) {
4656                         py_comment = Py_None;
4657                         Py_INCREF(py_comment);
4658                 } else {
4659                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4660                 }
4661         }
4662         return py_comment;
4663 }
4664
4665 static int py_srvsvc_NetShareInfo501_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4666 {
4667         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4668         if (value == Py_None) {
4669                 object->comment = NULL;
4670         } else {
4671                 object->comment = NULL;
4672                 if (PyUnicode_Check(value)) {
4673                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4674                 } else if (PyString_Check(value)) {
4675                         object->comment = PyString_AS_STRING(value);
4676                 } else {
4677                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4678                         return -1;
4679                 }
4680         }
4681         return 0;
4682 }
4683
4684 static PyObject *py_srvsvc_NetShareInfo501_get_csc_policy(PyObject *obj, void *closure)
4685 {
4686         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(obj);
4687         PyObject *py_csc_policy;
4688         py_csc_policy = PyInt_FromLong(object->csc_policy);
4689         return py_csc_policy;
4690 }
4691
4692 static int py_srvsvc_NetShareInfo501_set_csc_policy(PyObject *py_obj, PyObject *value, void *closure)
4693 {
4694         struct srvsvc_NetShareInfo501 *object = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(py_obj);
4695         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4696         object->csc_policy = PyInt_AsLong(value);
4697         return 0;
4698 }
4699
4700 static PyGetSetDef py_srvsvc_NetShareInfo501_getsetters[] = {
4701         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo501_get_name, py_srvsvc_NetShareInfo501_set_name },
4702         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo501_get_type, py_srvsvc_NetShareInfo501_set_type },
4703         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo501_get_comment, py_srvsvc_NetShareInfo501_set_comment },
4704         { discard_const_p(char, "csc_policy"), py_srvsvc_NetShareInfo501_get_csc_policy, py_srvsvc_NetShareInfo501_set_csc_policy },
4705         { NULL }
4706 };
4707
4708 static PyObject *py_srvsvc_NetShareInfo501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4709 {
4710         return pytalloc_new(struct srvsvc_NetShareInfo501, type);
4711 }
4712
4713
4714 static PyTypeObject srvsvc_NetShareInfo501_Type = {
4715         PyObject_HEAD_INIT(NULL) 0,
4716         .tp_name = "srvsvc.NetShareInfo501",
4717         .tp_getset = py_srvsvc_NetShareInfo501_getsetters,
4718         .tp_methods = NULL,
4719         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4720         .tp_basicsize = sizeof(pytalloc_Object),
4721         .tp_new = py_srvsvc_NetShareInfo501_new,
4722 };
4723
4724
4725 static PyObject *py_srvsvc_NetShareCtr501_get_count(PyObject *obj, void *closure)
4726 {
4727         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
4728         PyObject *py_count;
4729         py_count = PyInt_FromLong(object->count);
4730         return py_count;
4731 }
4732
4733 static int py_srvsvc_NetShareCtr501_set_count(PyObject *py_obj, PyObject *value, void *closure)
4734 {
4735         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(py_obj);
4736         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4737         object->count = PyInt_AsLong(value);
4738         return 0;
4739 }
4740
4741 static PyObject *py_srvsvc_NetShareCtr501_get_array(PyObject *obj, void *closure)
4742 {
4743         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(obj);
4744         PyObject *py_array;
4745         if (object->array == NULL) {
4746                 py_array = Py_None;
4747                 Py_INCREF(py_array);
4748         } else {
4749                 py_array = PyList_New(object->count);
4750                 if (py_array == NULL) {
4751                         return NULL;
4752                 }
4753                 {
4754                         int array_cntr_1;
4755                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
4756                                 PyObject *py_array_1;
4757                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, object->array, &object->array[array_cntr_1]);
4758                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
4759                         }
4760                 }
4761         }
4762         return py_array;
4763 }
4764
4765 static int py_srvsvc_NetShareCtr501_set_array(PyObject *py_obj, PyObject *value, void *closure)
4766 {
4767         struct srvsvc_NetShareCtr501 *object = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(py_obj);
4768         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
4769         if (value == Py_None) {
4770                 object->array = NULL;
4771         } else {
4772                 object->array = NULL;
4773                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4774                 {
4775                         int array_cntr_1;
4776                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
4777                         if (!object->array) { return -1;; }
4778                         talloc_set_name_const(object->array, "ARRAY: object->array");
4779                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
4780                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
4781                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
4782                                         PyErr_NoMemory();
4783                                         return -1;
4784                                 }
4785                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
4786                         }
4787                 }
4788         }
4789         return 0;
4790 }
4791
4792 static PyGetSetDef py_srvsvc_NetShareCtr501_getsetters[] = {
4793         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr501_get_count, py_srvsvc_NetShareCtr501_set_count },
4794         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr501_get_array, py_srvsvc_NetShareCtr501_set_array },
4795         { NULL }
4796 };
4797
4798 static PyObject *py_srvsvc_NetShareCtr501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4799 {
4800         return pytalloc_new(struct srvsvc_NetShareCtr501, type);
4801 }
4802
4803
4804 static PyTypeObject srvsvc_NetShareCtr501_Type = {
4805         PyObject_HEAD_INIT(NULL) 0,
4806         .tp_name = "srvsvc.NetShareCtr501",
4807         .tp_getset = py_srvsvc_NetShareCtr501_getsetters,
4808         .tp_methods = NULL,
4809         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4810         .tp_basicsize = sizeof(pytalloc_Object),
4811         .tp_new = py_srvsvc_NetShareCtr501_new,
4812 };
4813
4814
4815 static PyObject *py_srvsvc_NetShareInfo502_get_name(PyObject *obj, void *closure)
4816 {
4817         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4818         PyObject *py_name;
4819         if (object->name == NULL) {
4820                 py_name = Py_None;
4821                 Py_INCREF(py_name);
4822         } else {
4823                 if (object->name == NULL) {
4824                         py_name = Py_None;
4825                         Py_INCREF(py_name);
4826                 } else {
4827                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
4828                 }
4829         }
4830         return py_name;
4831 }
4832
4833 static int py_srvsvc_NetShareInfo502_set_name(PyObject *py_obj, PyObject *value, void *closure)
4834 {
4835         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4836         if (value == Py_None) {
4837                 object->name = NULL;
4838         } else {
4839                 object->name = NULL;
4840                 if (PyUnicode_Check(value)) {
4841                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4842                 } else if (PyString_Check(value)) {
4843                         object->name = PyString_AS_STRING(value);
4844                 } else {
4845                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4846                         return -1;
4847                 }
4848         }
4849         return 0;
4850 }
4851
4852 static PyObject *py_srvsvc_NetShareInfo502_get_type(PyObject *obj, void *closure)
4853 {
4854         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4855         PyObject *py_type;
4856         py_type = PyInt_FromLong(object->type);
4857         return py_type;
4858 }
4859
4860 static int py_srvsvc_NetShareInfo502_set_type(PyObject *py_obj, PyObject *value, void *closure)
4861 {
4862         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4863         if (PyLong_Check(value)) {
4864                 object->type = PyLong_AsLongLong(value);
4865         } else if (PyInt_Check(value)) {
4866                 object->type = PyInt_AsLong(value);
4867         } else {
4868                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4869                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4870                 return -1;
4871         }
4872         return 0;
4873 }
4874
4875 static PyObject *py_srvsvc_NetShareInfo502_get_comment(PyObject *obj, void *closure)
4876 {
4877         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4878         PyObject *py_comment;
4879         if (object->comment == NULL) {
4880                 py_comment = Py_None;
4881                 Py_INCREF(py_comment);
4882         } else {
4883                 if (object->comment == NULL) {
4884                         py_comment = Py_None;
4885                         Py_INCREF(py_comment);
4886                 } else {
4887                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
4888                 }
4889         }
4890         return py_comment;
4891 }
4892
4893 static int py_srvsvc_NetShareInfo502_set_comment(PyObject *py_obj, PyObject *value, void *closure)
4894 {
4895         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4896         if (value == Py_None) {
4897                 object->comment = NULL;
4898         } else {
4899                 object->comment = NULL;
4900                 if (PyUnicode_Check(value)) {
4901                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4902                 } else if (PyString_Check(value)) {
4903                         object->comment = PyString_AS_STRING(value);
4904                 } else {
4905                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4906                         return -1;
4907                 }
4908         }
4909         return 0;
4910 }
4911
4912 static PyObject *py_srvsvc_NetShareInfo502_get_permissions(PyObject *obj, void *closure)
4913 {
4914         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4915         PyObject *py_permissions;
4916         py_permissions = PyInt_FromLong(object->permissions);
4917         return py_permissions;
4918 }
4919
4920 static int py_srvsvc_NetShareInfo502_set_permissions(PyObject *py_obj, PyObject *value, void *closure)
4921 {
4922         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4923         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4924         object->permissions = PyInt_AsLong(value);
4925         return 0;
4926 }
4927
4928 static PyObject *py_srvsvc_NetShareInfo502_get_max_users(PyObject *obj, void *closure)
4929 {
4930         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4931         PyObject *py_max_users;
4932         py_max_users = PyInt_FromLong(object->max_users);
4933         return py_max_users;
4934 }
4935
4936 static int py_srvsvc_NetShareInfo502_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
4937 {
4938         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4939         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4940         object->max_users = PyInt_AsLong(value);
4941         return 0;
4942 }
4943
4944 static PyObject *py_srvsvc_NetShareInfo502_get_current_users(PyObject *obj, void *closure)
4945 {
4946         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4947         PyObject *py_current_users;
4948         py_current_users = PyInt_FromLong(object->current_users);
4949         return py_current_users;
4950 }
4951
4952 static int py_srvsvc_NetShareInfo502_set_current_users(PyObject *py_obj, PyObject *value, void *closure)
4953 {
4954         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4955         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4956         object->current_users = PyInt_AsLong(value);
4957         return 0;
4958 }
4959
4960 static PyObject *py_srvsvc_NetShareInfo502_get_path(PyObject *obj, void *closure)
4961 {
4962         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
4963         PyObject *py_path;
4964         if (object->path == NULL) {
4965                 py_path = Py_None;
4966                 Py_INCREF(py_path);
4967         } else {
4968                 if (object->path == NULL) {
4969                         py_path = Py_None;
4970                         Py_INCREF(py_path);
4971                 } else {
4972                         py_path = PyUnicode_Decode(object->path, strlen(object->path), "utf-8", "ignore");
4973                 }
4974         }
4975         return py_path;
4976 }
4977
4978 static int py_srvsvc_NetShareInfo502_set_path(PyObject *py_obj, PyObject *value, void *closure)
4979 {
4980         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
4981         if (value == Py_None) {
4982                 object->path = NULL;
4983         } else {
4984                 object->path = NULL;
4985                 if (PyUnicode_Check(value)) {
4986                         object->path = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4987                 } else if (PyString_Check(value)) {
4988                         object->path = PyString_AS_STRING(value);
4989                 } else {
4990                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
4991                         return -1;
4992                 }
4993         }
4994         return 0;
4995 }
4996
4997 static PyObject *py_srvsvc_NetShareInfo502_get_password(PyObject *obj, void *closure)
4998 {
4999         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
5000         PyObject *py_password;
5001         if (object->password == NULL) {
5002                 py_password = Py_None;
5003                 Py_INCREF(py_password);
5004         } else {
5005                 if (object->password == NULL) {
5006                         py_password = Py_None;
5007                         Py_INCREF(py_password);
5008                 } else {
5009                         py_password = PyUnicode_Decode(object->password, strlen(object->password), "utf-8", "ignore");
5010                 }
5011         }
5012         return py_password;
5013 }
5014
5015 static int py_srvsvc_NetShareInfo502_set_password(PyObject *py_obj, PyObject *value, void *closure)
5016 {
5017         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
5018         if (value == Py_None) {
5019                 object->password = NULL;
5020         } else {
5021                 object->password = NULL;
5022                 if (PyUnicode_Check(value)) {
5023                         object->password = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5024                 } else if (PyString_Check(value)) {
5025                         object->password = PyString_AS_STRING(value);
5026                 } else {
5027                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5028                         return -1;
5029                 }
5030         }
5031         return 0;
5032 }
5033
5034 static PyObject *py_srvsvc_NetShareInfo502_get_sd_buf(PyObject *obj, void *closure)
5035 {
5036         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(obj);
5037         PyObject *py_sd_buf;
5038         py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, pytalloc_get_mem_ctx(obj), &object->sd_buf);
5039         return py_sd_buf;
5040 }
5041
5042 static int py_srvsvc_NetShareInfo502_set_sd_buf(PyObject *py_obj, PyObject *value, void *closure)
5043 {
5044         struct srvsvc_NetShareInfo502 *object = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(py_obj);
5045         PY_CHECK_TYPE(sec_desc_buf_Type, value, return -1;);
5046         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
5047                 PyErr_NoMemory();
5048                 return -1;
5049         }
5050         object->sd_buf = *(struct sec_desc_buf *)pytalloc_get_ptr(value);
5051         return 0;
5052 }
5053
5054 static PyGetSetDef py_srvsvc_NetShareInfo502_getsetters[] = {
5055         { discard_const_p(char, "name"), py_srvsvc_NetShareInfo502_get_name, py_srvsvc_NetShareInfo502_set_name },
5056         { discard_const_p(char, "type"), py_srvsvc_NetShareInfo502_get_type, py_srvsvc_NetShareInfo502_set_type },
5057         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo502_get_comment, py_srvsvc_NetShareInfo502_set_comment },
5058         { discard_const_p(char, "permissions"), py_srvsvc_NetShareInfo502_get_permissions, py_srvsvc_NetShareInfo502_set_permissions },
5059         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo502_get_max_users, py_srvsvc_NetShareInfo502_set_max_users },
5060         { discard_const_p(char, "current_users"), py_srvsvc_NetShareInfo502_get_current_users, py_srvsvc_NetShareInfo502_set_current_users },
5061         { discard_const_p(char, "path"), py_srvsvc_NetShareInfo502_get_path, py_srvsvc_NetShareInfo502_set_path },
5062         { discard_const_p(char, "password"), py_srvsvc_NetShareInfo502_get_password, py_srvsvc_NetShareInfo502_set_password },
5063         { discard_const_p(char, "sd_buf"), py_srvsvc_NetShareInfo502_get_sd_buf, py_srvsvc_NetShareInfo502_set_sd_buf },
5064         { NULL }
5065 };
5066
5067 static PyObject *py_srvsvc_NetShareInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5068 {
5069         return pytalloc_new(struct srvsvc_NetShareInfo502, type);
5070 }
5071
5072
5073 static PyTypeObject srvsvc_NetShareInfo502_Type = {
5074         PyObject_HEAD_INIT(NULL) 0,
5075         .tp_name = "srvsvc.NetShareInfo502",
5076         .tp_getset = py_srvsvc_NetShareInfo502_getsetters,
5077         .tp_methods = NULL,
5078         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5079         .tp_basicsize = sizeof(pytalloc_Object),
5080         .tp_new = py_srvsvc_NetShareInfo502_new,
5081 };
5082
5083
5084 static PyObject *py_srvsvc_NetShareCtr502_get_count(PyObject *obj, void *closure)
5085 {
5086         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
5087         PyObject *py_count;
5088         py_count = PyInt_FromLong(object->count);
5089         return py_count;
5090 }
5091
5092 static int py_srvsvc_NetShareCtr502_set_count(PyObject *py_obj, PyObject *value, void *closure)
5093 {
5094         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(py_obj);
5095         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5096         object->count = PyInt_AsLong(value);
5097         return 0;
5098 }
5099
5100 static PyObject *py_srvsvc_NetShareCtr502_get_array(PyObject *obj, void *closure)
5101 {
5102         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(obj);
5103         PyObject *py_array;
5104         if (object->array == NULL) {
5105                 py_array = Py_None;
5106                 Py_INCREF(py_array);
5107         } else {
5108                 py_array = PyList_New(object->count);
5109                 if (py_array == NULL) {
5110                         return NULL;
5111                 }
5112                 {
5113                         int array_cntr_1;
5114                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5115                                 PyObject *py_array_1;
5116                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, object->array, &object->array[array_cntr_1]);
5117                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5118                         }
5119                 }
5120         }
5121         return py_array;
5122 }
5123
5124 static int py_srvsvc_NetShareCtr502_set_array(PyObject *py_obj, PyObject *value, void *closure)
5125 {
5126         struct srvsvc_NetShareCtr502 *object = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(py_obj);
5127         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5128         if (value == Py_None) {
5129                 object->array = NULL;
5130         } else {
5131                 object->array = NULL;
5132                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5133                 {
5134                         int array_cntr_1;
5135                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5136                         if (!object->array) { return -1;; }
5137                         talloc_set_name_const(object->array, "ARRAY: object->array");
5138                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5139                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5140                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5141                                         PyErr_NoMemory();
5142                                         return -1;
5143                                 }
5144                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5145                         }
5146                 }
5147         }
5148         return 0;
5149 }
5150
5151 static PyGetSetDef py_srvsvc_NetShareCtr502_getsetters[] = {
5152         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr502_get_count, py_srvsvc_NetShareCtr502_set_count },
5153         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr502_get_array, py_srvsvc_NetShareCtr502_set_array },
5154         { NULL }
5155 };
5156
5157 static PyObject *py_srvsvc_NetShareCtr502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5158 {
5159         return pytalloc_new(struct srvsvc_NetShareCtr502, type);
5160 }
5161
5162
5163 static PyTypeObject srvsvc_NetShareCtr502_Type = {
5164         PyObject_HEAD_INIT(NULL) 0,
5165         .tp_name = "srvsvc.NetShareCtr502",
5166         .tp_getset = py_srvsvc_NetShareCtr502_getsetters,
5167         .tp_methods = NULL,
5168         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5169         .tp_basicsize = sizeof(pytalloc_Object),
5170         .tp_new = py_srvsvc_NetShareCtr502_new,
5171 };
5172
5173
5174 static PyObject *py_srvsvc_NetShareInfo1004_get_comment(PyObject *obj, void *closure)
5175 {
5176         struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(obj);
5177         PyObject *py_comment;
5178         if (object->comment == NULL) {
5179                 py_comment = Py_None;
5180                 Py_INCREF(py_comment);
5181         } else {
5182                 if (object->comment == NULL) {
5183                         py_comment = Py_None;
5184                         Py_INCREF(py_comment);
5185                 } else {
5186                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
5187                 }
5188         }
5189         return py_comment;
5190 }
5191
5192 static int py_srvsvc_NetShareInfo1004_set_comment(PyObject *py_obj, PyObject *value, void *closure)
5193 {
5194         struct srvsvc_NetShareInfo1004 *object = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(py_obj);
5195         if (value == Py_None) {
5196                 object->comment = NULL;
5197         } else {
5198                 object->comment = NULL;
5199                 if (PyUnicode_Check(value)) {
5200                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5201                 } else if (PyString_Check(value)) {
5202                         object->comment = PyString_AS_STRING(value);
5203                 } else {
5204                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5205                         return -1;
5206                 }
5207         }
5208         return 0;
5209 }
5210
5211 static PyGetSetDef py_srvsvc_NetShareInfo1004_getsetters[] = {
5212         { discard_const_p(char, "comment"), py_srvsvc_NetShareInfo1004_get_comment, py_srvsvc_NetShareInfo1004_set_comment },
5213         { NULL }
5214 };
5215
5216 static PyObject *py_srvsvc_NetShareInfo1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5217 {
5218         return pytalloc_new(struct srvsvc_NetShareInfo1004, type);
5219 }
5220
5221
5222 static PyTypeObject srvsvc_NetShareInfo1004_Type = {
5223         PyObject_HEAD_INIT(NULL) 0,
5224         .tp_name = "srvsvc.NetShareInfo1004",
5225         .tp_getset = py_srvsvc_NetShareInfo1004_getsetters,
5226         .tp_methods = NULL,
5227         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5228         .tp_basicsize = sizeof(pytalloc_Object),
5229         .tp_new = py_srvsvc_NetShareInfo1004_new,
5230 };
5231
5232
5233 static PyObject *py_srvsvc_NetShareCtr1004_get_count(PyObject *obj, void *closure)
5234 {
5235         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
5236         PyObject *py_count;
5237         py_count = PyInt_FromLong(object->count);
5238         return py_count;
5239 }
5240
5241 static int py_srvsvc_NetShareCtr1004_set_count(PyObject *py_obj, PyObject *value, void *closure)
5242 {
5243         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(py_obj);
5244         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5245         object->count = PyInt_AsLong(value);
5246         return 0;
5247 }
5248
5249 static PyObject *py_srvsvc_NetShareCtr1004_get_array(PyObject *obj, void *closure)
5250 {
5251         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(obj);
5252         PyObject *py_array;
5253         if (object->array == NULL) {
5254                 py_array = Py_None;
5255                 Py_INCREF(py_array);
5256         } else {
5257                 py_array = PyList_New(object->count);
5258                 if (py_array == NULL) {
5259                         return NULL;
5260                 }
5261                 {
5262                         int array_cntr_1;
5263                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5264                                 PyObject *py_array_1;
5265                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, object->array, &object->array[array_cntr_1]);
5266                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5267                         }
5268                 }
5269         }
5270         return py_array;
5271 }
5272
5273 static int py_srvsvc_NetShareCtr1004_set_array(PyObject *py_obj, PyObject *value, void *closure)
5274 {
5275         struct srvsvc_NetShareCtr1004 *object = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(py_obj);
5276         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5277         if (value == Py_None) {
5278                 object->array = NULL;
5279         } else {
5280                 object->array = NULL;
5281                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5282                 {
5283                         int array_cntr_1;
5284                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5285                         if (!object->array) { return -1;; }
5286                         talloc_set_name_const(object->array, "ARRAY: object->array");
5287                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5288                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5289                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5290                                         PyErr_NoMemory();
5291                                         return -1;
5292                                 }
5293                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5294                         }
5295                 }
5296         }
5297         return 0;
5298 }
5299
5300 static PyGetSetDef py_srvsvc_NetShareCtr1004_getsetters[] = {
5301         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1004_get_count, py_srvsvc_NetShareCtr1004_set_count },
5302         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1004_get_array, py_srvsvc_NetShareCtr1004_set_array },
5303         { NULL }
5304 };
5305
5306 static PyObject *py_srvsvc_NetShareCtr1004_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5307 {
5308         return pytalloc_new(struct srvsvc_NetShareCtr1004, type);
5309 }
5310
5311
5312 static PyTypeObject srvsvc_NetShareCtr1004_Type = {
5313         PyObject_HEAD_INIT(NULL) 0,
5314         .tp_name = "srvsvc.NetShareCtr1004",
5315         .tp_getset = py_srvsvc_NetShareCtr1004_getsetters,
5316         .tp_methods = NULL,
5317         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5318         .tp_basicsize = sizeof(pytalloc_Object),
5319         .tp_new = py_srvsvc_NetShareCtr1004_new,
5320 };
5321
5322
5323 static PyObject *py_srvsvc_NetShareInfo1005_get_dfs_flags(PyObject *obj, void *closure)
5324 {
5325         struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(obj);
5326         PyObject *py_dfs_flags;
5327         py_dfs_flags = PyInt_FromLong(object->dfs_flags);
5328         return py_dfs_flags;
5329 }
5330
5331 static int py_srvsvc_NetShareInfo1005_set_dfs_flags(PyObject *py_obj, PyObject *value, void *closure)
5332 {
5333         struct srvsvc_NetShareInfo1005 *object = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(py_obj);
5334         if (PyLong_Check(value)) {
5335                 object->dfs_flags = PyLong_AsLongLong(value);
5336         } else if (PyInt_Check(value)) {
5337                 object->dfs_flags = PyInt_AsLong(value);
5338         } else {
5339                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5340                   PyInt_Type.tp_name, PyLong_Type.tp_name);
5341                 return -1;
5342         }
5343         return 0;
5344 }
5345
5346 static PyGetSetDef py_srvsvc_NetShareInfo1005_getsetters[] = {
5347         { discard_const_p(char, "dfs_flags"), py_srvsvc_NetShareInfo1005_get_dfs_flags, py_srvsvc_NetShareInfo1005_set_dfs_flags },
5348         { NULL }
5349 };
5350
5351 static PyObject *py_srvsvc_NetShareInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5352 {
5353         return pytalloc_new(struct srvsvc_NetShareInfo1005, type);
5354 }
5355
5356
5357 static PyTypeObject srvsvc_NetShareInfo1005_Type = {
5358         PyObject_HEAD_INIT(NULL) 0,
5359         .tp_name = "srvsvc.NetShareInfo1005",
5360         .tp_getset = py_srvsvc_NetShareInfo1005_getsetters,
5361         .tp_methods = NULL,
5362         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5363         .tp_basicsize = sizeof(pytalloc_Object),
5364         .tp_new = py_srvsvc_NetShareInfo1005_new,
5365 };
5366
5367
5368 static PyObject *py_srvsvc_NetShareCtr1005_get_count(PyObject *obj, void *closure)
5369 {
5370         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
5371         PyObject *py_count;
5372         py_count = PyInt_FromLong(object->count);
5373         return py_count;
5374 }
5375
5376 static int py_srvsvc_NetShareCtr1005_set_count(PyObject *py_obj, PyObject *value, void *closure)
5377 {
5378         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(py_obj);
5379         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5380         object->count = PyInt_AsLong(value);
5381         return 0;
5382 }
5383
5384 static PyObject *py_srvsvc_NetShareCtr1005_get_array(PyObject *obj, void *closure)
5385 {
5386         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(obj);
5387         PyObject *py_array;
5388         if (object->array == NULL) {
5389                 py_array = Py_None;
5390                 Py_INCREF(py_array);
5391         } else {
5392                 py_array = PyList_New(object->count);
5393                 if (py_array == NULL) {
5394                         return NULL;
5395                 }
5396                 {
5397                         int array_cntr_1;
5398                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5399                                 PyObject *py_array_1;
5400                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, object->array, &object->array[array_cntr_1]);
5401                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5402                         }
5403                 }
5404         }
5405         return py_array;
5406 }
5407
5408 static int py_srvsvc_NetShareCtr1005_set_array(PyObject *py_obj, PyObject *value, void *closure)
5409 {
5410         struct srvsvc_NetShareCtr1005 *object = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(py_obj);
5411         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5412         if (value == Py_None) {
5413                 object->array = NULL;
5414         } else {
5415                 object->array = NULL;
5416                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5417                 {
5418                         int array_cntr_1;
5419                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5420                         if (!object->array) { return -1;; }
5421                         talloc_set_name_const(object->array, "ARRAY: object->array");
5422                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5423                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5424                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5425                                         PyErr_NoMemory();
5426                                         return -1;
5427                                 }
5428                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5429                         }
5430                 }
5431         }
5432         return 0;
5433 }
5434
5435 static PyGetSetDef py_srvsvc_NetShareCtr1005_getsetters[] = {
5436         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1005_get_count, py_srvsvc_NetShareCtr1005_set_count },
5437         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1005_get_array, py_srvsvc_NetShareCtr1005_set_array },
5438         { NULL }
5439 };
5440
5441 static PyObject *py_srvsvc_NetShareCtr1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5442 {
5443         return pytalloc_new(struct srvsvc_NetShareCtr1005, type);
5444 }
5445
5446
5447 static PyTypeObject srvsvc_NetShareCtr1005_Type = {
5448         PyObject_HEAD_INIT(NULL) 0,
5449         .tp_name = "srvsvc.NetShareCtr1005",
5450         .tp_getset = py_srvsvc_NetShareCtr1005_getsetters,
5451         .tp_methods = NULL,
5452         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5453         .tp_basicsize = sizeof(pytalloc_Object),
5454         .tp_new = py_srvsvc_NetShareCtr1005_new,
5455 };
5456
5457
5458 static PyObject *py_srvsvc_NetShareInfo1006_get_max_users(PyObject *obj, void *closure)
5459 {
5460         struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(obj);
5461         PyObject *py_max_users;
5462         py_max_users = PyInt_FromLong(object->max_users);
5463         return py_max_users;
5464 }
5465
5466 static int py_srvsvc_NetShareInfo1006_set_max_users(PyObject *py_obj, PyObject *value, void *closure)
5467 {
5468         struct srvsvc_NetShareInfo1006 *object = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(py_obj);
5469         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5470         object->max_users = PyInt_AsLong(value);
5471         return 0;
5472 }
5473
5474 static PyGetSetDef py_srvsvc_NetShareInfo1006_getsetters[] = {
5475         { discard_const_p(char, "max_users"), py_srvsvc_NetShareInfo1006_get_max_users, py_srvsvc_NetShareInfo1006_set_max_users },
5476         { NULL }
5477 };
5478
5479 static PyObject *py_srvsvc_NetShareInfo1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5480 {
5481         return pytalloc_new(struct srvsvc_NetShareInfo1006, type);
5482 }
5483
5484
5485 static PyTypeObject srvsvc_NetShareInfo1006_Type = {
5486         PyObject_HEAD_INIT(NULL) 0,
5487         .tp_name = "srvsvc.NetShareInfo1006",
5488         .tp_getset = py_srvsvc_NetShareInfo1006_getsetters,
5489         .tp_methods = NULL,
5490         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5491         .tp_basicsize = sizeof(pytalloc_Object),
5492         .tp_new = py_srvsvc_NetShareInfo1006_new,
5493 };
5494
5495
5496 static PyObject *py_srvsvc_NetShareCtr1006_get_count(PyObject *obj, void *closure)
5497 {
5498         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
5499         PyObject *py_count;
5500         py_count = PyInt_FromLong(object->count);
5501         return py_count;
5502 }
5503
5504 static int py_srvsvc_NetShareCtr1006_set_count(PyObject *py_obj, PyObject *value, void *closure)
5505 {
5506         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(py_obj);
5507         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5508         object->count = PyInt_AsLong(value);
5509         return 0;
5510 }
5511
5512 static PyObject *py_srvsvc_NetShareCtr1006_get_array(PyObject *obj, void *closure)
5513 {
5514         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(obj);
5515         PyObject *py_array;
5516         if (object->array == NULL) {
5517                 py_array = Py_None;
5518                 Py_INCREF(py_array);
5519         } else {
5520                 py_array = PyList_New(object->count);
5521                 if (py_array == NULL) {
5522                         return NULL;
5523                 }
5524                 {
5525                         int array_cntr_1;
5526                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5527                                 PyObject *py_array_1;
5528                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, object->array, &object->array[array_cntr_1]);
5529                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5530                         }
5531                 }
5532         }
5533         return py_array;
5534 }
5535
5536 static int py_srvsvc_NetShareCtr1006_set_array(PyObject *py_obj, PyObject *value, void *closure)
5537 {
5538         struct srvsvc_NetShareCtr1006 *object = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(py_obj);
5539         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5540         if (value == Py_None) {
5541                 object->array = NULL;
5542         } else {
5543                 object->array = NULL;
5544                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5545                 {
5546                         int array_cntr_1;
5547                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5548                         if (!object->array) { return -1;; }
5549                         talloc_set_name_const(object->array, "ARRAY: object->array");
5550                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5551                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5552                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5553                                         PyErr_NoMemory();
5554                                         return -1;
5555                                 }
5556                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5557                         }
5558                 }
5559         }
5560         return 0;
5561 }
5562
5563 static PyGetSetDef py_srvsvc_NetShareCtr1006_getsetters[] = {
5564         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1006_get_count, py_srvsvc_NetShareCtr1006_set_count },
5565         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1006_get_array, py_srvsvc_NetShareCtr1006_set_array },
5566         { NULL }
5567 };
5568
5569 static PyObject *py_srvsvc_NetShareCtr1006_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5570 {
5571         return pytalloc_new(struct srvsvc_NetShareCtr1006, type);
5572 }
5573
5574
5575 static PyTypeObject srvsvc_NetShareCtr1006_Type = {
5576         PyObject_HEAD_INIT(NULL) 0,
5577         .tp_name = "srvsvc.NetShareCtr1006",
5578         .tp_getset = py_srvsvc_NetShareCtr1006_getsetters,
5579         .tp_methods = NULL,
5580         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5581         .tp_basicsize = sizeof(pytalloc_Object),
5582         .tp_new = py_srvsvc_NetShareCtr1006_new,
5583 };
5584
5585
5586 static PyObject *py_srvsvc_NetShareInfo1007_get_flags(PyObject *obj, void *closure)
5587 {
5588         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
5589         PyObject *py_flags;
5590         py_flags = PyInt_FromLong(object->flags);
5591         return py_flags;
5592 }
5593
5594 static int py_srvsvc_NetShareInfo1007_set_flags(PyObject *py_obj, PyObject *value, void *closure)
5595 {
5596         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
5597         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5598         object->flags = PyInt_AsLong(value);
5599         return 0;
5600 }
5601
5602 static PyObject *py_srvsvc_NetShareInfo1007_get_alternate_directory_name(PyObject *obj, void *closure)
5603 {
5604         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(obj);
5605         PyObject *py_alternate_directory_name;
5606         if (object->alternate_directory_name == NULL) {
5607                 py_alternate_directory_name = Py_None;
5608                 Py_INCREF(py_alternate_directory_name);
5609         } else {
5610                 if (object->alternate_directory_name == NULL) {
5611                         py_alternate_directory_name = Py_None;
5612                         Py_INCREF(py_alternate_directory_name);
5613                 } else {
5614                         py_alternate_directory_name = PyUnicode_Decode(object->alternate_directory_name, strlen(object->alternate_directory_name), "utf-8", "ignore");
5615                 }
5616         }
5617         return py_alternate_directory_name;
5618 }
5619
5620 static int py_srvsvc_NetShareInfo1007_set_alternate_directory_name(PyObject *py_obj, PyObject *value, void *closure)
5621 {
5622         struct srvsvc_NetShareInfo1007 *object = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(py_obj);
5623         if (value == Py_None) {
5624                 object->alternate_directory_name = NULL;
5625         } else {
5626                 object->alternate_directory_name = NULL;
5627                 if (PyUnicode_Check(value)) {
5628                         object->alternate_directory_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5629                 } else if (PyString_Check(value)) {
5630                         object->alternate_directory_name = PyString_AS_STRING(value);
5631                 } else {
5632                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5633                         return -1;
5634                 }
5635         }
5636         return 0;
5637 }
5638
5639 static PyGetSetDef py_srvsvc_NetShareInfo1007_getsetters[] = {
5640         { discard_const_p(char, "flags"), py_srvsvc_NetShareInfo1007_get_flags, py_srvsvc_NetShareInfo1007_set_flags },
5641         { discard_const_p(char, "alternate_directory_name"), py_srvsvc_NetShareInfo1007_get_alternate_directory_name, py_srvsvc_NetShareInfo1007_set_alternate_directory_name },
5642         { NULL }
5643 };
5644
5645 static PyObject *py_srvsvc_NetShareInfo1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5646 {
5647         return pytalloc_new(struct srvsvc_NetShareInfo1007, type);
5648 }
5649
5650
5651 static PyTypeObject srvsvc_NetShareInfo1007_Type = {
5652         PyObject_HEAD_INIT(NULL) 0,
5653         .tp_name = "srvsvc.NetShareInfo1007",
5654         .tp_getset = py_srvsvc_NetShareInfo1007_getsetters,
5655         .tp_methods = NULL,
5656         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5657         .tp_basicsize = sizeof(pytalloc_Object),
5658         .tp_new = py_srvsvc_NetShareInfo1007_new,
5659 };
5660
5661
5662 static PyObject *py_srvsvc_NetShareCtr1007_get_count(PyObject *obj, void *closure)
5663 {
5664         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
5665         PyObject *py_count;
5666         py_count = PyInt_FromLong(object->count);
5667         return py_count;
5668 }
5669
5670 static int py_srvsvc_NetShareCtr1007_set_count(PyObject *py_obj, PyObject *value, void *closure)
5671 {
5672         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(py_obj);
5673         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5674         object->count = PyInt_AsLong(value);
5675         return 0;
5676 }
5677
5678 static PyObject *py_srvsvc_NetShareCtr1007_get_array(PyObject *obj, void *closure)
5679 {
5680         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(obj);
5681         PyObject *py_array;
5682         if (object->array == NULL) {
5683                 py_array = Py_None;
5684                 Py_INCREF(py_array);
5685         } else {
5686                 py_array = PyList_New(object->count);
5687                 if (py_array == NULL) {
5688                         return NULL;
5689                 }
5690                 {
5691                         int array_cntr_1;
5692                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5693                                 PyObject *py_array_1;
5694                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, object->array, &object->array[array_cntr_1]);
5695                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5696                         }
5697                 }
5698         }
5699         return py_array;
5700 }
5701
5702 static int py_srvsvc_NetShareCtr1007_set_array(PyObject *py_obj, PyObject *value, void *closure)
5703 {
5704         struct srvsvc_NetShareCtr1007 *object = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(py_obj);
5705         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5706         if (value == Py_None) {
5707                 object->array = NULL;
5708         } else {
5709                 object->array = NULL;
5710                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5711                 {
5712                         int array_cntr_1;
5713                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5714                         if (!object->array) { return -1;; }
5715                         talloc_set_name_const(object->array, "ARRAY: object->array");
5716                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5717                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5718                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5719                                         PyErr_NoMemory();
5720                                         return -1;
5721                                 }
5722                                 object->array[array_cntr_1] = *(struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5723                         }
5724                 }
5725         }
5726         return 0;
5727 }
5728
5729 static PyGetSetDef py_srvsvc_NetShareCtr1007_getsetters[] = {
5730         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1007_get_count, py_srvsvc_NetShareCtr1007_set_count },
5731         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1007_get_array, py_srvsvc_NetShareCtr1007_set_array },
5732         { NULL }
5733 };
5734
5735 static PyObject *py_srvsvc_NetShareCtr1007_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5736 {
5737         return pytalloc_new(struct srvsvc_NetShareCtr1007, type);
5738 }
5739
5740
5741 static PyTypeObject srvsvc_NetShareCtr1007_Type = {
5742         PyObject_HEAD_INIT(NULL) 0,
5743         .tp_name = "srvsvc.NetShareCtr1007",
5744         .tp_getset = py_srvsvc_NetShareCtr1007_getsetters,
5745         .tp_methods = NULL,
5746         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5747         .tp_basicsize = sizeof(pytalloc_Object),
5748         .tp_new = py_srvsvc_NetShareCtr1007_new,
5749 };
5750
5751
5752 static PyObject *py_srvsvc_NetShareCtr1501_get_count(PyObject *obj, void *closure)
5753 {
5754         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
5755         PyObject *py_count;
5756         py_count = PyInt_FromLong(object->count);
5757         return py_count;
5758 }
5759
5760 static int py_srvsvc_NetShareCtr1501_set_count(PyObject *py_obj, PyObject *value, void *closure)
5761 {
5762         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(py_obj);
5763         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5764         object->count = PyInt_AsLong(value);
5765         return 0;
5766 }
5767
5768 static PyObject *py_srvsvc_NetShareCtr1501_get_array(PyObject *obj, void *closure)
5769 {
5770         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(obj);
5771         PyObject *py_array;
5772         if (object->array == NULL) {
5773                 py_array = Py_None;
5774                 Py_INCREF(py_array);
5775         } else {
5776                 py_array = PyList_New(object->count);
5777                 if (py_array == NULL) {
5778                         return NULL;
5779                 }
5780                 {
5781                         int array_cntr_1;
5782                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
5783                                 PyObject *py_array_1;
5784                                 py_array_1 = pytalloc_reference_ex(sec_desc_buf_Type, object->array, &object->array[array_cntr_1]);
5785                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
5786                         }
5787                 }
5788         }
5789         return py_array;
5790 }
5791
5792 static int py_srvsvc_NetShareCtr1501_set_array(PyObject *py_obj, PyObject *value, void *closure)
5793 {
5794         struct srvsvc_NetShareCtr1501 *object = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(py_obj);
5795         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
5796         if (value == Py_None) {
5797                 object->array = NULL;
5798         } else {
5799                 object->array = NULL;
5800                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5801                 {
5802                         int array_cntr_1;
5803                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
5804                         if (!object->array) { return -1;; }
5805                         talloc_set_name_const(object->array, "ARRAY: object->array");
5806                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
5807                                 PY_CHECK_TYPE(sec_desc_buf_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
5808                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
5809                                         PyErr_NoMemory();
5810                                         return -1;
5811                                 }
5812                                 object->array[array_cntr_1] = *(struct sec_desc_buf *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
5813                         }
5814                 }
5815         }
5816         return 0;
5817 }
5818
5819 static PyGetSetDef py_srvsvc_NetShareCtr1501_getsetters[] = {
5820         { discard_const_p(char, "count"), py_srvsvc_NetShareCtr1501_get_count, py_srvsvc_NetShareCtr1501_set_count },
5821         { discard_const_p(char, "array"), py_srvsvc_NetShareCtr1501_get_array, py_srvsvc_NetShareCtr1501_set_array },
5822         { NULL }
5823 };
5824
5825 static PyObject *py_srvsvc_NetShareCtr1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5826 {
5827         return pytalloc_new(struct srvsvc_NetShareCtr1501, type);
5828 }
5829
5830
5831 static PyTypeObject srvsvc_NetShareCtr1501_Type = {
5832         PyObject_HEAD_INIT(NULL) 0,
5833         .tp_name = "srvsvc.NetShareCtr1501",
5834         .tp_getset = py_srvsvc_NetShareCtr1501_getsetters,
5835         .tp_methods = NULL,
5836         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5837         .tp_basicsize = sizeof(pytalloc_Object),
5838         .tp_new = py_srvsvc_NetShareCtr1501_new,
5839 };
5840
5841 PyObject *py_import_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareInfo *in)
5842 {
5843         PyObject *ret;
5844
5845         switch (level) {
5846                 case 0:
5847                         if (in->info0 == NULL) {
5848                                 ret = Py_None;
5849                                 Py_INCREF(ret);
5850                         } else {
5851                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo0_Type, in->info0, in->info0);
5852                         }
5853                         return ret;
5854
5855                 case 1:
5856                         if (in->info1 == NULL) {
5857                                 ret = Py_None;
5858                                 Py_INCREF(ret);
5859                         } else {
5860                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1_Type, in->info1, in->info1);
5861                         }
5862                         return ret;
5863
5864                 case 2:
5865                         if (in->info2 == NULL) {
5866                                 ret = Py_None;
5867                                 Py_INCREF(ret);
5868                         } else {
5869                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo2_Type, in->info2, in->info2);
5870                         }
5871                         return ret;
5872
5873                 case 501:
5874                         if (in->info501 == NULL) {
5875                                 ret = Py_None;
5876                                 Py_INCREF(ret);
5877                         } else {
5878                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo501_Type, in->info501, in->info501);
5879                         }
5880                         return ret;
5881
5882                 case 502:
5883                         if (in->info502 == NULL) {
5884                                 ret = Py_None;
5885                                 Py_INCREF(ret);
5886                         } else {
5887                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo502_Type, in->info502, in->info502);
5888                         }
5889                         return ret;
5890
5891                 case 1004:
5892                         if (in->info1004 == NULL) {
5893                                 ret = Py_None;
5894                                 Py_INCREF(ret);
5895                         } else {
5896                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1004_Type, in->info1004, in->info1004);
5897                         }
5898                         return ret;
5899
5900                 case 1005:
5901                         if (in->info1005 == NULL) {
5902                                 ret = Py_None;
5903                                 Py_INCREF(ret);
5904                         } else {
5905                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1005_Type, in->info1005, in->info1005);
5906                         }
5907                         return ret;
5908
5909                 case 1006:
5910                         if (in->info1006 == NULL) {
5911                                 ret = Py_None;
5912                                 Py_INCREF(ret);
5913                         } else {
5914                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1006_Type, in->info1006, in->info1006);
5915                         }
5916                         return ret;
5917
5918                 case 1007:
5919                         if (in->info1007 == NULL) {
5920                                 ret = Py_None;
5921                                 Py_INCREF(ret);
5922                         } else {
5923                                 ret = pytalloc_reference_ex(&srvsvc_NetShareInfo1007_Type, in->info1007, in->info1007);
5924                         }
5925                         return ret;
5926
5927                 case 1501:
5928                         if (in->info1501 == NULL) {
5929                                 ret = Py_None;
5930                                 Py_INCREF(ret);
5931                         } else {
5932                                 ret = pytalloc_reference_ex(sec_desc_buf_Type, in->info1501, in->info1501);
5933                         }
5934                         return ret;
5935
5936                 default:
5937                         ret = Py_None;
5938                         Py_INCREF(ret);
5939                         return ret;
5940
5941         }
5942         PyErr_SetString(PyExc_TypeError, "unknown union level");
5943         return NULL;
5944 }
5945
5946 union srvsvc_NetShareInfo *py_export_srvsvc_NetShareInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5947 {
5948         union srvsvc_NetShareInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetShareInfo);
5949         switch (level) {
5950                 case 0:
5951                         if (in == Py_None) {
5952                                 ret->info0 = NULL;
5953                         } else {
5954                                 ret->info0 = NULL;
5955                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo0_Type, in, talloc_free(ret); return NULL;);
5956                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5957                                         PyErr_NoMemory();
5958                                         talloc_free(ret); return NULL;
5959                                 }
5960                                 ret->info0 = (struct srvsvc_NetShareInfo0 *)pytalloc_get_ptr(in);
5961                         }
5962                         break;
5963
5964                 case 1:
5965                         if (in == Py_None) {
5966                                 ret->info1 = NULL;
5967                         } else {
5968                                 ret->info1 = NULL;
5969                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1_Type, in, talloc_free(ret); return NULL;);
5970                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5971                                         PyErr_NoMemory();
5972                                         talloc_free(ret); return NULL;
5973                                 }
5974                                 ret->info1 = (struct srvsvc_NetShareInfo1 *)pytalloc_get_ptr(in);
5975                         }
5976                         break;
5977
5978                 case 2:
5979                         if (in == Py_None) {
5980                                 ret->info2 = NULL;
5981                         } else {
5982                                 ret->info2 = NULL;
5983                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo2_Type, in, talloc_free(ret); return NULL;);
5984                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5985                                         PyErr_NoMemory();
5986                                         talloc_free(ret); return NULL;
5987                                 }
5988                                 ret->info2 = (struct srvsvc_NetShareInfo2 *)pytalloc_get_ptr(in);
5989                         }
5990                         break;
5991
5992                 case 501:
5993                         if (in == Py_None) {
5994                                 ret->info501 = NULL;
5995                         } else {
5996                                 ret->info501 = NULL;
5997                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo501_Type, in, talloc_free(ret); return NULL;);
5998                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5999                                         PyErr_NoMemory();
6000                                         talloc_free(ret); return NULL;
6001                                 }
6002                                 ret->info501 = (struct srvsvc_NetShareInfo501 *)pytalloc_get_ptr(in);
6003                         }
6004                         break;
6005
6006                 case 502:
6007                         if (in == Py_None) {
6008                                 ret->info502 = NULL;
6009                         } else {
6010                                 ret->info502 = NULL;
6011                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo502_Type, in, talloc_free(ret); return NULL;);
6012                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6013                                         PyErr_NoMemory();
6014                                         talloc_free(ret); return NULL;
6015                                 }
6016                                 ret->info502 = (struct srvsvc_NetShareInfo502 *)pytalloc_get_ptr(in);
6017                         }
6018                         break;
6019
6020                 case 1004:
6021                         if (in == Py_None) {
6022                                 ret->info1004 = NULL;
6023                         } else {
6024                                 ret->info1004 = NULL;
6025                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1004_Type, in, talloc_free(ret); return NULL;);
6026                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6027                                         PyErr_NoMemory();
6028                                         talloc_free(ret); return NULL;
6029                                 }
6030                                 ret->info1004 = (struct srvsvc_NetShareInfo1004 *)pytalloc_get_ptr(in);
6031                         }
6032                         break;
6033
6034                 case 1005:
6035                         if (in == Py_None) {
6036                                 ret->info1005 = NULL;
6037                         } else {
6038                                 ret->info1005 = NULL;
6039                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1005_Type, in, talloc_free(ret); return NULL;);
6040                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6041                                         PyErr_NoMemory();
6042                                         talloc_free(ret); return NULL;
6043                                 }
6044                                 ret->info1005 = (struct srvsvc_NetShareInfo1005 *)pytalloc_get_ptr(in);
6045                         }
6046                         break;
6047
6048                 case 1006:
6049                         if (in == Py_None) {
6050                                 ret->info1006 = NULL;
6051                         } else {
6052                                 ret->info1006 = NULL;
6053                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1006_Type, in, talloc_free(ret); return NULL;);
6054                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6055                                         PyErr_NoMemory();
6056                                         talloc_free(ret); return NULL;
6057                                 }
6058                                 ret->info1006 = (struct srvsvc_NetShareInfo1006 *)pytalloc_get_ptr(in);
6059                         }
6060                         break;
6061
6062                 case 1007:
6063                         if (in == Py_None) {
6064                                 ret->info1007 = NULL;
6065                         } else {
6066                                 ret->info1007 = NULL;
6067                                 PY_CHECK_TYPE(&srvsvc_NetShareInfo1007_Type, in, talloc_free(ret); return NULL;);
6068                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6069                                         PyErr_NoMemory();
6070                                         talloc_free(ret); return NULL;
6071                                 }
6072                                 ret->info1007 = (struct srvsvc_NetShareInfo1007 *)pytalloc_get_ptr(in);
6073                         }
6074                         break;
6075
6076                 case 1501:
6077                         if (in == Py_None) {
6078                                 ret->info1501 = NULL;
6079                         } else {
6080                                 ret->info1501 = NULL;
6081                                 PY_CHECK_TYPE(sec_desc_buf_Type, in, talloc_free(ret); return NULL;);
6082                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6083                                         PyErr_NoMemory();
6084                                         talloc_free(ret); return NULL;
6085                                 }
6086                                 ret->info1501 = (struct sec_desc_buf *)pytalloc_get_ptr(in);
6087                         }
6088                         break;
6089
6090                 default:
6091                         break;
6092
6093         }
6094
6095         return ret;
6096 }
6097
6098 PyObject *py_import_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetShareCtr *in)
6099 {
6100         PyObject *ret;
6101
6102         switch (level) {
6103                 case 0:
6104                         if (in->ctr0 == NULL) {
6105                                 ret = Py_None;
6106                                 Py_INCREF(ret);
6107                         } else {
6108                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr0_Type, in->ctr0, in->ctr0);
6109                         }
6110                         return ret;
6111
6112                 case 1:
6113                         if (in->ctr1 == NULL) {
6114                                 ret = Py_None;
6115                                 Py_INCREF(ret);
6116                         } else {
6117                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1_Type, in->ctr1, in->ctr1);
6118                         }
6119                         return ret;
6120
6121                 case 2:
6122                         if (in->ctr2 == NULL) {
6123                                 ret = Py_None;
6124                                 Py_INCREF(ret);
6125                         } else {
6126                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr2_Type, in->ctr2, in->ctr2);
6127                         }
6128                         return ret;
6129
6130                 case 501:
6131                         if (in->ctr501 == NULL) {
6132                                 ret = Py_None;
6133                                 Py_INCREF(ret);
6134                         } else {
6135                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr501_Type, in->ctr501, in->ctr501);
6136                         }
6137                         return ret;
6138
6139                 case 502:
6140                         if (in->ctr502 == NULL) {
6141                                 ret = Py_None;
6142                                 Py_INCREF(ret);
6143                         } else {
6144                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr502_Type, in->ctr502, in->ctr502);
6145                         }
6146                         return ret;
6147
6148                 case 1004:
6149                         if (in->ctr1004 == NULL) {
6150                                 ret = Py_None;
6151                                 Py_INCREF(ret);
6152                         } else {
6153                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1004_Type, in->ctr1004, in->ctr1004);
6154                         }
6155                         return ret;
6156
6157                 case 1005:
6158                         if (in->ctr1005 == NULL) {
6159                                 ret = Py_None;
6160                                 Py_INCREF(ret);
6161                         } else {
6162                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1005_Type, in->ctr1005, in->ctr1005);
6163                         }
6164                         return ret;
6165
6166                 case 1006:
6167                         if (in->ctr1006 == NULL) {
6168                                 ret = Py_None;
6169                                 Py_INCREF(ret);
6170                         } else {
6171                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1006_Type, in->ctr1006, in->ctr1006);
6172                         }
6173                         return ret;
6174
6175                 case 1007:
6176                         if (in->ctr1007 == NULL) {
6177                                 ret = Py_None;
6178                                 Py_INCREF(ret);
6179                         } else {
6180                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1007_Type, in->ctr1007, in->ctr1007);
6181                         }
6182                         return ret;
6183
6184                 case 1501:
6185                         if (in->ctr1501 == NULL) {
6186                                 ret = Py_None;
6187                                 Py_INCREF(ret);
6188                         } else {
6189                                 ret = pytalloc_reference_ex(&srvsvc_NetShareCtr1501_Type, in->ctr1501, in->ctr1501);
6190                         }
6191                         return ret;
6192
6193                 default:
6194                         ret = Py_None;
6195                         Py_INCREF(ret);
6196                         return ret;
6197
6198         }
6199         PyErr_SetString(PyExc_TypeError, "unknown union level");
6200         return NULL;
6201 }
6202
6203 union srvsvc_NetShareCtr *py_export_srvsvc_NetShareCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
6204 {
6205         union srvsvc_NetShareCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetShareCtr);
6206         switch (level) {
6207                 case 0:
6208                         if (in == Py_None) {
6209                                 ret->ctr0 = NULL;
6210                         } else {
6211                                 ret->ctr0 = NULL;
6212                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr0_Type, in, talloc_free(ret); return NULL;);
6213                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6214                                         PyErr_NoMemory();
6215                                         talloc_free(ret); return NULL;
6216                                 }
6217                                 ret->ctr0 = (struct srvsvc_NetShareCtr0 *)pytalloc_get_ptr(in);
6218                         }
6219                         break;
6220
6221                 case 1:
6222                         if (in == Py_None) {
6223                                 ret->ctr1 = NULL;
6224                         } else {
6225                                 ret->ctr1 = NULL;
6226                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1_Type, in, talloc_free(ret); return NULL;);
6227                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6228                                         PyErr_NoMemory();
6229                                         talloc_free(ret); return NULL;
6230                                 }
6231                                 ret->ctr1 = (struct srvsvc_NetShareCtr1 *)pytalloc_get_ptr(in);
6232                         }
6233                         break;
6234
6235                 case 2:
6236                         if (in == Py_None) {
6237                                 ret->ctr2 = NULL;
6238                         } else {
6239                                 ret->ctr2 = NULL;
6240                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr2_Type, in, talloc_free(ret); return NULL;);
6241                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6242                                         PyErr_NoMemory();
6243                                         talloc_free(ret); return NULL;
6244                                 }
6245                                 ret->ctr2 = (struct srvsvc_NetShareCtr2 *)pytalloc_get_ptr(in);
6246                         }
6247                         break;
6248
6249                 case 501:
6250                         if (in == Py_None) {
6251                                 ret->ctr501 = NULL;
6252                         } else {
6253                                 ret->ctr501 = NULL;
6254                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr501_Type, in, talloc_free(ret); return NULL;);
6255                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6256                                         PyErr_NoMemory();
6257                                         talloc_free(ret); return NULL;
6258                                 }
6259                                 ret->ctr501 = (struct srvsvc_NetShareCtr501 *)pytalloc_get_ptr(in);
6260                         }
6261                         break;
6262
6263                 case 502:
6264                         if (in == Py_None) {
6265                                 ret->ctr502 = NULL;
6266                         } else {
6267                                 ret->ctr502 = NULL;
6268                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr502_Type, in, talloc_free(ret); return NULL;);
6269                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6270                                         PyErr_NoMemory();
6271                                         talloc_free(ret); return NULL;
6272                                 }
6273                                 ret->ctr502 = (struct srvsvc_NetShareCtr502 *)pytalloc_get_ptr(in);
6274                         }
6275                         break;
6276
6277                 case 1004:
6278                         if (in == Py_None) {
6279                                 ret->ctr1004 = NULL;
6280                         } else {
6281                                 ret->ctr1004 = NULL;
6282                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1004_Type, in, talloc_free(ret); return NULL;);
6283                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6284                                         PyErr_NoMemory();
6285                                         talloc_free(ret); return NULL;
6286                                 }
6287                                 ret->ctr1004 = (struct srvsvc_NetShareCtr1004 *)pytalloc_get_ptr(in);
6288                         }
6289                         break;
6290
6291                 case 1005:
6292                         if (in == Py_None) {
6293                                 ret->ctr1005 = NULL;
6294                         } else {
6295                                 ret->ctr1005 = NULL;
6296                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1005_Type, in, talloc_free(ret); return NULL;);
6297                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6298                                         PyErr_NoMemory();
6299                                         talloc_free(ret); return NULL;
6300                                 }
6301                                 ret->ctr1005 = (struct srvsvc_NetShareCtr1005 *)pytalloc_get_ptr(in);
6302                         }
6303                         break;
6304
6305                 case 1006:
6306                         if (in == Py_None) {
6307                                 ret->ctr1006 = NULL;
6308                         } else {
6309                                 ret->ctr1006 = NULL;
6310                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1006_Type, in, talloc_free(ret); return NULL;);
6311                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6312                                         PyErr_NoMemory();
6313                                         talloc_free(ret); return NULL;
6314                                 }
6315                                 ret->ctr1006 = (struct srvsvc_NetShareCtr1006 *)pytalloc_get_ptr(in);
6316                         }
6317                         break;
6318
6319                 case 1007:
6320                         if (in == Py_None) {
6321                                 ret->ctr1007 = NULL;
6322                         } else {
6323                                 ret->ctr1007 = NULL;
6324                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1007_Type, in, talloc_free(ret); return NULL;);
6325                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6326                                         PyErr_NoMemory();
6327                                         talloc_free(ret); return NULL;
6328                                 }
6329                                 ret->ctr1007 = (struct srvsvc_NetShareCtr1007 *)pytalloc_get_ptr(in);
6330                         }
6331                         break;
6332
6333                 case 1501:
6334                         if (in == Py_None) {
6335                                 ret->ctr1501 = NULL;
6336                         } else {
6337                                 ret->ctr1501 = NULL;
6338                                 PY_CHECK_TYPE(&srvsvc_NetShareCtr1501_Type, in, talloc_free(ret); return NULL;);
6339                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6340                                         PyErr_NoMemory();
6341                                         talloc_free(ret); return NULL;
6342                                 }
6343                                 ret->ctr1501 = (struct srvsvc_NetShareCtr1501 *)pytalloc_get_ptr(in);
6344                         }
6345                         break;
6346
6347                 default:
6348                         break;
6349
6350         }
6351
6352         return ret;
6353 }
6354
6355
6356 static PyObject *py_srvsvc_NetShareInfoCtr_get_level(PyObject *obj, void *closure)
6357 {
6358         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
6359         PyObject *py_level;
6360         py_level = PyInt_FromLong(object->level);
6361         return py_level;
6362 }
6363
6364 static int py_srvsvc_NetShareInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
6365 {
6366         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_obj);
6367         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6368         object->level = PyInt_AsLong(value);
6369         return 0;
6370 }
6371
6372 static PyObject *py_srvsvc_NetShareInfoCtr_get_ctr(PyObject *obj, void *closure)
6373 {
6374         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(obj);
6375         PyObject *py_ctr;
6376         py_ctr = py_import_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
6377         if (py_ctr == NULL) {
6378                 return NULL;
6379         }
6380         return py_ctr;
6381 }
6382
6383 static int py_srvsvc_NetShareInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
6384 {
6385         struct srvsvc_NetShareInfoCtr *object = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_obj);
6386         {
6387                 union srvsvc_NetShareCtr *ctr_switch_0;
6388                 ctr_switch_0 = py_export_srvsvc_NetShareCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
6389                 if (ctr_switch_0 == NULL) {
6390                         return -1;
6391                 }
6392                 object->ctr = *ctr_switch_0;
6393         }
6394         return 0;
6395 }
6396
6397 static PyGetSetDef py_srvsvc_NetShareInfoCtr_getsetters[] = {
6398         { discard_const_p(char, "level"), py_srvsvc_NetShareInfoCtr_get_level, py_srvsvc_NetShareInfoCtr_set_level },
6399         { discard_const_p(char, "ctr"), py_srvsvc_NetShareInfoCtr_get_ctr, py_srvsvc_NetShareInfoCtr_set_ctr },
6400         { NULL }
6401 };
6402
6403 static PyObject *py_srvsvc_NetShareInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6404 {
6405         return pytalloc_new(struct srvsvc_NetShareInfoCtr, type);
6406 }
6407
6408
6409 static PyTypeObject srvsvc_NetShareInfoCtr_Type = {
6410         PyObject_HEAD_INIT(NULL) 0,
6411         .tp_name = "srvsvc.NetShareInfoCtr",
6412         .tp_getset = py_srvsvc_NetShareInfoCtr_getsetters,
6413         .tp_methods = NULL,
6414         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6415         .tp_basicsize = sizeof(pytalloc_Object),
6416         .tp_new = py_srvsvc_NetShareInfoCtr_new,
6417 };
6418
6419
6420 static PyObject *py_srvsvc_NetSrvInfo100_get_platform_id(PyObject *obj, void *closure)
6421 {
6422         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
6423         PyObject *py_platform_id;
6424         py_platform_id = PyInt_FromLong(object->platform_id);
6425         return py_platform_id;
6426 }
6427
6428 static int py_srvsvc_NetSrvInfo100_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6429 {
6430         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6431         if (PyLong_Check(value)) {
6432                 object->platform_id = PyLong_AsLongLong(value);
6433         } else if (PyInt_Check(value)) {
6434                 object->platform_id = PyInt_AsLong(value);
6435         } else {
6436                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6437                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6438                 return -1;
6439         }
6440         return 0;
6441 }
6442
6443 static PyObject *py_srvsvc_NetSrvInfo100_get_server_name(PyObject *obj, void *closure)
6444 {
6445         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(obj);
6446         PyObject *py_server_name;
6447         if (object->server_name == NULL) {
6448                 py_server_name = Py_None;
6449                 Py_INCREF(py_server_name);
6450         } else {
6451                 if (object->server_name == NULL) {
6452                         py_server_name = Py_None;
6453                         Py_INCREF(py_server_name);
6454                 } else {
6455                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6456                 }
6457         }
6458         return py_server_name;
6459 }
6460
6461 static int py_srvsvc_NetSrvInfo100_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6462 {
6463         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6464         if (value == Py_None) {
6465                 object->server_name = NULL;
6466         } else {
6467                 object->server_name = NULL;
6468                 if (PyUnicode_Check(value)) {
6469                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6470                 } else if (PyString_Check(value)) {
6471                         object->server_name = PyString_AS_STRING(value);
6472                 } else {
6473                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6474                         return -1;
6475                 }
6476         }
6477         return 0;
6478 }
6479
6480 static PyGetSetDef py_srvsvc_NetSrvInfo100_getsetters[] = {
6481         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo100_get_platform_id, py_srvsvc_NetSrvInfo100_set_platform_id },
6482         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo100_get_server_name, py_srvsvc_NetSrvInfo100_set_server_name },
6483         { NULL }
6484 };
6485
6486 static PyObject *py_srvsvc_NetSrvInfo100_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6487 {
6488         return pytalloc_new(struct srvsvc_NetSrvInfo100, type);
6489 }
6490
6491 static PyObject *py_srvsvc_NetSrvInfo100_ndr_pack(PyObject *py_obj)
6492 {
6493         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6494         DATA_BLOB blob;
6495         enum ndr_err_code err;
6496         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo100);
6497         if (err != NDR_ERR_SUCCESS) {
6498                 PyErr_SetNdrError(err);
6499                 return NULL;
6500         }
6501
6502         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6503 }
6504
6505 static PyObject *py_srvsvc_NetSrvInfo100_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
6506 {
6507         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6508         DATA_BLOB blob;
6509         int blob_length = 0;
6510         enum ndr_err_code err;
6511         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
6512         PyObject *allow_remaining_obj = NULL;
6513         bool allow_remaining = false;
6514
6515         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
6516                 discard_const_p(char *, kwnames),
6517                 &blob.data, &blob_length,
6518                 &allow_remaining_obj)) {
6519                 return NULL;
6520         }
6521         blob.length = blob_length;
6522
6523         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
6524                 allow_remaining = true;
6525         }
6526
6527         if (allow_remaining) {
6528                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
6529         } else {
6530                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo100);
6531         }
6532         if (err != NDR_ERR_SUCCESS) {
6533                 PyErr_SetNdrError(err);
6534                 return NULL;
6535         }
6536
6537         Py_RETURN_NONE;
6538 }
6539
6540 static PyObject *py_srvsvc_NetSrvInfo100_ndr_print(PyObject *py_obj)
6541 {
6542         struct srvsvc_NetSrvInfo100 *object = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(py_obj);
6543         PyObject *ret;
6544         char *retstr;
6545
6546         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo100, "srvsvc_NetSrvInfo100", object);
6547         ret = PyString_FromString(retstr);
6548         talloc_free(retstr);
6549
6550         return ret;
6551 }
6552
6553 static PyMethodDef py_srvsvc_NetSrvInfo100_methods[] = {
6554         { "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6555         { "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
6556         { "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo100_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6557         { NULL, NULL, 0, NULL }
6558 };
6559
6560
6561 static PyTypeObject srvsvc_NetSrvInfo100_Type = {
6562         PyObject_HEAD_INIT(NULL) 0,
6563         .tp_name = "srvsvc.NetSrvInfo100",
6564         .tp_getset = py_srvsvc_NetSrvInfo100_getsetters,
6565         .tp_methods = py_srvsvc_NetSrvInfo100_methods,
6566         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6567         .tp_basicsize = sizeof(pytalloc_Object),
6568         .tp_new = py_srvsvc_NetSrvInfo100_new,
6569 };
6570
6571
6572 static PyObject *py_srvsvc_NetSrvInfo101_get_platform_id(PyObject *obj, void *closure)
6573 {
6574         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6575         PyObject *py_platform_id;
6576         py_platform_id = PyInt_FromLong(object->platform_id);
6577         return py_platform_id;
6578 }
6579
6580 static int py_srvsvc_NetSrvInfo101_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6581 {
6582         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6583         if (PyLong_Check(value)) {
6584                 object->platform_id = PyLong_AsLongLong(value);
6585         } else if (PyInt_Check(value)) {
6586                 object->platform_id = PyInt_AsLong(value);
6587         } else {
6588                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6589                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6590                 return -1;
6591         }
6592         return 0;
6593 }
6594
6595 static PyObject *py_srvsvc_NetSrvInfo101_get_server_name(PyObject *obj, void *closure)
6596 {
6597         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6598         PyObject *py_server_name;
6599         if (object->server_name == NULL) {
6600                 py_server_name = Py_None;
6601                 Py_INCREF(py_server_name);
6602         } else {
6603                 if (object->server_name == NULL) {
6604                         py_server_name = Py_None;
6605                         Py_INCREF(py_server_name);
6606                 } else {
6607                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6608                 }
6609         }
6610         return py_server_name;
6611 }
6612
6613 static int py_srvsvc_NetSrvInfo101_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6614 {
6615         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6616         if (value == Py_None) {
6617                 object->server_name = NULL;
6618         } else {
6619                 object->server_name = NULL;
6620                 if (PyUnicode_Check(value)) {
6621                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6622                 } else if (PyString_Check(value)) {
6623                         object->server_name = PyString_AS_STRING(value);
6624                 } else {
6625                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6626                         return -1;
6627                 }
6628         }
6629         return 0;
6630 }
6631
6632 static PyObject *py_srvsvc_NetSrvInfo101_get_version_major(PyObject *obj, void *closure)
6633 {
6634         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6635         PyObject *py_version_major;
6636         py_version_major = PyInt_FromLong(object->version_major);
6637         return py_version_major;
6638 }
6639
6640 static int py_srvsvc_NetSrvInfo101_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
6641 {
6642         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6643         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6644         object->version_major = PyInt_AsLong(value);
6645         return 0;
6646 }
6647
6648 static PyObject *py_srvsvc_NetSrvInfo101_get_version_minor(PyObject *obj, void *closure)
6649 {
6650         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6651         PyObject *py_version_minor;
6652         py_version_minor = PyInt_FromLong(object->version_minor);
6653         return py_version_minor;
6654 }
6655
6656 static int py_srvsvc_NetSrvInfo101_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
6657 {
6658         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6659         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6660         object->version_minor = PyInt_AsLong(value);
6661         return 0;
6662 }
6663
6664 static PyObject *py_srvsvc_NetSrvInfo101_get_server_type(PyObject *obj, void *closure)
6665 {
6666         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6667         PyObject *py_server_type;
6668         py_server_type = PyInt_FromLong(object->server_type);
6669         return py_server_type;
6670 }
6671
6672 static int py_srvsvc_NetSrvInfo101_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
6673 {
6674         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6675         if (PyLong_Check(value)) {
6676                 object->server_type = PyLong_AsLongLong(value);
6677         } else if (PyInt_Check(value)) {
6678                 object->server_type = PyInt_AsLong(value);
6679         } else {
6680                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6681                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6682                 return -1;
6683         }
6684         return 0;
6685 }
6686
6687 static PyObject *py_srvsvc_NetSrvInfo101_get_comment(PyObject *obj, void *closure)
6688 {
6689         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(obj);
6690         PyObject *py_comment;
6691         if (object->comment == NULL) {
6692                 py_comment = Py_None;
6693                 Py_INCREF(py_comment);
6694         } else {
6695                 if (object->comment == NULL) {
6696                         py_comment = Py_None;
6697                         Py_INCREF(py_comment);
6698                 } else {
6699                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
6700                 }
6701         }
6702         return py_comment;
6703 }
6704
6705 static int py_srvsvc_NetSrvInfo101_set_comment(PyObject *py_obj, PyObject *value, void *closure)
6706 {
6707         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6708         if (value == Py_None) {
6709                 object->comment = NULL;
6710         } else {
6711                 object->comment = NULL;
6712                 if (PyUnicode_Check(value)) {
6713                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6714                 } else if (PyString_Check(value)) {
6715                         object->comment = PyString_AS_STRING(value);
6716                 } else {
6717                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6718                         return -1;
6719                 }
6720         }
6721         return 0;
6722 }
6723
6724 static PyGetSetDef py_srvsvc_NetSrvInfo101_getsetters[] = {
6725         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo101_get_platform_id, py_srvsvc_NetSrvInfo101_set_platform_id },
6726         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo101_get_server_name, py_srvsvc_NetSrvInfo101_set_server_name },
6727         { discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo101_get_version_major, py_srvsvc_NetSrvInfo101_set_version_major },
6728         { discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo101_get_version_minor, py_srvsvc_NetSrvInfo101_set_version_minor },
6729         { discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo101_get_server_type, py_srvsvc_NetSrvInfo101_set_server_type },
6730         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo101_get_comment, py_srvsvc_NetSrvInfo101_set_comment },
6731         { NULL }
6732 };
6733
6734 static PyObject *py_srvsvc_NetSrvInfo101_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6735 {
6736         return pytalloc_new(struct srvsvc_NetSrvInfo101, type);
6737 }
6738
6739 static PyObject *py_srvsvc_NetSrvInfo101_ndr_pack(PyObject *py_obj)
6740 {
6741         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6742         DATA_BLOB blob;
6743         enum ndr_err_code err;
6744         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvInfo101);
6745         if (err != NDR_ERR_SUCCESS) {
6746                 PyErr_SetNdrError(err);
6747                 return NULL;
6748         }
6749
6750         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6751 }
6752
6753 static PyObject *py_srvsvc_NetSrvInfo101_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
6754 {
6755         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6756         DATA_BLOB blob;
6757         int blob_length = 0;
6758         enum ndr_err_code err;
6759         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
6760         PyObject *allow_remaining_obj = NULL;
6761         bool allow_remaining = false;
6762
6763         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
6764                 discard_const_p(char *, kwnames),
6765                 &blob.data, &blob_length,
6766                 &allow_remaining_obj)) {
6767                 return NULL;
6768         }
6769         blob.length = blob_length;
6770
6771         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
6772                 allow_remaining = true;
6773         }
6774
6775         if (allow_remaining) {
6776                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
6777         } else {
6778                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvInfo101);
6779         }
6780         if (err != NDR_ERR_SUCCESS) {
6781                 PyErr_SetNdrError(err);
6782                 return NULL;
6783         }
6784
6785         Py_RETURN_NONE;
6786 }
6787
6788 static PyObject *py_srvsvc_NetSrvInfo101_ndr_print(PyObject *py_obj)
6789 {
6790         struct srvsvc_NetSrvInfo101 *object = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(py_obj);
6791         PyObject *ret;
6792         char *retstr;
6793
6794         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_srvsvc_NetSrvInfo101, "srvsvc_NetSrvInfo101", object);
6795         ret = PyString_FromString(retstr);
6796         talloc_free(retstr);
6797
6798         return ret;
6799 }
6800
6801 static PyMethodDef py_srvsvc_NetSrvInfo101_methods[] = {
6802         { "__ndr_pack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6803         { "__ndr_unpack__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
6804         { "__ndr_print__", (PyCFunction)py_srvsvc_NetSrvInfo101_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6805         { NULL, NULL, 0, NULL }
6806 };
6807
6808
6809 static PyTypeObject srvsvc_NetSrvInfo101_Type = {
6810         PyObject_HEAD_INIT(NULL) 0,
6811         .tp_name = "srvsvc.NetSrvInfo101",
6812         .tp_getset = py_srvsvc_NetSrvInfo101_getsetters,
6813         .tp_methods = py_srvsvc_NetSrvInfo101_methods,
6814         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6815         .tp_basicsize = sizeof(pytalloc_Object),
6816         .tp_new = py_srvsvc_NetSrvInfo101_new,
6817 };
6818
6819
6820 static PyObject *py_srvsvc_NetSrvInfo102_get_platform_id(PyObject *obj, void *closure)
6821 {
6822         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6823         PyObject *py_platform_id;
6824         py_platform_id = PyInt_FromLong(object->platform_id);
6825         return py_platform_id;
6826 }
6827
6828 static int py_srvsvc_NetSrvInfo102_set_platform_id(PyObject *py_obj, PyObject *value, void *closure)
6829 {
6830         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6831         if (PyLong_Check(value)) {
6832                 object->platform_id = PyLong_AsLongLong(value);
6833         } else if (PyInt_Check(value)) {
6834                 object->platform_id = PyInt_AsLong(value);
6835         } else {
6836                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6837                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6838                 return -1;
6839         }
6840         return 0;
6841 }
6842
6843 static PyObject *py_srvsvc_NetSrvInfo102_get_server_name(PyObject *obj, void *closure)
6844 {
6845         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6846         PyObject *py_server_name;
6847         if (object->server_name == NULL) {
6848                 py_server_name = Py_None;
6849                 Py_INCREF(py_server_name);
6850         } else {
6851                 if (object->server_name == NULL) {
6852                         py_server_name = Py_None;
6853                         Py_INCREF(py_server_name);
6854                 } else {
6855                         py_server_name = PyUnicode_Decode(object->server_name, strlen(object->server_name), "utf-8", "ignore");
6856                 }
6857         }
6858         return py_server_name;
6859 }
6860
6861 static int py_srvsvc_NetSrvInfo102_set_server_name(PyObject *py_obj, PyObject *value, void *closure)
6862 {
6863         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6864         if (value == Py_None) {
6865                 object->server_name = NULL;
6866         } else {
6867                 object->server_name = NULL;
6868                 if (PyUnicode_Check(value)) {
6869                         object->server_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6870                 } else if (PyString_Check(value)) {
6871                         object->server_name = PyString_AS_STRING(value);
6872                 } else {
6873                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6874                         return -1;
6875                 }
6876         }
6877         return 0;
6878 }
6879
6880 static PyObject *py_srvsvc_NetSrvInfo102_get_version_major(PyObject *obj, void *closure)
6881 {
6882         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6883         PyObject *py_version_major;
6884         py_version_major = PyInt_FromLong(object->version_major);
6885         return py_version_major;
6886 }
6887
6888 static int py_srvsvc_NetSrvInfo102_set_version_major(PyObject *py_obj, PyObject *value, void *closure)
6889 {
6890         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6891         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6892         object->version_major = PyInt_AsLong(value);
6893         return 0;
6894 }
6895
6896 static PyObject *py_srvsvc_NetSrvInfo102_get_version_minor(PyObject *obj, void *closure)
6897 {
6898         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6899         PyObject *py_version_minor;
6900         py_version_minor = PyInt_FromLong(object->version_minor);
6901         return py_version_minor;
6902 }
6903
6904 static int py_srvsvc_NetSrvInfo102_set_version_minor(PyObject *py_obj, PyObject *value, void *closure)
6905 {
6906         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6907         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6908         object->version_minor = PyInt_AsLong(value);
6909         return 0;
6910 }
6911
6912 static PyObject *py_srvsvc_NetSrvInfo102_get_server_type(PyObject *obj, void *closure)
6913 {
6914         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6915         PyObject *py_server_type;
6916         py_server_type = PyInt_FromLong(object->server_type);
6917         return py_server_type;
6918 }
6919
6920 static int py_srvsvc_NetSrvInfo102_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
6921 {
6922         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6923         if (PyLong_Check(value)) {
6924                 object->server_type = PyLong_AsLongLong(value);
6925         } else if (PyInt_Check(value)) {
6926                 object->server_type = PyInt_AsLong(value);
6927         } else {
6928                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6929                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6930                 return -1;
6931         }
6932         return 0;
6933 }
6934
6935 static PyObject *py_srvsvc_NetSrvInfo102_get_comment(PyObject *obj, void *closure)
6936 {
6937         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6938         PyObject *py_comment;
6939         if (object->comment == NULL) {
6940                 py_comment = Py_None;
6941                 Py_INCREF(py_comment);
6942         } else {
6943                 if (object->comment == NULL) {
6944                         py_comment = Py_None;
6945                         Py_INCREF(py_comment);
6946                 } else {
6947                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
6948                 }
6949         }
6950         return py_comment;
6951 }
6952
6953 static int py_srvsvc_NetSrvInfo102_set_comment(PyObject *py_obj, PyObject *value, void *closure)
6954 {
6955         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6956         if (value == Py_None) {
6957                 object->comment = NULL;
6958         } else {
6959                 object->comment = NULL;
6960                 if (PyUnicode_Check(value)) {
6961                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6962                 } else if (PyString_Check(value)) {
6963                         object->comment = PyString_AS_STRING(value);
6964                 } else {
6965                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6966                         return -1;
6967                 }
6968         }
6969         return 0;
6970 }
6971
6972 static PyObject *py_srvsvc_NetSrvInfo102_get_users(PyObject *obj, void *closure)
6973 {
6974         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6975         PyObject *py_users;
6976         py_users = PyInt_FromLong(object->users);
6977         return py_users;
6978 }
6979
6980 static int py_srvsvc_NetSrvInfo102_set_users(PyObject *py_obj, PyObject *value, void *closure)
6981 {
6982         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6983         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6984         object->users = PyInt_AsLong(value);
6985         return 0;
6986 }
6987
6988 static PyObject *py_srvsvc_NetSrvInfo102_get_disc(PyObject *obj, void *closure)
6989 {
6990         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
6991         PyObject *py_disc;
6992         py_disc = PyInt_FromLong(object->disc);
6993         return py_disc;
6994 }
6995
6996 static int py_srvsvc_NetSrvInfo102_set_disc(PyObject *py_obj, PyObject *value, void *closure)
6997 {
6998         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
6999         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7000         object->disc = PyInt_AsLong(value);
7001         return 0;
7002 }
7003
7004 static PyObject *py_srvsvc_NetSrvInfo102_get_hidden(PyObject *obj, void *closure)
7005 {
7006         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7007         PyObject *py_hidden;
7008         py_hidden = PyInt_FromLong(object->hidden);
7009         return py_hidden;
7010 }
7011
7012 static int py_srvsvc_NetSrvInfo102_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
7013 {
7014         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7015         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7016         object->hidden = PyInt_AsLong(value);
7017         return 0;
7018 }
7019
7020 static PyObject *py_srvsvc_NetSrvInfo102_get_announce(PyObject *obj, void *closure)
7021 {
7022         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7023         PyObject *py_announce;
7024         py_announce = PyInt_FromLong(object->announce);
7025         return py_announce;
7026 }
7027
7028 static int py_srvsvc_NetSrvInfo102_set_announce(PyObject *py_obj, PyObject *value, void *closure)
7029 {
7030         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7031         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7032         object->announce = PyInt_AsLong(value);
7033         return 0;
7034 }
7035
7036 static PyObject *py_srvsvc_NetSrvInfo102_get_anndelta(PyObject *obj, void *closure)
7037 {
7038         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7039         PyObject *py_anndelta;
7040         py_anndelta = PyInt_FromLong(object->anndelta);
7041         return py_anndelta;
7042 }
7043
7044 static int py_srvsvc_NetSrvInfo102_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
7045 {
7046         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7047         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7048         object->anndelta = PyInt_AsLong(value);
7049         return 0;
7050 }
7051
7052 static PyObject *py_srvsvc_NetSrvInfo102_get_licenses(PyObject *obj, void *closure)
7053 {
7054         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7055         PyObject *py_licenses;
7056         py_licenses = PyInt_FromLong(object->licenses);
7057         return py_licenses;
7058 }
7059
7060 static int py_srvsvc_NetSrvInfo102_set_licenses(PyObject *py_obj, PyObject *value, void *closure)
7061 {
7062         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7063         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7064         object->licenses = PyInt_AsLong(value);
7065         return 0;
7066 }
7067
7068 static PyObject *py_srvsvc_NetSrvInfo102_get_userpath(PyObject *obj, void *closure)
7069 {
7070         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(obj);
7071         PyObject *py_userpath;
7072         if (object->userpath == NULL) {
7073                 py_userpath = Py_None;
7074                 Py_INCREF(py_userpath);
7075         } else {
7076                 if (object->userpath == NULL) {
7077                         py_userpath = Py_None;
7078                         Py_INCREF(py_userpath);
7079                 } else {
7080                         py_userpath = PyUnicode_Decode(object->userpath, strlen(object->userpath), "utf-8", "ignore");
7081                 }
7082         }
7083         return py_userpath;
7084 }
7085
7086 static int py_srvsvc_NetSrvInfo102_set_userpath(PyObject *py_obj, PyObject *value, void *closure)
7087 {
7088         struct srvsvc_NetSrvInfo102 *object = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(py_obj);
7089         if (value == Py_None) {
7090                 object->userpath = NULL;
7091         } else {
7092                 object->userpath = NULL;
7093                 if (PyUnicode_Check(value)) {
7094                         object->userpath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7095                 } else if (PyString_Check(value)) {
7096                         object->userpath = PyString_AS_STRING(value);
7097                 } else {
7098                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7099                         return -1;
7100                 }
7101         }
7102         return 0;
7103 }
7104
7105 static PyGetSetDef py_srvsvc_NetSrvInfo102_getsetters[] = {
7106         { discard_const_p(char, "platform_id"), py_srvsvc_NetSrvInfo102_get_platform_id, py_srvsvc_NetSrvInfo102_set_platform_id },
7107         { discard_const_p(char, "server_name"), py_srvsvc_NetSrvInfo102_get_server_name, py_srvsvc_NetSrvInfo102_set_server_name },
7108         { discard_const_p(char, "version_major"), py_srvsvc_NetSrvInfo102_get_version_major, py_srvsvc_NetSrvInfo102_set_version_major },
7109         { discard_const_p(char, "version_minor"), py_srvsvc_NetSrvInfo102_get_version_minor, py_srvsvc_NetSrvInfo102_set_version_minor },
7110         { discard_const_p(char, "server_type"), py_srvsvc_NetSrvInfo102_get_server_type, py_srvsvc_NetSrvInfo102_set_server_type },
7111         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo102_get_comment, py_srvsvc_NetSrvInfo102_set_comment },
7112         { discard_const_p(char, "users"), py_srvsvc_NetSrvInfo102_get_users, py_srvsvc_NetSrvInfo102_set_users },
7113         { discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo102_get_disc, py_srvsvc_NetSrvInfo102_set_disc },
7114         { discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo102_get_hidden, py_srvsvc_NetSrvInfo102_set_hidden },
7115         { discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo102_get_announce, py_srvsvc_NetSrvInfo102_set_announce },
7116         { discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo102_get_anndelta, py_srvsvc_NetSrvInfo102_set_anndelta },
7117         { discard_const_p(char, "licenses"), py_srvsvc_NetSrvInfo102_get_licenses, py_srvsvc_NetSrvInfo102_set_licenses },
7118         { discard_const_p(char, "userpath"), py_srvsvc_NetSrvInfo102_get_userpath, py_srvsvc_NetSrvInfo102_set_userpath },
7119         { NULL }
7120 };
7121
7122 static PyObject *py_srvsvc_NetSrvInfo102_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
7123 {
7124         return pytalloc_new(struct srvsvc_NetSrvInfo102, type);
7125 }
7126
7127
7128 static PyTypeObject srvsvc_NetSrvInfo102_Type = {
7129         PyObject_HEAD_INIT(NULL) 0,
7130         .tp_name = "srvsvc.NetSrvInfo102",
7131         .tp_getset = py_srvsvc_NetSrvInfo102_getsetters,
7132         .tp_methods = NULL,
7133         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7134         .tp_basicsize = sizeof(pytalloc_Object),
7135         .tp_new = py_srvsvc_NetSrvInfo102_new,
7136 };
7137
7138
7139 static PyObject *py_srvsvc_NetSrvInfo402_get_ulist_mtime(PyObject *obj, void *closure)
7140 {
7141         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7142         PyObject *py_ulist_mtime;
7143         py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
7144         return py_ulist_mtime;
7145 }
7146
7147 static int py_srvsvc_NetSrvInfo402_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7148 {
7149         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7150         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7151         object->ulist_mtime = PyInt_AsLong(value);
7152         return 0;
7153 }
7154
7155 static PyObject *py_srvsvc_NetSrvInfo402_get_glist_mtime(PyObject *obj, void *closure)
7156 {
7157         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7158         PyObject *py_glist_mtime;
7159         py_glist_mtime = PyInt_FromLong(object->glist_mtime);
7160         return py_glist_mtime;
7161 }
7162
7163 static int py_srvsvc_NetSrvInfo402_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7164 {
7165         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7166         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7167         object->glist_mtime = PyInt_AsLong(value);
7168         return 0;
7169 }
7170
7171 static PyObject *py_srvsvc_NetSrvInfo402_get_alist_mtime(PyObject *obj, void *closure)
7172 {
7173         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7174         PyObject *py_alist_mtime;
7175         py_alist_mtime = PyInt_FromLong(object->alist_mtime);
7176         return py_alist_mtime;
7177 }
7178
7179 static int py_srvsvc_NetSrvInfo402_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7180 {
7181         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7182         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7183         object->alist_mtime = PyInt_AsLong(value);
7184         return 0;
7185 }
7186
7187 static PyObject *py_srvsvc_NetSrvInfo402_get_alerts(PyObject *obj, void *closure)
7188 {
7189         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7190         PyObject *py_alerts;
7191         if (object->alerts == NULL) {
7192                 py_alerts = Py_None;
7193                 Py_INCREF(py_alerts);
7194         } else {
7195                 if (object->alerts == NULL) {
7196                         py_alerts = Py_None;
7197                         Py_INCREF(py_alerts);
7198                 } else {
7199                         py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
7200                 }
7201         }
7202         return py_alerts;
7203 }
7204
7205 static int py_srvsvc_NetSrvInfo402_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
7206 {
7207         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7208         if (value == Py_None) {
7209                 object->alerts = NULL;
7210         } else {
7211                 object->alerts = NULL;
7212                 if (PyUnicode_Check(value)) {
7213                         object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7214                 } else if (PyString_Check(value)) {
7215                         object->alerts = PyString_AS_STRING(value);
7216                 } else {
7217                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7218                         return -1;
7219                 }
7220         }
7221         return 0;
7222 }
7223
7224 static PyObject *py_srvsvc_NetSrvInfo402_get_security(PyObject *obj, void *closure)
7225 {
7226         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7227         PyObject *py_security;
7228         py_security = PyInt_FromLong(object->security);
7229         return py_security;
7230 }
7231
7232 static int py_srvsvc_NetSrvInfo402_set_security(PyObject *py_obj, PyObject *value, void *closure)
7233 {
7234         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7235         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7236         object->security = PyInt_AsLong(value);
7237         return 0;
7238 }
7239
7240 static PyObject *py_srvsvc_NetSrvInfo402_get_numadmin(PyObject *obj, void *closure)
7241 {
7242         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7243         PyObject *py_numadmin;
7244         py_numadmin = PyInt_FromLong(object->numadmin);
7245         return py_numadmin;
7246 }
7247
7248 static int py_srvsvc_NetSrvInfo402_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
7249 {
7250         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7251         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7252         object->numadmin = PyInt_AsLong(value);
7253         return 0;
7254 }
7255
7256 static PyObject *py_srvsvc_NetSrvInfo402_get_lanmask(PyObject *obj, void *closure)
7257 {
7258         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7259         PyObject *py_lanmask;
7260         py_lanmask = PyInt_FromLong(object->lanmask);
7261         return py_lanmask;
7262 }
7263
7264 static int py_srvsvc_NetSrvInfo402_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
7265 {
7266         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7267         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7268         object->lanmask = PyInt_AsLong(value);
7269         return 0;
7270 }
7271
7272 static PyObject *py_srvsvc_NetSrvInfo402_get_guestaccount(PyObject *obj, void *closure)
7273 {
7274         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7275         PyObject *py_guestaccount;
7276         if (object->guestaccount == NULL) {
7277                 py_guestaccount = Py_None;
7278                 Py_INCREF(py_guestaccount);
7279         } else {
7280                 if (object->guestaccount == NULL) {
7281                         py_guestaccount = Py_None;
7282                         Py_INCREF(py_guestaccount);
7283                 } else {
7284                         py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
7285                 }
7286         }
7287         return py_guestaccount;
7288 }
7289
7290 static int py_srvsvc_NetSrvInfo402_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
7291 {
7292         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7293         if (value == Py_None) {
7294                 object->guestaccount = NULL;
7295         } else {
7296                 object->guestaccount = NULL;
7297                 if (PyUnicode_Check(value)) {
7298                         object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7299                 } else if (PyString_Check(value)) {
7300                         object->guestaccount = PyString_AS_STRING(value);
7301                 } else {
7302                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7303                         return -1;
7304                 }
7305         }
7306         return 0;
7307 }
7308
7309 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevs(PyObject *obj, void *closure)
7310 {
7311         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7312         PyObject *py_chdevs;
7313         py_chdevs = PyInt_FromLong(object->chdevs);
7314         return py_chdevs;
7315 }
7316
7317 static int py_srvsvc_NetSrvInfo402_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
7318 {
7319         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7320         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7321         object->chdevs = PyInt_AsLong(value);
7322         return 0;
7323 }
7324
7325 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevqs(PyObject *obj, void *closure)
7326 {
7327         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7328         PyObject *py_chdevqs;
7329         py_chdevqs = PyInt_FromLong(object->chdevqs);
7330         return py_chdevqs;
7331 }
7332
7333 static int py_srvsvc_NetSrvInfo402_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
7334 {
7335         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7336         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7337         object->chdevqs = PyInt_AsLong(value);
7338         return 0;
7339 }
7340
7341 static PyObject *py_srvsvc_NetSrvInfo402_get_chdevjobs(PyObject *obj, void *closure)
7342 {
7343         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7344         PyObject *py_chdevjobs;
7345         py_chdevjobs = PyInt_FromLong(object->chdevjobs);
7346         return py_chdevjobs;
7347 }
7348
7349 static int py_srvsvc_NetSrvInfo402_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
7350 {
7351         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7352         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7353         object->chdevjobs = PyInt_AsLong(value);
7354         return 0;
7355 }
7356
7357 static PyObject *py_srvsvc_NetSrvInfo402_get_connections(PyObject *obj, void *closure)
7358 {
7359         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7360         PyObject *py_connections;
7361         py_connections = PyInt_FromLong(object->connections);
7362         return py_connections;
7363 }
7364
7365 static int py_srvsvc_NetSrvInfo402_set_connections(PyObject *py_obj, PyObject *value, void *closure)
7366 {
7367         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7368         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7369         object->connections = PyInt_AsLong(value);
7370         return 0;
7371 }
7372
7373 static PyObject *py_srvsvc_NetSrvInfo402_get_shares(PyObject *obj, void *closure)
7374 {
7375         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7376         PyObject *py_shares;
7377         py_shares = PyInt_FromLong(object->shares);
7378         return py_shares;
7379 }
7380
7381 static int py_srvsvc_NetSrvInfo402_set_shares(PyObject *py_obj, PyObject *value, void *closure)
7382 {
7383         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7384         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7385         object->shares = PyInt_AsLong(value);
7386         return 0;
7387 }
7388
7389 static PyObject *py_srvsvc_NetSrvInfo402_get_openfiles(PyObject *obj, void *closure)
7390 {
7391         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7392         PyObject *py_openfiles;
7393         py_openfiles = PyInt_FromLong(object->openfiles);
7394         return py_openfiles;
7395 }
7396
7397 static int py_srvsvc_NetSrvInfo402_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
7398 {
7399         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7400         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7401         object->openfiles = PyInt_AsLong(value);
7402         return 0;
7403 }
7404
7405 static PyObject *py_srvsvc_NetSrvInfo402_get_sessopen(PyObject *obj, void *closure)
7406 {
7407         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7408         PyObject *py_sessopen;
7409         py_sessopen = PyInt_FromLong(object->sessopen);
7410         return py_sessopen;
7411 }
7412
7413 static int py_srvsvc_NetSrvInfo402_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
7414 {
7415         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7416         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7417         object->sessopen = PyInt_AsLong(value);
7418         return 0;
7419 }
7420
7421 static PyObject *py_srvsvc_NetSrvInfo402_get_sesssvc(PyObject *obj, void *closure)
7422 {
7423         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7424         PyObject *py_sesssvc;
7425         py_sesssvc = PyInt_FromLong(object->sesssvc);
7426         return py_sesssvc;
7427 }
7428
7429 static int py_srvsvc_NetSrvInfo402_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
7430 {
7431         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7432         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7433         object->sesssvc = PyInt_AsLong(value);
7434         return 0;
7435 }
7436
7437 static PyObject *py_srvsvc_NetSrvInfo402_get_sessreqs(PyObject *obj, void *closure)
7438 {
7439         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7440         PyObject *py_sessreqs;
7441         py_sessreqs = PyInt_FromLong(object->sessreqs);
7442         return py_sessreqs;
7443 }
7444
7445 static int py_srvsvc_NetSrvInfo402_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
7446 {
7447         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7448         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7449         object->sessreqs = PyInt_AsLong(value);
7450         return 0;
7451 }
7452
7453 static PyObject *py_srvsvc_NetSrvInfo402_get_opensearch(PyObject *obj, void *closure)
7454 {
7455         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7456         PyObject *py_opensearch;
7457         py_opensearch = PyInt_FromLong(object->opensearch);
7458         return py_opensearch;
7459 }
7460
7461 static int py_srvsvc_NetSrvInfo402_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
7462 {
7463         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7464         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7465         object->opensearch = PyInt_AsLong(value);
7466         return 0;
7467 }
7468
7469 static PyObject *py_srvsvc_NetSrvInfo402_get_activelocks(PyObject *obj, void *closure)
7470 {
7471         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7472         PyObject *py_activelocks;
7473         py_activelocks = PyInt_FromLong(object->activelocks);
7474         return py_activelocks;
7475 }
7476
7477 static int py_srvsvc_NetSrvInfo402_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
7478 {
7479         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7480         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7481         object->activelocks = PyInt_AsLong(value);
7482         return 0;
7483 }
7484
7485 static PyObject *py_srvsvc_NetSrvInfo402_get_numreqbufs(PyObject *obj, void *closure)
7486 {
7487         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7488         PyObject *py_numreqbufs;
7489         py_numreqbufs = PyInt_FromLong(object->numreqbufs);
7490         return py_numreqbufs;
7491 }
7492
7493 static int py_srvsvc_NetSrvInfo402_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
7494 {
7495         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7496         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7497         object->numreqbufs = PyInt_AsLong(value);
7498         return 0;
7499 }
7500
7501 static PyObject *py_srvsvc_NetSrvInfo402_get_sizereqbufs(PyObject *obj, void *closure)
7502 {
7503         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7504         PyObject *py_sizereqbufs;
7505         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
7506         return py_sizereqbufs;
7507 }
7508
7509 static int py_srvsvc_NetSrvInfo402_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
7510 {
7511         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7512         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7513         object->sizereqbufs = PyInt_AsLong(value);
7514         return 0;
7515 }
7516
7517 static PyObject *py_srvsvc_NetSrvInfo402_get_numbigbufs(PyObject *obj, void *closure)
7518 {
7519         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7520         PyObject *py_numbigbufs;
7521         py_numbigbufs = PyInt_FromLong(object->numbigbufs);
7522         return py_numbigbufs;
7523 }
7524
7525 static int py_srvsvc_NetSrvInfo402_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
7526 {
7527         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7528         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7529         object->numbigbufs = PyInt_AsLong(value);
7530         return 0;
7531 }
7532
7533 static PyObject *py_srvsvc_NetSrvInfo402_get_numfiletasks(PyObject *obj, void *closure)
7534 {
7535         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7536         PyObject *py_numfiletasks;
7537         py_numfiletasks = PyInt_FromLong(object->numfiletasks);
7538         return py_numfiletasks;
7539 }
7540
7541 static int py_srvsvc_NetSrvInfo402_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
7542 {
7543         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7544         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7545         object->numfiletasks = PyInt_AsLong(value);
7546         return 0;
7547 }
7548
7549 static PyObject *py_srvsvc_NetSrvInfo402_get_alertsched(PyObject *obj, void *closure)
7550 {
7551         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7552         PyObject *py_alertsched;
7553         py_alertsched = PyInt_FromLong(object->alertsched);
7554         return py_alertsched;
7555 }
7556
7557 static int py_srvsvc_NetSrvInfo402_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
7558 {
7559         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7560         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7561         object->alertsched = PyInt_AsLong(value);
7562         return 0;
7563 }
7564
7565 static PyObject *py_srvsvc_NetSrvInfo402_get_erroralert(PyObject *obj, void *closure)
7566 {
7567         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7568         PyObject *py_erroralert;
7569         py_erroralert = PyInt_FromLong(object->erroralert);
7570         return py_erroralert;
7571 }
7572
7573 static int py_srvsvc_NetSrvInfo402_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
7574 {
7575         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7576         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7577         object->erroralert = PyInt_AsLong(value);
7578         return 0;
7579 }
7580
7581 static PyObject *py_srvsvc_NetSrvInfo402_get_logonalert(PyObject *obj, void *closure)
7582 {
7583         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7584         PyObject *py_logonalert;
7585         py_logonalert = PyInt_FromLong(object->logonalert);
7586         return py_logonalert;
7587 }
7588
7589 static int py_srvsvc_NetSrvInfo402_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
7590 {
7591         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7592         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7593         object->logonalert = PyInt_AsLong(value);
7594         return 0;
7595 }
7596
7597 static PyObject *py_srvsvc_NetSrvInfo402_get_accessalert(PyObject *obj, void *closure)
7598 {
7599         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7600         PyObject *py_accessalert;
7601         py_accessalert = PyInt_FromLong(object->accessalert);
7602         return py_accessalert;
7603 }
7604
7605 static int py_srvsvc_NetSrvInfo402_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
7606 {
7607         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7608         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7609         object->accessalert = PyInt_AsLong(value);
7610         return 0;
7611 }
7612
7613 static PyObject *py_srvsvc_NetSrvInfo402_get_diskalert(PyObject *obj, void *closure)
7614 {
7615         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7616         PyObject *py_diskalert;
7617         py_diskalert = PyInt_FromLong(object->diskalert);
7618         return py_diskalert;
7619 }
7620
7621 static int py_srvsvc_NetSrvInfo402_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
7622 {
7623         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7624         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7625         object->diskalert = PyInt_AsLong(value);
7626         return 0;
7627 }
7628
7629 static PyObject *py_srvsvc_NetSrvInfo402_get_netioalert(PyObject *obj, void *closure)
7630 {
7631         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7632         PyObject *py_netioalert;
7633         py_netioalert = PyInt_FromLong(object->netioalert);
7634         return py_netioalert;
7635 }
7636
7637 static int py_srvsvc_NetSrvInfo402_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
7638 {
7639         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7640         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7641         object->netioalert = PyInt_AsLong(value);
7642         return 0;
7643 }
7644
7645 static PyObject *py_srvsvc_NetSrvInfo402_get_maxaudits(PyObject *obj, void *closure)
7646 {
7647         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7648         PyObject *py_maxaudits;
7649         py_maxaudits = PyInt_FromLong(object->maxaudits);
7650         return py_maxaudits;
7651 }
7652
7653 static int py_srvsvc_NetSrvInfo402_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
7654 {
7655         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7656         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7657         object->maxaudits = PyInt_AsLong(value);
7658         return 0;
7659 }
7660
7661 static PyObject *py_srvsvc_NetSrvInfo402_get_srvheuristics(PyObject *obj, void *closure)
7662 {
7663         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(obj);
7664         PyObject *py_srvheuristics;
7665         if (object->srvheuristics == NULL) {
7666                 py_srvheuristics = Py_None;
7667                 Py_INCREF(py_srvheuristics);
7668         } else {
7669                 if (object->srvheuristics == NULL) {
7670                         py_srvheuristics = Py_None;
7671                         Py_INCREF(py_srvheuristics);
7672                 } else {
7673                         py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
7674                 }
7675         }
7676         return py_srvheuristics;
7677 }
7678
7679 static int py_srvsvc_NetSrvInfo402_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
7680 {
7681         struct srvsvc_NetSrvInfo402 *object = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(py_obj);
7682         if (value == Py_None) {
7683                 object->srvheuristics = NULL;
7684         } else {
7685                 object->srvheuristics = NULL;
7686                 if (PyUnicode_Check(value)) {
7687                         object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7688                 } else if (PyString_Check(value)) {
7689                         object->srvheuristics = PyString_AS_STRING(value);
7690                 } else {
7691                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7692                         return -1;
7693                 }
7694         }
7695         return 0;
7696 }
7697
7698 static PyGetSetDef py_srvsvc_NetSrvInfo402_getsetters[] = {
7699         { discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo402_get_ulist_mtime, py_srvsvc_NetSrvInfo402_set_ulist_mtime },
7700         { discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo402_get_glist_mtime, py_srvsvc_NetSrvInfo402_set_glist_mtime },
7701         { discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo402_get_alist_mtime, py_srvsvc_NetSrvInfo402_set_alist_mtime },
7702         { discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo402_get_alerts, py_srvsvc_NetSrvInfo402_set_alerts },
7703         { discard_const_p(char, "security"), py_srvsvc_NetSrvInfo402_get_security, py_srvsvc_NetSrvInfo402_set_security },
7704         { discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo402_get_numadmin, py_srvsvc_NetSrvInfo402_set_numadmin },
7705         { discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo402_get_lanmask, py_srvsvc_NetSrvInfo402_set_lanmask },
7706         { discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo402_get_guestaccount, py_srvsvc_NetSrvInfo402_set_guestaccount },
7707         { discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo402_get_chdevs, py_srvsvc_NetSrvInfo402_set_chdevs },
7708         { discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo402_get_chdevqs, py_srvsvc_NetSrvInfo402_set_chdevqs },
7709         { discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo402_get_chdevjobs, py_srvsvc_NetSrvInfo402_set_chdevjobs },
7710         { discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo402_get_connections, py_srvsvc_NetSrvInfo402_set_connections },
7711         { discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo402_get_shares, py_srvsvc_NetSrvInfo402_set_shares },
7712         { discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo402_get_openfiles, py_srvsvc_NetSrvInfo402_set_openfiles },
7713         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo402_get_sessopen, py_srvsvc_NetSrvInfo402_set_sessopen },
7714         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo402_get_sesssvc, py_srvsvc_NetSrvInfo402_set_sesssvc },
7715         { discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo402_get_sessreqs, py_srvsvc_NetSrvInfo402_set_sessreqs },
7716         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo402_get_opensearch, py_srvsvc_NetSrvInfo402_set_opensearch },
7717         { discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo402_get_activelocks, py_srvsvc_NetSrvInfo402_set_activelocks },
7718         { discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo402_get_numreqbufs, py_srvsvc_NetSrvInfo402_set_numreqbufs },
7719         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo402_get_sizereqbufs, py_srvsvc_NetSrvInfo402_set_sizereqbufs },
7720         { discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo402_get_numbigbufs, py_srvsvc_NetSrvInfo402_set_numbigbufs },
7721         { discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo402_get_numfiletasks, py_srvsvc_NetSrvInfo402_set_numfiletasks },
7722         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo402_get_alertsched, py_srvsvc_NetSrvInfo402_set_alertsched },
7723         { discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo402_get_erroralert, py_srvsvc_NetSrvInfo402_set_erroralert },
7724         { discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo402_get_logonalert, py_srvsvc_NetSrvInfo402_set_logonalert },
7725         { discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo402_get_accessalert, py_srvsvc_NetSrvInfo402_set_accessalert },
7726         { discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo402_get_diskalert, py_srvsvc_NetSrvInfo402_set_diskalert },
7727         { discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo402_get_netioalert, py_srvsvc_NetSrvInfo402_set_netioalert },
7728         { discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo402_get_maxaudits, py_srvsvc_NetSrvInfo402_set_maxaudits },
7729         { discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo402_get_srvheuristics, py_srvsvc_NetSrvInfo402_set_srvheuristics },
7730         { NULL }
7731 };
7732
7733 static PyObject *py_srvsvc_NetSrvInfo402_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
7734 {
7735         return pytalloc_new(struct srvsvc_NetSrvInfo402, type);
7736 }
7737
7738
7739 static PyTypeObject srvsvc_NetSrvInfo402_Type = {
7740         PyObject_HEAD_INIT(NULL) 0,
7741         .tp_name = "srvsvc.NetSrvInfo402",
7742         .tp_getset = py_srvsvc_NetSrvInfo402_getsetters,
7743         .tp_methods = NULL,
7744         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7745         .tp_basicsize = sizeof(pytalloc_Object),
7746         .tp_new = py_srvsvc_NetSrvInfo402_new,
7747 };
7748
7749
7750 static PyObject *py_srvsvc_NetSrvInfo403_get_ulist_mtime(PyObject *obj, void *closure)
7751 {
7752         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7753         PyObject *py_ulist_mtime;
7754         py_ulist_mtime = PyInt_FromLong(object->ulist_mtime);
7755         return py_ulist_mtime;
7756 }
7757
7758 static int py_srvsvc_NetSrvInfo403_set_ulist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7759 {
7760         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7761         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7762         object->ulist_mtime = PyInt_AsLong(value);
7763         return 0;
7764 }
7765
7766 static PyObject *py_srvsvc_NetSrvInfo403_get_glist_mtime(PyObject *obj, void *closure)
7767 {
7768         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7769         PyObject *py_glist_mtime;
7770         py_glist_mtime = PyInt_FromLong(object->glist_mtime);
7771         return py_glist_mtime;
7772 }
7773
7774 static int py_srvsvc_NetSrvInfo403_set_glist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7775 {
7776         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7777         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7778         object->glist_mtime = PyInt_AsLong(value);
7779         return 0;
7780 }
7781
7782 static PyObject *py_srvsvc_NetSrvInfo403_get_alist_mtime(PyObject *obj, void *closure)
7783 {
7784         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7785         PyObject *py_alist_mtime;
7786         py_alist_mtime = PyInt_FromLong(object->alist_mtime);
7787         return py_alist_mtime;
7788 }
7789
7790 static int py_srvsvc_NetSrvInfo403_set_alist_mtime(PyObject *py_obj, PyObject *value, void *closure)
7791 {
7792         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7793         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7794         object->alist_mtime = PyInt_AsLong(value);
7795         return 0;
7796 }
7797
7798 static PyObject *py_srvsvc_NetSrvInfo403_get_alerts(PyObject *obj, void *closure)
7799 {
7800         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7801         PyObject *py_alerts;
7802         if (object->alerts == NULL) {
7803                 py_alerts = Py_None;
7804                 Py_INCREF(py_alerts);
7805         } else {
7806                 if (object->alerts == NULL) {
7807                         py_alerts = Py_None;
7808                         Py_INCREF(py_alerts);
7809                 } else {
7810                         py_alerts = PyUnicode_Decode(object->alerts, strlen(object->alerts), "utf-8", "ignore");
7811                 }
7812         }
7813         return py_alerts;
7814 }
7815
7816 static int py_srvsvc_NetSrvInfo403_set_alerts(PyObject *py_obj, PyObject *value, void *closure)
7817 {
7818         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7819         if (value == Py_None) {
7820                 object->alerts = NULL;
7821         } else {
7822                 object->alerts = NULL;
7823                 if (PyUnicode_Check(value)) {
7824                         object->alerts = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7825                 } else if (PyString_Check(value)) {
7826                         object->alerts = PyString_AS_STRING(value);
7827                 } else {
7828                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7829                         return -1;
7830                 }
7831         }
7832         return 0;
7833 }
7834
7835 static PyObject *py_srvsvc_NetSrvInfo403_get_security(PyObject *obj, void *closure)
7836 {
7837         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7838         PyObject *py_security;
7839         py_security = PyInt_FromLong(object->security);
7840         return py_security;
7841 }
7842
7843 static int py_srvsvc_NetSrvInfo403_set_security(PyObject *py_obj, PyObject *value, void *closure)
7844 {
7845         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7846         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7847         object->security = PyInt_AsLong(value);
7848         return 0;
7849 }
7850
7851 static PyObject *py_srvsvc_NetSrvInfo403_get_numadmin(PyObject *obj, void *closure)
7852 {
7853         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7854         PyObject *py_numadmin;
7855         py_numadmin = PyInt_FromLong(object->numadmin);
7856         return py_numadmin;
7857 }
7858
7859 static int py_srvsvc_NetSrvInfo403_set_numadmin(PyObject *py_obj, PyObject *value, void *closure)
7860 {
7861         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7862         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7863         object->numadmin = PyInt_AsLong(value);
7864         return 0;
7865 }
7866
7867 static PyObject *py_srvsvc_NetSrvInfo403_get_lanmask(PyObject *obj, void *closure)
7868 {
7869         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7870         PyObject *py_lanmask;
7871         py_lanmask = PyInt_FromLong(object->lanmask);
7872         return py_lanmask;
7873 }
7874
7875 static int py_srvsvc_NetSrvInfo403_set_lanmask(PyObject *py_obj, PyObject *value, void *closure)
7876 {
7877         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7878         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7879         object->lanmask = PyInt_AsLong(value);
7880         return 0;
7881 }
7882
7883 static PyObject *py_srvsvc_NetSrvInfo403_get_guestaccount(PyObject *obj, void *closure)
7884 {
7885         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7886         PyObject *py_guestaccount;
7887         if (object->guestaccount == NULL) {
7888                 py_guestaccount = Py_None;
7889                 Py_INCREF(py_guestaccount);
7890         } else {
7891                 if (object->guestaccount == NULL) {
7892                         py_guestaccount = Py_None;
7893                         Py_INCREF(py_guestaccount);
7894                 } else {
7895                         py_guestaccount = PyUnicode_Decode(object->guestaccount, strlen(object->guestaccount), "utf-8", "ignore");
7896                 }
7897         }
7898         return py_guestaccount;
7899 }
7900
7901 static int py_srvsvc_NetSrvInfo403_set_guestaccount(PyObject *py_obj, PyObject *value, void *closure)
7902 {
7903         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7904         if (value == Py_None) {
7905                 object->guestaccount = NULL;
7906         } else {
7907                 object->guestaccount = NULL;
7908                 if (PyUnicode_Check(value)) {
7909                         object->guestaccount = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
7910                 } else if (PyString_Check(value)) {
7911                         object->guestaccount = PyString_AS_STRING(value);
7912                 } else {
7913                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
7914                         return -1;
7915                 }
7916         }
7917         return 0;
7918 }
7919
7920 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevs(PyObject *obj, void *closure)
7921 {
7922         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7923         PyObject *py_chdevs;
7924         py_chdevs = PyInt_FromLong(object->chdevs);
7925         return py_chdevs;
7926 }
7927
7928 static int py_srvsvc_NetSrvInfo403_set_chdevs(PyObject *py_obj, PyObject *value, void *closure)
7929 {
7930         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7931         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7932         object->chdevs = PyInt_AsLong(value);
7933         return 0;
7934 }
7935
7936 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevqs(PyObject *obj, void *closure)
7937 {
7938         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7939         PyObject *py_chdevqs;
7940         py_chdevqs = PyInt_FromLong(object->chdevqs);
7941         return py_chdevqs;
7942 }
7943
7944 static int py_srvsvc_NetSrvInfo403_set_chdevqs(PyObject *py_obj, PyObject *value, void *closure)
7945 {
7946         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7947         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7948         object->chdevqs = PyInt_AsLong(value);
7949         return 0;
7950 }
7951
7952 static PyObject *py_srvsvc_NetSrvInfo403_get_chdevjobs(PyObject *obj, void *closure)
7953 {
7954         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7955         PyObject *py_chdevjobs;
7956         py_chdevjobs = PyInt_FromLong(object->chdevjobs);
7957         return py_chdevjobs;
7958 }
7959
7960 static int py_srvsvc_NetSrvInfo403_set_chdevjobs(PyObject *py_obj, PyObject *value, void *closure)
7961 {
7962         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7963         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7964         object->chdevjobs = PyInt_AsLong(value);
7965         return 0;
7966 }
7967
7968 static PyObject *py_srvsvc_NetSrvInfo403_get_connections(PyObject *obj, void *closure)
7969 {
7970         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7971         PyObject *py_connections;
7972         py_connections = PyInt_FromLong(object->connections);
7973         return py_connections;
7974 }
7975
7976 static int py_srvsvc_NetSrvInfo403_set_connections(PyObject *py_obj, PyObject *value, void *closure)
7977 {
7978         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7979         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7980         object->connections = PyInt_AsLong(value);
7981         return 0;
7982 }
7983
7984 static PyObject *py_srvsvc_NetSrvInfo403_get_shares(PyObject *obj, void *closure)
7985 {
7986         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
7987         PyObject *py_shares;
7988         py_shares = PyInt_FromLong(object->shares);
7989         return py_shares;
7990 }
7991
7992 static int py_srvsvc_NetSrvInfo403_set_shares(PyObject *py_obj, PyObject *value, void *closure)
7993 {
7994         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
7995         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
7996         object->shares = PyInt_AsLong(value);
7997         return 0;
7998 }
7999
8000 static PyObject *py_srvsvc_NetSrvInfo403_get_openfiles(PyObject *obj, void *closure)
8001 {
8002         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8003         PyObject *py_openfiles;
8004         py_openfiles = PyInt_FromLong(object->openfiles);
8005         return py_openfiles;
8006 }
8007
8008 static int py_srvsvc_NetSrvInfo403_set_openfiles(PyObject *py_obj, PyObject *value, void *closure)
8009 {
8010         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8011         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8012         object->openfiles = PyInt_AsLong(value);
8013         return 0;
8014 }
8015
8016 static PyObject *py_srvsvc_NetSrvInfo403_get_sessopen(PyObject *obj, void *closure)
8017 {
8018         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8019         PyObject *py_sessopen;
8020         py_sessopen = PyInt_FromLong(object->sessopen);
8021         return py_sessopen;
8022 }
8023
8024 static int py_srvsvc_NetSrvInfo403_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8025 {
8026         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8027         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8028         object->sessopen = PyInt_AsLong(value);
8029         return 0;
8030 }
8031
8032 static PyObject *py_srvsvc_NetSrvInfo403_get_sesssvc(PyObject *obj, void *closure)
8033 {
8034         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8035         PyObject *py_sesssvc;
8036         py_sesssvc = PyInt_FromLong(object->sesssvc);
8037         return py_sesssvc;
8038 }
8039
8040 static int py_srvsvc_NetSrvInfo403_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8041 {
8042         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8043         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8044         object->sesssvc = PyInt_AsLong(value);
8045         return 0;
8046 }
8047
8048 static PyObject *py_srvsvc_NetSrvInfo403_get_sessreqs(PyObject *obj, void *closure)
8049 {
8050         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8051         PyObject *py_sessreqs;
8052         py_sessreqs = PyInt_FromLong(object->sessreqs);
8053         return py_sessreqs;
8054 }
8055
8056 static int py_srvsvc_NetSrvInfo403_set_sessreqs(PyObject *py_obj, PyObject *value, void *closure)
8057 {
8058         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8059         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8060         object->sessreqs = PyInt_AsLong(value);
8061         return 0;
8062 }
8063
8064 static PyObject *py_srvsvc_NetSrvInfo403_get_opensearch(PyObject *obj, void *closure)
8065 {
8066         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8067         PyObject *py_opensearch;
8068         py_opensearch = PyInt_FromLong(object->opensearch);
8069         return py_opensearch;
8070 }
8071
8072 static int py_srvsvc_NetSrvInfo403_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8073 {
8074         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8075         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8076         object->opensearch = PyInt_AsLong(value);
8077         return 0;
8078 }
8079
8080 static PyObject *py_srvsvc_NetSrvInfo403_get_activelocks(PyObject *obj, void *closure)
8081 {
8082         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8083         PyObject *py_activelocks;
8084         py_activelocks = PyInt_FromLong(object->activelocks);
8085         return py_activelocks;
8086 }
8087
8088 static int py_srvsvc_NetSrvInfo403_set_activelocks(PyObject *py_obj, PyObject *value, void *closure)
8089 {
8090         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8091         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8092         object->activelocks = PyInt_AsLong(value);
8093         return 0;
8094 }
8095
8096 static PyObject *py_srvsvc_NetSrvInfo403_get_numreqbufs(PyObject *obj, void *closure)
8097 {
8098         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8099         PyObject *py_numreqbufs;
8100         py_numreqbufs = PyInt_FromLong(object->numreqbufs);
8101         return py_numreqbufs;
8102 }
8103
8104 static int py_srvsvc_NetSrvInfo403_set_numreqbufs(PyObject *py_obj, PyObject *value, void *closure)
8105 {
8106         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8107         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8108         object->numreqbufs = PyInt_AsLong(value);
8109         return 0;
8110 }
8111
8112 static PyObject *py_srvsvc_NetSrvInfo403_get_sizereqbufs(PyObject *obj, void *closure)
8113 {
8114         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8115         PyObject *py_sizereqbufs;
8116         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8117         return py_sizereqbufs;
8118 }
8119
8120 static int py_srvsvc_NetSrvInfo403_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8121 {
8122         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8123         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8124         object->sizereqbufs = PyInt_AsLong(value);
8125         return 0;
8126 }
8127
8128 static PyObject *py_srvsvc_NetSrvInfo403_get_numbigbufs(PyObject *obj, void *closure)
8129 {
8130         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8131         PyObject *py_numbigbufs;
8132         py_numbigbufs = PyInt_FromLong(object->numbigbufs);
8133         return py_numbigbufs;
8134 }
8135
8136 static int py_srvsvc_NetSrvInfo403_set_numbigbufs(PyObject *py_obj, PyObject *value, void *closure)
8137 {
8138         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8139         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8140         object->numbigbufs = PyInt_AsLong(value);
8141         return 0;
8142 }
8143
8144 static PyObject *py_srvsvc_NetSrvInfo403_get_numfiletasks(PyObject *obj, void *closure)
8145 {
8146         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8147         PyObject *py_numfiletasks;
8148         py_numfiletasks = PyInt_FromLong(object->numfiletasks);
8149         return py_numfiletasks;
8150 }
8151
8152 static int py_srvsvc_NetSrvInfo403_set_numfiletasks(PyObject *py_obj, PyObject *value, void *closure)
8153 {
8154         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8155         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8156         object->numfiletasks = PyInt_AsLong(value);
8157         return 0;
8158 }
8159
8160 static PyObject *py_srvsvc_NetSrvInfo403_get_alertsched(PyObject *obj, void *closure)
8161 {
8162         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8163         PyObject *py_alertsched;
8164         py_alertsched = PyInt_FromLong(object->alertsched);
8165         return py_alertsched;
8166 }
8167
8168 static int py_srvsvc_NetSrvInfo403_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
8169 {
8170         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8171         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8172         object->alertsched = PyInt_AsLong(value);
8173         return 0;
8174 }
8175
8176 static PyObject *py_srvsvc_NetSrvInfo403_get_erroralert(PyObject *obj, void *closure)
8177 {
8178         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8179         PyObject *py_erroralert;
8180         py_erroralert = PyInt_FromLong(object->erroralert);
8181         return py_erroralert;
8182 }
8183
8184 static int py_srvsvc_NetSrvInfo403_set_erroralert(PyObject *py_obj, PyObject *value, void *closure)
8185 {
8186         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8187         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8188         object->erroralert = PyInt_AsLong(value);
8189         return 0;
8190 }
8191
8192 static PyObject *py_srvsvc_NetSrvInfo403_get_logonalert(PyObject *obj, void *closure)
8193 {
8194         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8195         PyObject *py_logonalert;
8196         py_logonalert = PyInt_FromLong(object->logonalert);
8197         return py_logonalert;
8198 }
8199
8200 static int py_srvsvc_NetSrvInfo403_set_logonalert(PyObject *py_obj, PyObject *value, void *closure)
8201 {
8202         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8203         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8204         object->logonalert = PyInt_AsLong(value);
8205         return 0;
8206 }
8207
8208 static PyObject *py_srvsvc_NetSrvInfo403_get_accessalert(PyObject *obj, void *closure)
8209 {
8210         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8211         PyObject *py_accessalert;
8212         py_accessalert = PyInt_FromLong(object->accessalert);
8213         return py_accessalert;
8214 }
8215
8216 static int py_srvsvc_NetSrvInfo403_set_accessalert(PyObject *py_obj, PyObject *value, void *closure)
8217 {
8218         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8219         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8220         object->accessalert = PyInt_AsLong(value);
8221         return 0;
8222 }
8223
8224 static PyObject *py_srvsvc_NetSrvInfo403_get_diskalert(PyObject *obj, void *closure)
8225 {
8226         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8227         PyObject *py_diskalert;
8228         py_diskalert = PyInt_FromLong(object->diskalert);
8229         return py_diskalert;
8230 }
8231
8232 static int py_srvsvc_NetSrvInfo403_set_diskalert(PyObject *py_obj, PyObject *value, void *closure)
8233 {
8234         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8235         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8236         object->diskalert = PyInt_AsLong(value);
8237         return 0;
8238 }
8239
8240 static PyObject *py_srvsvc_NetSrvInfo403_get_netioalert(PyObject *obj, void *closure)
8241 {
8242         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8243         PyObject *py_netioalert;
8244         py_netioalert = PyInt_FromLong(object->netioalert);
8245         return py_netioalert;
8246 }
8247
8248 static int py_srvsvc_NetSrvInfo403_set_netioalert(PyObject *py_obj, PyObject *value, void *closure)
8249 {
8250         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8251         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8252         object->netioalert = PyInt_AsLong(value);
8253         return 0;
8254 }
8255
8256 static PyObject *py_srvsvc_NetSrvInfo403_get_maxaudits(PyObject *obj, void *closure)
8257 {
8258         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8259         PyObject *py_maxaudits;
8260         py_maxaudits = PyInt_FromLong(object->maxaudits);
8261         return py_maxaudits;
8262 }
8263
8264 static int py_srvsvc_NetSrvInfo403_set_maxaudits(PyObject *py_obj, PyObject *value, void *closure)
8265 {
8266         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8267         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8268         object->maxaudits = PyInt_AsLong(value);
8269         return 0;
8270 }
8271
8272 static PyObject *py_srvsvc_NetSrvInfo403_get_srvheuristics(PyObject *obj, void *closure)
8273 {
8274         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8275         PyObject *py_srvheuristics;
8276         if (object->srvheuristics == NULL) {
8277                 py_srvheuristics = Py_None;
8278                 Py_INCREF(py_srvheuristics);
8279         } else {
8280                 if (object->srvheuristics == NULL) {
8281                         py_srvheuristics = Py_None;
8282                         Py_INCREF(py_srvheuristics);
8283                 } else {
8284                         py_srvheuristics = PyUnicode_Decode(object->srvheuristics, strlen(object->srvheuristics), "utf-8", "ignore");
8285                 }
8286         }
8287         return py_srvheuristics;
8288 }
8289
8290 static int py_srvsvc_NetSrvInfo403_set_srvheuristics(PyObject *py_obj, PyObject *value, void *closure)
8291 {
8292         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8293         if (value == Py_None) {
8294                 object->srvheuristics = NULL;
8295         } else {
8296                 object->srvheuristics = NULL;
8297                 if (PyUnicode_Check(value)) {
8298                         object->srvheuristics = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
8299                 } else if (PyString_Check(value)) {
8300                         object->srvheuristics = PyString_AS_STRING(value);
8301                 } else {
8302                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
8303                         return -1;
8304                 }
8305         }
8306         return 0;
8307 }
8308
8309 static PyObject *py_srvsvc_NetSrvInfo403_get_auditedevents(PyObject *obj, void *closure)
8310 {
8311         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8312         PyObject *py_auditedevents;
8313         py_auditedevents = PyInt_FromLong(object->auditedevents);
8314         return py_auditedevents;
8315 }
8316
8317 static int py_srvsvc_NetSrvInfo403_set_auditedevents(PyObject *py_obj, PyObject *value, void *closure)
8318 {
8319         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8320         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8321         object->auditedevents = PyInt_AsLong(value);
8322         return 0;
8323 }
8324
8325 static PyObject *py_srvsvc_NetSrvInfo403_get_auditprofile(PyObject *obj, void *closure)
8326 {
8327         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8328         PyObject *py_auditprofile;
8329         py_auditprofile = PyInt_FromLong(object->auditprofile);
8330         return py_auditprofile;
8331 }
8332
8333 static int py_srvsvc_NetSrvInfo403_set_auditprofile(PyObject *py_obj, PyObject *value, void *closure)
8334 {
8335         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8336         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8337         object->auditprofile = PyInt_AsLong(value);
8338         return 0;
8339 }
8340
8341 static PyObject *py_srvsvc_NetSrvInfo403_get_autopath(PyObject *obj, void *closure)
8342 {
8343         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(obj);
8344         PyObject *py_autopath;
8345         if (object->autopath == NULL) {
8346                 py_autopath = Py_None;
8347                 Py_INCREF(py_autopath);
8348         } else {
8349                 if (object->autopath == NULL) {
8350                         py_autopath = Py_None;
8351                         Py_INCREF(py_autopath);
8352                 } else {
8353                         py_autopath = PyUnicode_Decode(object->autopath, strlen(object->autopath), "utf-8", "ignore");
8354                 }
8355         }
8356         return py_autopath;
8357 }
8358
8359 static int py_srvsvc_NetSrvInfo403_set_autopath(PyObject *py_obj, PyObject *value, void *closure)
8360 {
8361         struct srvsvc_NetSrvInfo403 *object = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(py_obj);
8362         if (value == Py_None) {
8363                 object->autopath = NULL;
8364         } else {
8365                 object->autopath = NULL;
8366                 if (PyUnicode_Check(value)) {
8367                         object->autopath = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
8368                 } else if (PyString_Check(value)) {
8369                         object->autopath = PyString_AS_STRING(value);
8370                 } else {
8371                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
8372                         return -1;
8373                 }
8374         }
8375         return 0;
8376 }
8377
8378 static PyGetSetDef py_srvsvc_NetSrvInfo403_getsetters[] = {
8379         { discard_const_p(char, "ulist_mtime"), py_srvsvc_NetSrvInfo403_get_ulist_mtime, py_srvsvc_NetSrvInfo403_set_ulist_mtime },
8380         { discard_const_p(char, "glist_mtime"), py_srvsvc_NetSrvInfo403_get_glist_mtime, py_srvsvc_NetSrvInfo403_set_glist_mtime },
8381         { discard_const_p(char, "alist_mtime"), py_srvsvc_NetSrvInfo403_get_alist_mtime, py_srvsvc_NetSrvInfo403_set_alist_mtime },
8382         { discard_const_p(char, "alerts"), py_srvsvc_NetSrvInfo403_get_alerts, py_srvsvc_NetSrvInfo403_set_alerts },
8383         { discard_const_p(char, "security"), py_srvsvc_NetSrvInfo403_get_security, py_srvsvc_NetSrvInfo403_set_security },
8384         { discard_const_p(char, "numadmin"), py_srvsvc_NetSrvInfo403_get_numadmin, py_srvsvc_NetSrvInfo403_set_numadmin },
8385         { discard_const_p(char, "lanmask"), py_srvsvc_NetSrvInfo403_get_lanmask, py_srvsvc_NetSrvInfo403_set_lanmask },
8386         { discard_const_p(char, "guestaccount"), py_srvsvc_NetSrvInfo403_get_guestaccount, py_srvsvc_NetSrvInfo403_set_guestaccount },
8387         { discard_const_p(char, "chdevs"), py_srvsvc_NetSrvInfo403_get_chdevs, py_srvsvc_NetSrvInfo403_set_chdevs },
8388         { discard_const_p(char, "chdevqs"), py_srvsvc_NetSrvInfo403_get_chdevqs, py_srvsvc_NetSrvInfo403_set_chdevqs },
8389         { discard_const_p(char, "chdevjobs"), py_srvsvc_NetSrvInfo403_get_chdevjobs, py_srvsvc_NetSrvInfo403_set_chdevjobs },
8390         { discard_const_p(char, "connections"), py_srvsvc_NetSrvInfo403_get_connections, py_srvsvc_NetSrvInfo403_set_connections },
8391         { discard_const_p(char, "shares"), py_srvsvc_NetSrvInfo403_get_shares, py_srvsvc_NetSrvInfo403_set_shares },
8392         { discard_const_p(char, "openfiles"), py_srvsvc_NetSrvInfo403_get_openfiles, py_srvsvc_NetSrvInfo403_set_openfiles },
8393         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo403_get_sessopen, py_srvsvc_NetSrvInfo403_set_sessopen },
8394         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo403_get_sesssvc, py_srvsvc_NetSrvInfo403_set_sesssvc },
8395         { discard_const_p(char, "sessreqs"), py_srvsvc_NetSrvInfo403_get_sessreqs, py_srvsvc_NetSrvInfo403_set_sessreqs },
8396         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo403_get_opensearch, py_srvsvc_NetSrvInfo403_set_opensearch },
8397         { discard_const_p(char, "activelocks"), py_srvsvc_NetSrvInfo403_get_activelocks, py_srvsvc_NetSrvInfo403_set_activelocks },
8398         { discard_const_p(char, "numreqbufs"), py_srvsvc_NetSrvInfo403_get_numreqbufs, py_srvsvc_NetSrvInfo403_set_numreqbufs },
8399         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo403_get_sizereqbufs, py_srvsvc_NetSrvInfo403_set_sizereqbufs },
8400         { discard_const_p(char, "numbigbufs"), py_srvsvc_NetSrvInfo403_get_numbigbufs, py_srvsvc_NetSrvInfo403_set_numbigbufs },
8401         { discard_const_p(char, "numfiletasks"), py_srvsvc_NetSrvInfo403_get_numfiletasks, py_srvsvc_NetSrvInfo403_set_numfiletasks },
8402         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo403_get_alertsched, py_srvsvc_NetSrvInfo403_set_alertsched },
8403         { discard_const_p(char, "erroralert"), py_srvsvc_NetSrvInfo403_get_erroralert, py_srvsvc_NetSrvInfo403_set_erroralert },
8404         { discard_const_p(char, "logonalert"), py_srvsvc_NetSrvInfo403_get_logonalert, py_srvsvc_NetSrvInfo403_set_logonalert },
8405         { discard_const_p(char, "accessalert"), py_srvsvc_NetSrvInfo403_get_accessalert, py_srvsvc_NetSrvInfo403_set_accessalert },
8406         { discard_const_p(char, "diskalert"), py_srvsvc_NetSrvInfo403_get_diskalert, py_srvsvc_NetSrvInfo403_set_diskalert },
8407         { discard_const_p(char, "netioalert"), py_srvsvc_NetSrvInfo403_get_netioalert, py_srvsvc_NetSrvInfo403_set_netioalert },
8408         { discard_const_p(char, "maxaudits"), py_srvsvc_NetSrvInfo403_get_maxaudits, py_srvsvc_NetSrvInfo403_set_maxaudits },
8409         { discard_const_p(char, "srvheuristics"), py_srvsvc_NetSrvInfo403_get_srvheuristics, py_srvsvc_NetSrvInfo403_set_srvheuristics },
8410         { discard_const_p(char, "auditedevents"), py_srvsvc_NetSrvInfo403_get_auditedevents, py_srvsvc_NetSrvInfo403_set_auditedevents },
8411         { discard_const_p(char, "auditprofile"), py_srvsvc_NetSrvInfo403_get_auditprofile, py_srvsvc_NetSrvInfo403_set_auditprofile },
8412         { discard_const_p(char, "autopath"), py_srvsvc_NetSrvInfo403_get_autopath, py_srvsvc_NetSrvInfo403_set_autopath },
8413         { NULL }
8414 };
8415
8416 static PyObject *py_srvsvc_NetSrvInfo403_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
8417 {
8418         return pytalloc_new(struct srvsvc_NetSrvInfo403, type);
8419 }
8420
8421
8422 static PyTypeObject srvsvc_NetSrvInfo403_Type = {
8423         PyObject_HEAD_INIT(NULL) 0,
8424         .tp_name = "srvsvc.NetSrvInfo403",
8425         .tp_getset = py_srvsvc_NetSrvInfo403_getsetters,
8426         .tp_methods = NULL,
8427         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
8428         .tp_basicsize = sizeof(pytalloc_Object),
8429         .tp_new = py_srvsvc_NetSrvInfo403_new,
8430 };
8431
8432
8433 static PyObject *py_srvsvc_NetSrvInfo502_get_sessopen(PyObject *obj, void *closure)
8434 {
8435         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8436         PyObject *py_sessopen;
8437         py_sessopen = PyInt_FromLong(object->sessopen);
8438         return py_sessopen;
8439 }
8440
8441 static int py_srvsvc_NetSrvInfo502_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8442 {
8443         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8444         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8445         object->sessopen = PyInt_AsLong(value);
8446         return 0;
8447 }
8448
8449 static PyObject *py_srvsvc_NetSrvInfo502_get_sesssvc(PyObject *obj, void *closure)
8450 {
8451         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8452         PyObject *py_sesssvc;
8453         py_sesssvc = PyInt_FromLong(object->sesssvc);
8454         return py_sesssvc;
8455 }
8456
8457 static int py_srvsvc_NetSrvInfo502_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8458 {
8459         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8460         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8461         object->sesssvc = PyInt_AsLong(value);
8462         return 0;
8463 }
8464
8465 static PyObject *py_srvsvc_NetSrvInfo502_get_opensearch(PyObject *obj, void *closure)
8466 {
8467         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8468         PyObject *py_opensearch;
8469         py_opensearch = PyInt_FromLong(object->opensearch);
8470         return py_opensearch;
8471 }
8472
8473 static int py_srvsvc_NetSrvInfo502_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8474 {
8475         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8476         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8477         object->opensearch = PyInt_AsLong(value);
8478         return 0;
8479 }
8480
8481 static PyObject *py_srvsvc_NetSrvInfo502_get_sizereqbufs(PyObject *obj, void *closure)
8482 {
8483         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8484         PyObject *py_sizereqbufs;
8485         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8486         return py_sizereqbufs;
8487 }
8488
8489 static int py_srvsvc_NetSrvInfo502_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8490 {
8491         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8492         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8493         object->sizereqbufs = PyInt_AsLong(value);
8494         return 0;
8495 }
8496
8497 static PyObject *py_srvsvc_NetSrvInfo502_get_initworkitems(PyObject *obj, void *closure)
8498 {
8499         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8500         PyObject *py_initworkitems;
8501         py_initworkitems = PyInt_FromLong(object->initworkitems);
8502         return py_initworkitems;
8503 }
8504
8505 static int py_srvsvc_NetSrvInfo502_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
8506 {
8507         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8508         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8509         object->initworkitems = PyInt_AsLong(value);
8510         return 0;
8511 }
8512
8513 static PyObject *py_srvsvc_NetSrvInfo502_get_maxworkitems(PyObject *obj, void *closure)
8514 {
8515         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8516         PyObject *py_maxworkitems;
8517         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
8518         return py_maxworkitems;
8519 }
8520
8521 static int py_srvsvc_NetSrvInfo502_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
8522 {
8523         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8524         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8525         object->maxworkitems = PyInt_AsLong(value);
8526         return 0;
8527 }
8528
8529 static PyObject *py_srvsvc_NetSrvInfo502_get_rawworkitems(PyObject *obj, void *closure)
8530 {
8531         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8532         PyObject *py_rawworkitems;
8533         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
8534         return py_rawworkitems;
8535 }
8536
8537 static int py_srvsvc_NetSrvInfo502_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
8538 {
8539         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8540         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8541         object->rawworkitems = PyInt_AsLong(value);
8542         return 0;
8543 }
8544
8545 static PyObject *py_srvsvc_NetSrvInfo502_get_irpstacksize(PyObject *obj, void *closure)
8546 {
8547         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8548         PyObject *py_irpstacksize;
8549         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
8550         return py_irpstacksize;
8551 }
8552
8553 static int py_srvsvc_NetSrvInfo502_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
8554 {
8555         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8556         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8557         object->irpstacksize = PyInt_AsLong(value);
8558         return 0;
8559 }
8560
8561 static PyObject *py_srvsvc_NetSrvInfo502_get_maxrawbuflen(PyObject *obj, void *closure)
8562 {
8563         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8564         PyObject *py_maxrawbuflen;
8565         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
8566         return py_maxrawbuflen;
8567 }
8568
8569 static int py_srvsvc_NetSrvInfo502_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
8570 {
8571         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8572         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8573         object->maxrawbuflen = PyInt_AsLong(value);
8574         return 0;
8575 }
8576
8577 static PyObject *py_srvsvc_NetSrvInfo502_get_sessusers(PyObject *obj, void *closure)
8578 {
8579         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8580         PyObject *py_sessusers;
8581         py_sessusers = PyInt_FromLong(object->sessusers);
8582         return py_sessusers;
8583 }
8584
8585 static int py_srvsvc_NetSrvInfo502_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
8586 {
8587         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8588         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8589         object->sessusers = PyInt_AsLong(value);
8590         return 0;
8591 }
8592
8593 static PyObject *py_srvsvc_NetSrvInfo502_get_sessconns(PyObject *obj, void *closure)
8594 {
8595         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8596         PyObject *py_sessconns;
8597         py_sessconns = PyInt_FromLong(object->sessconns);
8598         return py_sessconns;
8599 }
8600
8601 static int py_srvsvc_NetSrvInfo502_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
8602 {
8603         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8604         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8605         object->sessconns = PyInt_AsLong(value);
8606         return 0;
8607 }
8608
8609 static PyObject *py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage(PyObject *obj, void *closure)
8610 {
8611         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8612         PyObject *py_maxpagedmemoryusage;
8613         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
8614         return py_maxpagedmemoryusage;
8615 }
8616
8617 static int py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8618 {
8619         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8620         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8621         object->maxpagedmemoryusage = PyInt_AsLong(value);
8622         return 0;
8623 }
8624
8625 static PyObject *py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
8626 {
8627         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8628         PyObject *py_maxnonpagedmemoryusage;
8629         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
8630         return py_maxnonpagedmemoryusage;
8631 }
8632
8633 static int py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8634 {
8635         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8636         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8637         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
8638         return 0;
8639 }
8640
8641 static PyObject *py_srvsvc_NetSrvInfo502_get_enablesoftcompat(PyObject *obj, void *closure)
8642 {
8643         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8644         PyObject *py_enablesoftcompat;
8645         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
8646         return py_enablesoftcompat;
8647 }
8648
8649 static int py_srvsvc_NetSrvInfo502_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
8650 {
8651         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8652         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8653         object->enablesoftcompat = PyInt_AsLong(value);
8654         return 0;
8655 }
8656
8657 static PyObject *py_srvsvc_NetSrvInfo502_get_enableforcedlogoff(PyObject *obj, void *closure)
8658 {
8659         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8660         PyObject *py_enableforcedlogoff;
8661         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
8662         return py_enableforcedlogoff;
8663 }
8664
8665 static int py_srvsvc_NetSrvInfo502_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
8666 {
8667         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8668         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8669         object->enableforcedlogoff = PyInt_AsLong(value);
8670         return 0;
8671 }
8672
8673 static PyObject *py_srvsvc_NetSrvInfo502_get_timesource(PyObject *obj, void *closure)
8674 {
8675         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8676         PyObject *py_timesource;
8677         py_timesource = PyInt_FromLong(object->timesource);
8678         return py_timesource;
8679 }
8680
8681 static int py_srvsvc_NetSrvInfo502_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
8682 {
8683         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8684         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8685         object->timesource = PyInt_AsLong(value);
8686         return 0;
8687 }
8688
8689 static PyObject *py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis(PyObject *obj, void *closure)
8690 {
8691         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8692         PyObject *py_acceptdownlevelapis;
8693         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
8694         return py_acceptdownlevelapis;
8695 }
8696
8697 static int py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
8698 {
8699         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8700         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8701         object->acceptdownlevelapis = PyInt_AsLong(value);
8702         return 0;
8703 }
8704
8705 static PyObject *py_srvsvc_NetSrvInfo502_get_lmannounce(PyObject *obj, void *closure)
8706 {
8707         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(obj);
8708         PyObject *py_lmannounce;
8709         py_lmannounce = PyInt_FromLong(object->lmannounce);
8710         return py_lmannounce;
8711 }
8712
8713 static int py_srvsvc_NetSrvInfo502_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
8714 {
8715         struct srvsvc_NetSrvInfo502 *object = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(py_obj);
8716         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8717         object->lmannounce = PyInt_AsLong(value);
8718         return 0;
8719 }
8720
8721 static PyGetSetDef py_srvsvc_NetSrvInfo502_getsetters[] = {
8722         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo502_get_sessopen, py_srvsvc_NetSrvInfo502_set_sessopen },
8723         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo502_get_sesssvc, py_srvsvc_NetSrvInfo502_set_sesssvc },
8724         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo502_get_opensearch, py_srvsvc_NetSrvInfo502_set_opensearch },
8725         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo502_get_sizereqbufs, py_srvsvc_NetSrvInfo502_set_sizereqbufs },
8726         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo502_get_initworkitems, py_srvsvc_NetSrvInfo502_set_initworkitems },
8727         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo502_get_maxworkitems, py_srvsvc_NetSrvInfo502_set_maxworkitems },
8728         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo502_get_rawworkitems, py_srvsvc_NetSrvInfo502_set_rawworkitems },
8729         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo502_get_irpstacksize, py_srvsvc_NetSrvInfo502_set_irpstacksize },
8730         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo502_get_maxrawbuflen, py_srvsvc_NetSrvInfo502_set_maxrawbuflen },
8731         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo502_get_sessusers, py_srvsvc_NetSrvInfo502_set_sessusers },
8732         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo502_get_sessconns, py_srvsvc_NetSrvInfo502_set_sessconns },
8733         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxpagedmemoryusage },
8734         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo502_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo502_set_maxnonpagedmemoryusage },
8735         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo502_get_enablesoftcompat, py_srvsvc_NetSrvInfo502_set_enablesoftcompat },
8736         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo502_get_enableforcedlogoff, py_srvsvc_NetSrvInfo502_set_enableforcedlogoff },
8737         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo502_get_timesource, py_srvsvc_NetSrvInfo502_set_timesource },
8738         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo502_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo502_set_acceptdownlevelapis },
8739         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo502_get_lmannounce, py_srvsvc_NetSrvInfo502_set_lmannounce },
8740         { NULL }
8741 };
8742
8743 static PyObject *py_srvsvc_NetSrvInfo502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
8744 {
8745         return pytalloc_new(struct srvsvc_NetSrvInfo502, type);
8746 }
8747
8748
8749 static PyTypeObject srvsvc_NetSrvInfo502_Type = {
8750         PyObject_HEAD_INIT(NULL) 0,
8751         .tp_name = "srvsvc.NetSrvInfo502",
8752         .tp_getset = py_srvsvc_NetSrvInfo502_getsetters,
8753         .tp_methods = NULL,
8754         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
8755         .tp_basicsize = sizeof(pytalloc_Object),
8756         .tp_new = py_srvsvc_NetSrvInfo502_new,
8757 };
8758
8759
8760 static PyObject *py_srvsvc_NetSrvInfo503_get_sessopen(PyObject *obj, void *closure)
8761 {
8762         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8763         PyObject *py_sessopen;
8764         py_sessopen = PyInt_FromLong(object->sessopen);
8765         return py_sessopen;
8766 }
8767
8768 static int py_srvsvc_NetSrvInfo503_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
8769 {
8770         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8771         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8772         object->sessopen = PyInt_AsLong(value);
8773         return 0;
8774 }
8775
8776 static PyObject *py_srvsvc_NetSrvInfo503_get_sesssvc(PyObject *obj, void *closure)
8777 {
8778         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8779         PyObject *py_sesssvc;
8780         py_sesssvc = PyInt_FromLong(object->sesssvc);
8781         return py_sesssvc;
8782 }
8783
8784 static int py_srvsvc_NetSrvInfo503_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
8785 {
8786         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8787         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8788         object->sesssvc = PyInt_AsLong(value);
8789         return 0;
8790 }
8791
8792 static PyObject *py_srvsvc_NetSrvInfo503_get_opensearch(PyObject *obj, void *closure)
8793 {
8794         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8795         PyObject *py_opensearch;
8796         py_opensearch = PyInt_FromLong(object->opensearch);
8797         return py_opensearch;
8798 }
8799
8800 static int py_srvsvc_NetSrvInfo503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
8801 {
8802         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8803         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8804         object->opensearch = PyInt_AsLong(value);
8805         return 0;
8806 }
8807
8808 static PyObject *py_srvsvc_NetSrvInfo503_get_sizereqbufs(PyObject *obj, void *closure)
8809 {
8810         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8811         PyObject *py_sizereqbufs;
8812         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
8813         return py_sizereqbufs;
8814 }
8815
8816 static int py_srvsvc_NetSrvInfo503_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
8817 {
8818         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8819         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8820         object->sizereqbufs = PyInt_AsLong(value);
8821         return 0;
8822 }
8823
8824 static PyObject *py_srvsvc_NetSrvInfo503_get_initworkitems(PyObject *obj, void *closure)
8825 {
8826         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8827         PyObject *py_initworkitems;
8828         py_initworkitems = PyInt_FromLong(object->initworkitems);
8829         return py_initworkitems;
8830 }
8831
8832 static int py_srvsvc_NetSrvInfo503_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
8833 {
8834         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8835         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8836         object->initworkitems = PyInt_AsLong(value);
8837         return 0;
8838 }
8839
8840 static PyObject *py_srvsvc_NetSrvInfo503_get_maxworkitems(PyObject *obj, void *closure)
8841 {
8842         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8843         PyObject *py_maxworkitems;
8844         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
8845         return py_maxworkitems;
8846 }
8847
8848 static int py_srvsvc_NetSrvInfo503_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
8849 {
8850         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8851         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8852         object->maxworkitems = PyInt_AsLong(value);
8853         return 0;
8854 }
8855
8856 static PyObject *py_srvsvc_NetSrvInfo503_get_rawworkitems(PyObject *obj, void *closure)
8857 {
8858         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8859         PyObject *py_rawworkitems;
8860         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
8861         return py_rawworkitems;
8862 }
8863
8864 static int py_srvsvc_NetSrvInfo503_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
8865 {
8866         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8867         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8868         object->rawworkitems = PyInt_AsLong(value);
8869         return 0;
8870 }
8871
8872 static PyObject *py_srvsvc_NetSrvInfo503_get_irpstacksize(PyObject *obj, void *closure)
8873 {
8874         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8875         PyObject *py_irpstacksize;
8876         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
8877         return py_irpstacksize;
8878 }
8879
8880 static int py_srvsvc_NetSrvInfo503_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
8881 {
8882         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8883         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8884         object->irpstacksize = PyInt_AsLong(value);
8885         return 0;
8886 }
8887
8888 static PyObject *py_srvsvc_NetSrvInfo503_get_maxrawbuflen(PyObject *obj, void *closure)
8889 {
8890         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8891         PyObject *py_maxrawbuflen;
8892         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
8893         return py_maxrawbuflen;
8894 }
8895
8896 static int py_srvsvc_NetSrvInfo503_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
8897 {
8898         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8899         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8900         object->maxrawbuflen = PyInt_AsLong(value);
8901         return 0;
8902 }
8903
8904 static PyObject *py_srvsvc_NetSrvInfo503_get_sessusers(PyObject *obj, void *closure)
8905 {
8906         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8907         PyObject *py_sessusers;
8908         py_sessusers = PyInt_FromLong(object->sessusers);
8909         return py_sessusers;
8910 }
8911
8912 static int py_srvsvc_NetSrvInfo503_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
8913 {
8914         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8915         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8916         object->sessusers = PyInt_AsLong(value);
8917         return 0;
8918 }
8919
8920 static PyObject *py_srvsvc_NetSrvInfo503_get_sessconns(PyObject *obj, void *closure)
8921 {
8922         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8923         PyObject *py_sessconns;
8924         py_sessconns = PyInt_FromLong(object->sessconns);
8925         return py_sessconns;
8926 }
8927
8928 static int py_srvsvc_NetSrvInfo503_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
8929 {
8930         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8931         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8932         object->sessconns = PyInt_AsLong(value);
8933         return 0;
8934 }
8935
8936 static PyObject *py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage(PyObject *obj, void *closure)
8937 {
8938         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8939         PyObject *py_maxpagedmemoryusage;
8940         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
8941         return py_maxpagedmemoryusage;
8942 }
8943
8944 static int py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8945 {
8946         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8947         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8948         object->maxpagedmemoryusage = PyInt_AsLong(value);
8949         return 0;
8950 }
8951
8952 static PyObject *py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
8953 {
8954         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8955         PyObject *py_maxnonpagedmemoryusage;
8956         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
8957         return py_maxnonpagedmemoryusage;
8958 }
8959
8960 static int py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
8961 {
8962         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8963         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8964         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
8965         return 0;
8966 }
8967
8968 static PyObject *py_srvsvc_NetSrvInfo503_get_enablesoftcompat(PyObject *obj, void *closure)
8969 {
8970         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8971         PyObject *py_enablesoftcompat;
8972         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
8973         return py_enablesoftcompat;
8974 }
8975
8976 static int py_srvsvc_NetSrvInfo503_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
8977 {
8978         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8979         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8980         object->enablesoftcompat = PyInt_AsLong(value);
8981         return 0;
8982 }
8983
8984 static PyObject *py_srvsvc_NetSrvInfo503_get_enableforcedlogoff(PyObject *obj, void *closure)
8985 {
8986         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
8987         PyObject *py_enableforcedlogoff;
8988         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
8989         return py_enableforcedlogoff;
8990 }
8991
8992 static int py_srvsvc_NetSrvInfo503_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
8993 {
8994         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
8995         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
8996         object->enableforcedlogoff = PyInt_AsLong(value);
8997         return 0;
8998 }
8999
9000 static PyObject *py_srvsvc_NetSrvInfo503_get_timesource(PyObject *obj, void *closure)
9001 {
9002         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9003         PyObject *py_timesource;
9004         py_timesource = PyInt_FromLong(object->timesource);
9005         return py_timesource;
9006 }
9007
9008 static int py_srvsvc_NetSrvInfo503_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
9009 {
9010         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9011         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9012         object->timesource = PyInt_AsLong(value);
9013         return 0;
9014 }
9015
9016 static PyObject *py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis(PyObject *obj, void *closure)
9017 {
9018         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9019         PyObject *py_acceptdownlevelapis;
9020         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
9021         return py_acceptdownlevelapis;
9022 }
9023
9024 static int py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
9025 {
9026         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9027         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9028         object->acceptdownlevelapis = PyInt_AsLong(value);
9029         return 0;
9030 }
9031
9032 static PyObject *py_srvsvc_NetSrvInfo503_get_lmannounce(PyObject *obj, void *closure)
9033 {
9034         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9035         PyObject *py_lmannounce;
9036         py_lmannounce = PyInt_FromLong(object->lmannounce);
9037         return py_lmannounce;
9038 }
9039
9040 static int py_srvsvc_NetSrvInfo503_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
9041 {
9042         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9043         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9044         object->lmannounce = PyInt_AsLong(value);
9045         return 0;
9046 }
9047
9048 static PyObject *py_srvsvc_NetSrvInfo503_get_domain(PyObject *obj, void *closure)
9049 {
9050         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9051         PyObject *py_domain;
9052         if (object->domain == NULL) {
9053                 py_domain = Py_None;
9054                 Py_INCREF(py_domain);
9055         } else {
9056                 if (object->domain == NULL) {
9057                         py_domain = Py_None;
9058                         Py_INCREF(py_domain);
9059                 } else {
9060                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
9061                 }
9062         }
9063         return py_domain;
9064 }
9065
9066 static int py_srvsvc_NetSrvInfo503_set_domain(PyObject *py_obj, PyObject *value, void *closure)
9067 {
9068         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9069         if (value == Py_None) {
9070                 object->domain = NULL;
9071         } else {
9072                 object->domain = NULL;
9073                 if (PyUnicode_Check(value)) {
9074                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
9075                 } else if (PyString_Check(value)) {
9076                         object->domain = PyString_AS_STRING(value);
9077                 } else {
9078                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
9079                         return -1;
9080                 }
9081         }
9082         return 0;
9083 }
9084
9085 static PyObject *py_srvsvc_NetSrvInfo503_get_maxcopyreadlen(PyObject *obj, void *closure)
9086 {
9087         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9088         PyObject *py_maxcopyreadlen;
9089         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
9090         return py_maxcopyreadlen;
9091 }
9092
9093 static int py_srvsvc_NetSrvInfo503_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
9094 {
9095         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9096         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9097         object->maxcopyreadlen = PyInt_AsLong(value);
9098         return 0;
9099 }
9100
9101 static PyObject *py_srvsvc_NetSrvInfo503_get_maxcopywritelen(PyObject *obj, void *closure)
9102 {
9103         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9104         PyObject *py_maxcopywritelen;
9105         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
9106         return py_maxcopywritelen;
9107 }
9108
9109 static int py_srvsvc_NetSrvInfo503_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
9110 {
9111         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9112         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9113         object->maxcopywritelen = PyInt_AsLong(value);
9114         return 0;
9115 }
9116
9117 static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepsearch(PyObject *obj, void *closure)
9118 {
9119         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9120         PyObject *py_minkeepsearch;
9121         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
9122         return py_minkeepsearch;
9123 }
9124
9125 static int py_srvsvc_NetSrvInfo503_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9126 {
9127         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9128         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9129         object->minkeepsearch = PyInt_AsLong(value);
9130         return 0;
9131 }
9132
9133 static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepsearch(PyObject *obj, void *closure)
9134 {
9135         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9136         PyObject *py_maxkeepsearch;
9137         py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
9138         return py_maxkeepsearch;
9139 }
9140
9141 static int py_srvsvc_NetSrvInfo503_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9142 {
9143         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9144         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9145         object->maxkeepsearch = PyInt_AsLong(value);
9146         return 0;
9147 }
9148
9149 static PyObject *py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch(PyObject *obj, void *closure)
9150 {
9151         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9152         PyObject *py_minkeepcomplsearch;
9153         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
9154         return py_minkeepcomplsearch;
9155 }
9156
9157 static int py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9158 {
9159         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9160         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9161         object->minkeepcomplsearch = PyInt_AsLong(value);
9162         return 0;
9163 }
9164
9165 static PyObject *py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch(PyObject *obj, void *closure)
9166 {
9167         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9168         PyObject *py_maxkeepcomplsearch;
9169         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
9170         return py_maxkeepcomplsearch;
9171 }
9172
9173 static int py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9174 {
9175         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9176         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9177         object->maxkeepcomplsearch = PyInt_AsLong(value);
9178         return 0;
9179 }
9180
9181 static PyObject *py_srvsvc_NetSrvInfo503_get_threadcountadd(PyObject *obj, void *closure)
9182 {
9183         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9184         PyObject *py_threadcountadd;
9185         py_threadcountadd = PyInt_FromLong(object->threadcountadd);
9186         return py_threadcountadd;
9187 }
9188
9189 static int py_srvsvc_NetSrvInfo503_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
9190 {
9191         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9192         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9193         object->threadcountadd = PyInt_AsLong(value);
9194         return 0;
9195 }
9196
9197 static PyObject *py_srvsvc_NetSrvInfo503_get_numlockthreads(PyObject *obj, void *closure)
9198 {
9199         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9200         PyObject *py_numlockthreads;
9201         py_numlockthreads = PyInt_FromLong(object->numlockthreads);
9202         return py_numlockthreads;
9203 }
9204
9205 static int py_srvsvc_NetSrvInfo503_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
9206 {
9207         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9208         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9209         object->numlockthreads = PyInt_AsLong(value);
9210         return 0;
9211 }
9212
9213 static PyObject *py_srvsvc_NetSrvInfo503_get_scavtimeout(PyObject *obj, void *closure)
9214 {
9215         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9216         PyObject *py_scavtimeout;
9217         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
9218         return py_scavtimeout;
9219 }
9220
9221 static int py_srvsvc_NetSrvInfo503_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
9222 {
9223         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9224         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9225         object->scavtimeout = PyInt_AsLong(value);
9226         return 0;
9227 }
9228
9229 static PyObject *py_srvsvc_NetSrvInfo503_get_minrcvqueue(PyObject *obj, void *closure)
9230 {
9231         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9232         PyObject *py_minrcvqueue;
9233         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
9234         return py_minrcvqueue;
9235 }
9236
9237 static int py_srvsvc_NetSrvInfo503_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
9238 {
9239         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9240         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9241         object->minrcvqueue = PyInt_AsLong(value);
9242         return 0;
9243 }
9244
9245 static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeworkitems(PyObject *obj, void *closure)
9246 {
9247         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9248         PyObject *py_minfreeworkitems;
9249         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
9250         return py_minfreeworkitems;
9251 }
9252
9253 static int py_srvsvc_NetSrvInfo503_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
9254 {
9255         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9256         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9257         object->minfreeworkitems = PyInt_AsLong(value);
9258         return 0;
9259 }
9260
9261 static PyObject *py_srvsvc_NetSrvInfo503_get_xactmemsize(PyObject *obj, void *closure)
9262 {
9263         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9264         PyObject *py_xactmemsize;
9265         py_xactmemsize = PyInt_FromLong(object->xactmemsize);
9266         return py_xactmemsize;
9267 }
9268
9269 static int py_srvsvc_NetSrvInfo503_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
9270 {
9271         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9272         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9273         object->xactmemsize = PyInt_AsLong(value);
9274         return 0;
9275 }
9276
9277 static PyObject *py_srvsvc_NetSrvInfo503_get_threadpriority(PyObject *obj, void *closure)
9278 {
9279         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9280         PyObject *py_threadpriority;
9281         py_threadpriority = PyInt_FromLong(object->threadpriority);
9282         return py_threadpriority;
9283 }
9284
9285 static int py_srvsvc_NetSrvInfo503_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
9286 {
9287         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9288         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9289         object->threadpriority = PyInt_AsLong(value);
9290         return 0;
9291 }
9292
9293 static PyObject *py_srvsvc_NetSrvInfo503_get_maxmpxct(PyObject *obj, void *closure)
9294 {
9295         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9296         PyObject *py_maxmpxct;
9297         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
9298         return py_maxmpxct;
9299 }
9300
9301 static int py_srvsvc_NetSrvInfo503_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
9302 {
9303         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9304         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9305         object->maxmpxct = PyInt_AsLong(value);
9306         return 0;
9307 }
9308
9309 static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakwait(PyObject *obj, void *closure)
9310 {
9311         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9312         PyObject *py_oplockbreakwait;
9313         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
9314         return py_oplockbreakwait;
9315 }
9316
9317 static int py_srvsvc_NetSrvInfo503_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
9318 {
9319         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9320         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9321         object->oplockbreakwait = PyInt_AsLong(value);
9322         return 0;
9323 }
9324
9325 static PyObject *py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait(PyObject *obj, void *closure)
9326 {
9327         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9328         PyObject *py_oplockbreakresponsewait;
9329         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
9330         return py_oplockbreakresponsewait;
9331 }
9332
9333 static int py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
9334 {
9335         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9336         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9337         object->oplockbreakresponsewait = PyInt_AsLong(value);
9338         return 0;
9339 }
9340
9341 static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplocks(PyObject *obj, void *closure)
9342 {
9343         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9344         PyObject *py_enableoplocks;
9345         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
9346         return py_enableoplocks;
9347 }
9348
9349 static int py_srvsvc_NetSrvInfo503_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
9350 {
9351         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9352         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9353         object->enableoplocks = PyInt_AsLong(value);
9354         return 0;
9355 }
9356
9357 static PyObject *py_srvsvc_NetSrvInfo503_get_enableoplockforceclose(PyObject *obj, void *closure)
9358 {
9359         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9360         PyObject *py_enableoplockforceclose;
9361         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
9362         return py_enableoplockforceclose;
9363 }
9364
9365 static int py_srvsvc_NetSrvInfo503_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
9366 {
9367         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9368         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9369         object->enableoplockforceclose = PyInt_AsLong(value);
9370         return 0;
9371 }
9372
9373 static PyObject *py_srvsvc_NetSrvInfo503_get_enablefcbopens(PyObject *obj, void *closure)
9374 {
9375         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9376         PyObject *py_enablefcbopens;
9377         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
9378         return py_enablefcbopens;
9379 }
9380
9381 static int py_srvsvc_NetSrvInfo503_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
9382 {
9383         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9384         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9385         object->enablefcbopens = PyInt_AsLong(value);
9386         return 0;
9387 }
9388
9389 static PyObject *py_srvsvc_NetSrvInfo503_get_enableraw(PyObject *obj, void *closure)
9390 {
9391         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9392         PyObject *py_enableraw;
9393         py_enableraw = PyInt_FromLong(object->enableraw);
9394         return py_enableraw;
9395 }
9396
9397 static int py_srvsvc_NetSrvInfo503_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
9398 {
9399         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9400         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9401         object->enableraw = PyInt_AsLong(value);
9402         return 0;
9403 }
9404
9405 static PyObject *py_srvsvc_NetSrvInfo503_get_enablesharednetdrives(PyObject *obj, void *closure)
9406 {
9407         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9408         PyObject *py_enablesharednetdrives;
9409         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
9410         return py_enablesharednetdrives;
9411 }
9412
9413 static int py_srvsvc_NetSrvInfo503_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
9414 {
9415         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9416         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9417         object->enablesharednetdrives = PyInt_AsLong(value);
9418         return 0;
9419 }
9420
9421 static PyObject *py_srvsvc_NetSrvInfo503_get_minfreeconnections(PyObject *obj, void *closure)
9422 {
9423         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9424         PyObject *py_minfreeconnections;
9425         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
9426         return py_minfreeconnections;
9427 }
9428
9429 static int py_srvsvc_NetSrvInfo503_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
9430 {
9431         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9432         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9433         object->minfreeconnections = PyInt_AsLong(value);
9434         return 0;
9435 }
9436
9437 static PyObject *py_srvsvc_NetSrvInfo503_get_maxfreeconnections(PyObject *obj, void *closure)
9438 {
9439         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(obj);
9440         PyObject *py_maxfreeconnections;
9441         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
9442         return py_maxfreeconnections;
9443 }
9444
9445 static int py_srvsvc_NetSrvInfo503_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
9446 {
9447         struct srvsvc_NetSrvInfo503 *object = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(py_obj);
9448         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9449         object->maxfreeconnections = PyInt_AsLong(value);
9450         return 0;
9451 }
9452
9453 static PyGetSetDef py_srvsvc_NetSrvInfo503_getsetters[] = {
9454         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo503_get_sessopen, py_srvsvc_NetSrvInfo503_set_sessopen },
9455         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo503_get_sesssvc, py_srvsvc_NetSrvInfo503_set_sesssvc },
9456         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo503_get_opensearch, py_srvsvc_NetSrvInfo503_set_opensearch },
9457         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo503_get_sizereqbufs, py_srvsvc_NetSrvInfo503_set_sizereqbufs },
9458         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo503_get_initworkitems, py_srvsvc_NetSrvInfo503_set_initworkitems },
9459         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo503_get_maxworkitems, py_srvsvc_NetSrvInfo503_set_maxworkitems },
9460         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo503_get_rawworkitems, py_srvsvc_NetSrvInfo503_set_rawworkitems },
9461         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo503_get_irpstacksize, py_srvsvc_NetSrvInfo503_set_irpstacksize },
9462         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo503_get_maxrawbuflen, py_srvsvc_NetSrvInfo503_set_maxrawbuflen },
9463         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo503_get_sessusers, py_srvsvc_NetSrvInfo503_set_sessusers },
9464         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo503_get_sessconns, py_srvsvc_NetSrvInfo503_set_sessconns },
9465         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxpagedmemoryusage },
9466         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo503_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo503_set_maxnonpagedmemoryusage },
9467         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo503_get_enablesoftcompat, py_srvsvc_NetSrvInfo503_set_enablesoftcompat },
9468         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo503_get_enableforcedlogoff, py_srvsvc_NetSrvInfo503_set_enableforcedlogoff },
9469         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo503_get_timesource, py_srvsvc_NetSrvInfo503_set_timesource },
9470         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo503_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo503_set_acceptdownlevelapis },
9471         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo503_get_lmannounce, py_srvsvc_NetSrvInfo503_set_lmannounce },
9472         { discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo503_get_domain, py_srvsvc_NetSrvInfo503_set_domain },
9473         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo503_get_maxcopyreadlen, py_srvsvc_NetSrvInfo503_set_maxcopyreadlen },
9474         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo503_get_maxcopywritelen, py_srvsvc_NetSrvInfo503_set_maxcopywritelen },
9475         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo503_get_minkeepsearch, py_srvsvc_NetSrvInfo503_set_minkeepsearch },
9476         { discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepsearch, py_srvsvc_NetSrvInfo503_set_maxkeepsearch },
9477         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_minkeepcomplsearch },
9478         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo503_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo503_set_maxkeepcomplsearch },
9479         { discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo503_get_threadcountadd, py_srvsvc_NetSrvInfo503_set_threadcountadd },
9480         { discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo503_get_numlockthreads, py_srvsvc_NetSrvInfo503_set_numlockthreads },
9481         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo503_get_scavtimeout, py_srvsvc_NetSrvInfo503_set_scavtimeout },
9482         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo503_get_minrcvqueue, py_srvsvc_NetSrvInfo503_set_minrcvqueue },
9483         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo503_get_minfreeworkitems, py_srvsvc_NetSrvInfo503_set_minfreeworkitems },
9484         { discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo503_get_xactmemsize, py_srvsvc_NetSrvInfo503_set_xactmemsize },
9485         { discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo503_get_threadpriority, py_srvsvc_NetSrvInfo503_set_threadpriority },
9486         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo503_get_maxmpxct, py_srvsvc_NetSrvInfo503_set_maxmpxct },
9487         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo503_get_oplockbreakwait, py_srvsvc_NetSrvInfo503_set_oplockbreakwait },
9488         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo503_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo503_set_oplockbreakresponsewait },
9489         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo503_get_enableoplocks, py_srvsvc_NetSrvInfo503_set_enableoplocks },
9490         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo503_get_enableoplockforceclose, py_srvsvc_NetSrvInfo503_set_enableoplockforceclose },
9491         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo503_get_enablefcbopens, py_srvsvc_NetSrvInfo503_set_enablefcbopens },
9492         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo503_get_enableraw, py_srvsvc_NetSrvInfo503_set_enableraw },
9493         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo503_get_enablesharednetdrives, py_srvsvc_NetSrvInfo503_set_enablesharednetdrives },
9494         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo503_get_minfreeconnections, py_srvsvc_NetSrvInfo503_set_minfreeconnections },
9495         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo503_get_maxfreeconnections, py_srvsvc_NetSrvInfo503_set_maxfreeconnections },
9496         { NULL }
9497 };
9498
9499 static PyObject *py_srvsvc_NetSrvInfo503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
9500 {
9501         return pytalloc_new(struct srvsvc_NetSrvInfo503, type);
9502 }
9503
9504
9505 static PyTypeObject srvsvc_NetSrvInfo503_Type = {
9506         PyObject_HEAD_INIT(NULL) 0,
9507         .tp_name = "srvsvc.NetSrvInfo503",
9508         .tp_getset = py_srvsvc_NetSrvInfo503_getsetters,
9509         .tp_methods = NULL,
9510         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
9511         .tp_basicsize = sizeof(pytalloc_Object),
9512         .tp_new = py_srvsvc_NetSrvInfo503_new,
9513 };
9514
9515
9516 static PyObject *py_srvsvc_NetSrvInfo599_get_sessopen(PyObject *obj, void *closure)
9517 {
9518         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9519         PyObject *py_sessopen;
9520         py_sessopen = PyInt_FromLong(object->sessopen);
9521         return py_sessopen;
9522 }
9523
9524 static int py_srvsvc_NetSrvInfo599_set_sessopen(PyObject *py_obj, PyObject *value, void *closure)
9525 {
9526         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9527         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9528         object->sessopen = PyInt_AsLong(value);
9529         return 0;
9530 }
9531
9532 static PyObject *py_srvsvc_NetSrvInfo599_get_sesssvc(PyObject *obj, void *closure)
9533 {
9534         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9535         PyObject *py_sesssvc;
9536         py_sesssvc = PyInt_FromLong(object->sesssvc);
9537         return py_sesssvc;
9538 }
9539
9540 static int py_srvsvc_NetSrvInfo599_set_sesssvc(PyObject *py_obj, PyObject *value, void *closure)
9541 {
9542         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9543         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9544         object->sesssvc = PyInt_AsLong(value);
9545         return 0;
9546 }
9547
9548 static PyObject *py_srvsvc_NetSrvInfo599_get_opensearch(PyObject *obj, void *closure)
9549 {
9550         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9551         PyObject *py_opensearch;
9552         py_opensearch = PyInt_FromLong(object->opensearch);
9553         return py_opensearch;
9554 }
9555
9556 static int py_srvsvc_NetSrvInfo599_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
9557 {
9558         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9559         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9560         object->opensearch = PyInt_AsLong(value);
9561         return 0;
9562 }
9563
9564 static PyObject *py_srvsvc_NetSrvInfo599_get_sizereqbufs(PyObject *obj, void *closure)
9565 {
9566         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9567         PyObject *py_sizereqbufs;
9568         py_sizereqbufs = PyInt_FromLong(object->sizereqbufs);
9569         return py_sizereqbufs;
9570 }
9571
9572 static int py_srvsvc_NetSrvInfo599_set_sizereqbufs(PyObject *py_obj, PyObject *value, void *closure)
9573 {
9574         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9575         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9576         object->sizereqbufs = PyInt_AsLong(value);
9577         return 0;
9578 }
9579
9580 static PyObject *py_srvsvc_NetSrvInfo599_get_initworkitems(PyObject *obj, void *closure)
9581 {
9582         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9583         PyObject *py_initworkitems;
9584         py_initworkitems = PyInt_FromLong(object->initworkitems);
9585         return py_initworkitems;
9586 }
9587
9588 static int py_srvsvc_NetSrvInfo599_set_initworkitems(PyObject *py_obj, PyObject *value, void *closure)
9589 {
9590         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9591         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9592         object->initworkitems = PyInt_AsLong(value);
9593         return 0;
9594 }
9595
9596 static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitems(PyObject *obj, void *closure)
9597 {
9598         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9599         PyObject *py_maxworkitems;
9600         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
9601         return py_maxworkitems;
9602 }
9603
9604 static int py_srvsvc_NetSrvInfo599_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
9605 {
9606         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9607         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9608         object->maxworkitems = PyInt_AsLong(value);
9609         return 0;
9610 }
9611
9612 static PyObject *py_srvsvc_NetSrvInfo599_get_rawworkitems(PyObject *obj, void *closure)
9613 {
9614         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9615         PyObject *py_rawworkitems;
9616         py_rawworkitems = PyInt_FromLong(object->rawworkitems);
9617         return py_rawworkitems;
9618 }
9619
9620 static int py_srvsvc_NetSrvInfo599_set_rawworkitems(PyObject *py_obj, PyObject *value, void *closure)
9621 {
9622         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9623         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9624         object->rawworkitems = PyInt_AsLong(value);
9625         return 0;
9626 }
9627
9628 static PyObject *py_srvsvc_NetSrvInfo599_get_irpstacksize(PyObject *obj, void *closure)
9629 {
9630         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9631         PyObject *py_irpstacksize;
9632         py_irpstacksize = PyInt_FromLong(object->irpstacksize);
9633         return py_irpstacksize;
9634 }
9635
9636 static int py_srvsvc_NetSrvInfo599_set_irpstacksize(PyObject *py_obj, PyObject *value, void *closure)
9637 {
9638         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9639         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9640         object->irpstacksize = PyInt_AsLong(value);
9641         return 0;
9642 }
9643
9644 static PyObject *py_srvsvc_NetSrvInfo599_get_maxrawbuflen(PyObject *obj, void *closure)
9645 {
9646         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9647         PyObject *py_maxrawbuflen;
9648         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
9649         return py_maxrawbuflen;
9650 }
9651
9652 static int py_srvsvc_NetSrvInfo599_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
9653 {
9654         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9655         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9656         object->maxrawbuflen = PyInt_AsLong(value);
9657         return 0;
9658 }
9659
9660 static PyObject *py_srvsvc_NetSrvInfo599_get_sessusers(PyObject *obj, void *closure)
9661 {
9662         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9663         PyObject *py_sessusers;
9664         py_sessusers = PyInt_FromLong(object->sessusers);
9665         return py_sessusers;
9666 }
9667
9668 static int py_srvsvc_NetSrvInfo599_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
9669 {
9670         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9671         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9672         object->sessusers = PyInt_AsLong(value);
9673         return 0;
9674 }
9675
9676 static PyObject *py_srvsvc_NetSrvInfo599_get_sessconns(PyObject *obj, void *closure)
9677 {
9678         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9679         PyObject *py_sessconns;
9680         py_sessconns = PyInt_FromLong(object->sessconns);
9681         return py_sessconns;
9682 }
9683
9684 static int py_srvsvc_NetSrvInfo599_set_sessconns(PyObject *py_obj, PyObject *value, void *closure)
9685 {
9686         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9687         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9688         object->sessconns = PyInt_AsLong(value);
9689         return 0;
9690 }
9691
9692 static PyObject *py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage(PyObject *obj, void *closure)
9693 {
9694         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9695         PyObject *py_maxpagedmemoryusage;
9696         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
9697         return py_maxpagedmemoryusage;
9698 }
9699
9700 static int py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
9701 {
9702         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9703         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9704         object->maxpagedmemoryusage = PyInt_AsLong(value);
9705         return 0;
9706 }
9707
9708 static PyObject *py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
9709 {
9710         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9711         PyObject *py_maxnonpagedmemoryusage;
9712         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
9713         return py_maxnonpagedmemoryusage;
9714 }
9715
9716 static int py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
9717 {
9718         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9719         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9720         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
9721         return 0;
9722 }
9723
9724 static PyObject *py_srvsvc_NetSrvInfo599_get_enablesoftcompat(PyObject *obj, void *closure)
9725 {
9726         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9727         PyObject *py_enablesoftcompat;
9728         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
9729         return py_enablesoftcompat;
9730 }
9731
9732 static int py_srvsvc_NetSrvInfo599_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
9733 {
9734         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9735         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9736         object->enablesoftcompat = PyInt_AsLong(value);
9737         return 0;
9738 }
9739
9740 static PyObject *py_srvsvc_NetSrvInfo599_get_enableforcedlogoff(PyObject *obj, void *closure)
9741 {
9742         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9743         PyObject *py_enableforcedlogoff;
9744         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
9745         return py_enableforcedlogoff;
9746 }
9747
9748 static int py_srvsvc_NetSrvInfo599_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
9749 {
9750         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9751         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9752         object->enableforcedlogoff = PyInt_AsLong(value);
9753         return 0;
9754 }
9755
9756 static PyObject *py_srvsvc_NetSrvInfo599_get_timesource(PyObject *obj, void *closure)
9757 {
9758         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9759         PyObject *py_timesource;
9760         py_timesource = PyInt_FromLong(object->timesource);
9761         return py_timesource;
9762 }
9763
9764 static int py_srvsvc_NetSrvInfo599_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
9765 {
9766         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9767         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9768         object->timesource = PyInt_AsLong(value);
9769         return 0;
9770 }
9771
9772 static PyObject *py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis(PyObject *obj, void *closure)
9773 {
9774         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9775         PyObject *py_acceptdownlevelapis;
9776         py_acceptdownlevelapis = PyInt_FromLong(object->acceptdownlevelapis);
9777         return py_acceptdownlevelapis;
9778 }
9779
9780 static int py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis(PyObject *py_obj, PyObject *value, void *closure)
9781 {
9782         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9783         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9784         object->acceptdownlevelapis = PyInt_AsLong(value);
9785         return 0;
9786 }
9787
9788 static PyObject *py_srvsvc_NetSrvInfo599_get_lmannounce(PyObject *obj, void *closure)
9789 {
9790         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9791         PyObject *py_lmannounce;
9792         py_lmannounce = PyInt_FromLong(object->lmannounce);
9793         return py_lmannounce;
9794 }
9795
9796 static int py_srvsvc_NetSrvInfo599_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
9797 {
9798         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9799         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9800         object->lmannounce = PyInt_AsLong(value);
9801         return 0;
9802 }
9803
9804 static PyObject *py_srvsvc_NetSrvInfo599_get_domain(PyObject *obj, void *closure)
9805 {
9806         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9807         PyObject *py_domain;
9808         if (object->domain == NULL) {
9809                 py_domain = Py_None;
9810                 Py_INCREF(py_domain);
9811         } else {
9812                 if (object->domain == NULL) {
9813                         py_domain = Py_None;
9814                         Py_INCREF(py_domain);
9815                 } else {
9816                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
9817                 }
9818         }
9819         return py_domain;
9820 }
9821
9822 static int py_srvsvc_NetSrvInfo599_set_domain(PyObject *py_obj, PyObject *value, void *closure)
9823 {
9824         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9825         if (value == Py_None) {
9826                 object->domain = NULL;
9827         } else {
9828                 object->domain = NULL;
9829                 if (PyUnicode_Check(value)) {
9830                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
9831                 } else if (PyString_Check(value)) {
9832                         object->domain = PyString_AS_STRING(value);
9833                 } else {
9834                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
9835                         return -1;
9836                 }
9837         }
9838         return 0;
9839 }
9840
9841 static PyObject *py_srvsvc_NetSrvInfo599_get_maxcopyreadlen(PyObject *obj, void *closure)
9842 {
9843         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9844         PyObject *py_maxcopyreadlen;
9845         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
9846         return py_maxcopyreadlen;
9847 }
9848
9849 static int py_srvsvc_NetSrvInfo599_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
9850 {
9851         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9852         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9853         object->maxcopyreadlen = PyInt_AsLong(value);
9854         return 0;
9855 }
9856
9857 static PyObject *py_srvsvc_NetSrvInfo599_get_maxcopywritelen(PyObject *obj, void *closure)
9858 {
9859         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9860         PyObject *py_maxcopywritelen;
9861         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
9862         return py_maxcopywritelen;
9863 }
9864
9865 static int py_srvsvc_NetSrvInfo599_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
9866 {
9867         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9868         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9869         object->maxcopywritelen = PyInt_AsLong(value);
9870         return 0;
9871 }
9872
9873 static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepsearch(PyObject *obj, void *closure)
9874 {
9875         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9876         PyObject *py_minkeepsearch;
9877         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
9878         return py_minkeepsearch;
9879 }
9880
9881 static int py_srvsvc_NetSrvInfo599_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
9882 {
9883         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9884         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9885         object->minkeepsearch = PyInt_AsLong(value);
9886         return 0;
9887 }
9888
9889 static PyObject *py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch(PyObject *obj, void *closure)
9890 {
9891         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9892         PyObject *py_minkeepcomplsearch;
9893         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
9894         return py_minkeepcomplsearch;
9895 }
9896
9897 static int py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9898 {
9899         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9900         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9901         object->minkeepcomplsearch = PyInt_AsLong(value);
9902         return 0;
9903 }
9904
9905 static PyObject *py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch(PyObject *obj, void *closure)
9906 {
9907         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9908         PyObject *py_maxkeepcomplsearch;
9909         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
9910         return py_maxkeepcomplsearch;
9911 }
9912
9913 static int py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
9914 {
9915         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9916         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9917         object->maxkeepcomplsearch = PyInt_AsLong(value);
9918         return 0;
9919 }
9920
9921 static PyObject *py_srvsvc_NetSrvInfo599_get_threadcountadd(PyObject *obj, void *closure)
9922 {
9923         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9924         PyObject *py_threadcountadd;
9925         py_threadcountadd = PyInt_FromLong(object->threadcountadd);
9926         return py_threadcountadd;
9927 }
9928
9929 static int py_srvsvc_NetSrvInfo599_set_threadcountadd(PyObject *py_obj, PyObject *value, void *closure)
9930 {
9931         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9933         object->threadcountadd = PyInt_AsLong(value);
9934         return 0;
9935 }
9936
9937 static PyObject *py_srvsvc_NetSrvInfo599_get_numlockthreads(PyObject *obj, void *closure)
9938 {
9939         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9940         PyObject *py_numlockthreads;
9941         py_numlockthreads = PyInt_FromLong(object->numlockthreads);
9942         return py_numlockthreads;
9943 }
9944
9945 static int py_srvsvc_NetSrvInfo599_set_numlockthreads(PyObject *py_obj, PyObject *value, void *closure)
9946 {
9947         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9948         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9949         object->numlockthreads = PyInt_AsLong(value);
9950         return 0;
9951 }
9952
9953 static PyObject *py_srvsvc_NetSrvInfo599_get_scavtimeout(PyObject *obj, void *closure)
9954 {
9955         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9956         PyObject *py_scavtimeout;
9957         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
9958         return py_scavtimeout;
9959 }
9960
9961 static int py_srvsvc_NetSrvInfo599_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
9962 {
9963         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9964         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9965         object->scavtimeout = PyInt_AsLong(value);
9966         return 0;
9967 }
9968
9969 static PyObject *py_srvsvc_NetSrvInfo599_get_minrcvqueue(PyObject *obj, void *closure)
9970 {
9971         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9972         PyObject *py_minrcvqueue;
9973         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
9974         return py_minrcvqueue;
9975 }
9976
9977 static int py_srvsvc_NetSrvInfo599_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
9978 {
9979         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9980         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9981         object->minrcvqueue = PyInt_AsLong(value);
9982         return 0;
9983 }
9984
9985 static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeworkitems(PyObject *obj, void *closure)
9986 {
9987         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
9988         PyObject *py_minfreeworkitems;
9989         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
9990         return py_minfreeworkitems;
9991 }
9992
9993 static int py_srvsvc_NetSrvInfo599_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
9994 {
9995         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
9996         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
9997         object->minfreeworkitems = PyInt_AsLong(value);
9998         return 0;
9999 }
10000
10001 static PyObject *py_srvsvc_NetSrvInfo599_get_xactmemsize(PyObject *obj, void *closure)
10002 {
10003         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10004         PyObject *py_xactmemsize;
10005         py_xactmemsize = PyInt_FromLong(object->xactmemsize);
10006         return py_xactmemsize;
10007 }
10008
10009 static int py_srvsvc_NetSrvInfo599_set_xactmemsize(PyObject *py_obj, PyObject *value, void *closure)
10010 {
10011         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10012         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10013         object->xactmemsize = PyInt_AsLong(value);
10014         return 0;
10015 }
10016
10017 static PyObject *py_srvsvc_NetSrvInfo599_get_threadpriority(PyObject *obj, void *closure)
10018 {
10019         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10020         PyObject *py_threadpriority;
10021         py_threadpriority = PyInt_FromLong(object->threadpriority);
10022         return py_threadpriority;
10023 }
10024
10025 static int py_srvsvc_NetSrvInfo599_set_threadpriority(PyObject *py_obj, PyObject *value, void *closure)
10026 {
10027         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10028         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10029         object->threadpriority = PyInt_AsLong(value);
10030         return 0;
10031 }
10032
10033 static PyObject *py_srvsvc_NetSrvInfo599_get_maxmpxct(PyObject *obj, void *closure)
10034 {
10035         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10036         PyObject *py_maxmpxct;
10037         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
10038         return py_maxmpxct;
10039 }
10040
10041 static int py_srvsvc_NetSrvInfo599_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
10042 {
10043         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10044         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10045         object->maxmpxct = PyInt_AsLong(value);
10046         return 0;
10047 }
10048
10049 static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakwait(PyObject *obj, void *closure)
10050 {
10051         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10052         PyObject *py_oplockbreakwait;
10053         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
10054         return py_oplockbreakwait;
10055 }
10056
10057 static int py_srvsvc_NetSrvInfo599_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
10058 {
10059         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10060         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10061         object->oplockbreakwait = PyInt_AsLong(value);
10062         return 0;
10063 }
10064
10065 static PyObject *py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait(PyObject *obj, void *closure)
10066 {
10067         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10068         PyObject *py_oplockbreakresponsewait;
10069         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
10070         return py_oplockbreakresponsewait;
10071 }
10072
10073 static int py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
10074 {
10075         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10076         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10077         object->oplockbreakresponsewait = PyInt_AsLong(value);
10078         return 0;
10079 }
10080
10081 static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplocks(PyObject *obj, void *closure)
10082 {
10083         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10084         PyObject *py_enableoplocks;
10085         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
10086         return py_enableoplocks;
10087 }
10088
10089 static int py_srvsvc_NetSrvInfo599_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
10090 {
10091         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10092         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10093         object->enableoplocks = PyInt_AsLong(value);
10094         return 0;
10095 }
10096
10097 static PyObject *py_srvsvc_NetSrvInfo599_get_enableoplockforceclose(PyObject *obj, void *closure)
10098 {
10099         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10100         PyObject *py_enableoplockforceclose;
10101         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
10102         return py_enableoplockforceclose;
10103 }
10104
10105 static int py_srvsvc_NetSrvInfo599_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
10106 {
10107         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10108         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10109         object->enableoplockforceclose = PyInt_AsLong(value);
10110         return 0;
10111 }
10112
10113 static PyObject *py_srvsvc_NetSrvInfo599_get_enablefcbopens(PyObject *obj, void *closure)
10114 {
10115         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10116         PyObject *py_enablefcbopens;
10117         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
10118         return py_enablefcbopens;
10119 }
10120
10121 static int py_srvsvc_NetSrvInfo599_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
10122 {
10123         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10124         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10125         object->enablefcbopens = PyInt_AsLong(value);
10126         return 0;
10127 }
10128
10129 static PyObject *py_srvsvc_NetSrvInfo599_get_enableraw(PyObject *obj, void *closure)
10130 {
10131         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10132         PyObject *py_enableraw;
10133         py_enableraw = PyInt_FromLong(object->enableraw);
10134         return py_enableraw;
10135 }
10136
10137 static int py_srvsvc_NetSrvInfo599_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
10138 {
10139         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10140         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10141         object->enableraw = PyInt_AsLong(value);
10142         return 0;
10143 }
10144
10145 static PyObject *py_srvsvc_NetSrvInfo599_get_enablesharednetdrives(PyObject *obj, void *closure)
10146 {
10147         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10148         PyObject *py_enablesharednetdrives;
10149         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
10150         return py_enablesharednetdrives;
10151 }
10152
10153 static int py_srvsvc_NetSrvInfo599_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
10154 {
10155         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10156         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10157         object->enablesharednetdrives = PyInt_AsLong(value);
10158         return 0;
10159 }
10160
10161 static PyObject *py_srvsvc_NetSrvInfo599_get_minfreeconnections(PyObject *obj, void *closure)
10162 {
10163         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10164         PyObject *py_minfreeconnections;
10165         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
10166         return py_minfreeconnections;
10167 }
10168
10169 static int py_srvsvc_NetSrvInfo599_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
10170 {
10171         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10172         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10173         object->minfreeconnections = PyInt_AsLong(value);
10174         return 0;
10175 }
10176
10177 static PyObject *py_srvsvc_NetSrvInfo599_get_maxfreeconnections(PyObject *obj, void *closure)
10178 {
10179         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10180         PyObject *py_maxfreeconnections;
10181         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
10182         return py_maxfreeconnections;
10183 }
10184
10185 static int py_srvsvc_NetSrvInfo599_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
10186 {
10187         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10188         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10189         object->maxfreeconnections = PyInt_AsLong(value);
10190         return 0;
10191 }
10192
10193 static PyObject *py_srvsvc_NetSrvInfo599_get_initsesstable(PyObject *obj, void *closure)
10194 {
10195         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10196         PyObject *py_initsesstable;
10197         py_initsesstable = PyInt_FromLong(object->initsesstable);
10198         return py_initsesstable;
10199 }
10200
10201 static int py_srvsvc_NetSrvInfo599_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
10202 {
10203         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10204         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10205         object->initsesstable = PyInt_AsLong(value);
10206         return 0;
10207 }
10208
10209 static PyObject *py_srvsvc_NetSrvInfo599_get_initconntable(PyObject *obj, void *closure)
10210 {
10211         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10212         PyObject *py_initconntable;
10213         py_initconntable = PyInt_FromLong(object->initconntable);
10214         return py_initconntable;
10215 }
10216
10217 static int py_srvsvc_NetSrvInfo599_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
10218 {
10219         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10220         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10221         object->initconntable = PyInt_AsLong(value);
10222         return 0;
10223 }
10224
10225 static PyObject *py_srvsvc_NetSrvInfo599_get_initfiletable(PyObject *obj, void *closure)
10226 {
10227         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10228         PyObject *py_initfiletable;
10229         py_initfiletable = PyInt_FromLong(object->initfiletable);
10230         return py_initfiletable;
10231 }
10232
10233 static int py_srvsvc_NetSrvInfo599_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
10234 {
10235         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10236         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10237         object->initfiletable = PyInt_AsLong(value);
10238         return 0;
10239 }
10240
10241 static PyObject *py_srvsvc_NetSrvInfo599_get_initsearchtable(PyObject *obj, void *closure)
10242 {
10243         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10244         PyObject *py_initsearchtable;
10245         py_initsearchtable = PyInt_FromLong(object->initsearchtable);
10246         return py_initsearchtable;
10247 }
10248
10249 static int py_srvsvc_NetSrvInfo599_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
10250 {
10251         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10252         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10253         object->initsearchtable = PyInt_AsLong(value);
10254         return 0;
10255 }
10256
10257 static PyObject *py_srvsvc_NetSrvInfo599_get_alertsched(PyObject *obj, void *closure)
10258 {
10259         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10260         PyObject *py_alertsched;
10261         py_alertsched = PyInt_FromLong(object->alertsched);
10262         return py_alertsched;
10263 }
10264
10265 static int py_srvsvc_NetSrvInfo599_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
10266 {
10267         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10269         object->alertsched = PyInt_AsLong(value);
10270         return 0;
10271 }
10272
10273 static PyObject *py_srvsvc_NetSrvInfo599_get_errortreshold(PyObject *obj, void *closure)
10274 {
10275         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10276         PyObject *py_errortreshold;
10277         py_errortreshold = PyInt_FromLong(object->errortreshold);
10278         return py_errortreshold;
10279 }
10280
10281 static int py_srvsvc_NetSrvInfo599_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
10282 {
10283         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10284         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10285         object->errortreshold = PyInt_AsLong(value);
10286         return 0;
10287 }
10288
10289 static PyObject *py_srvsvc_NetSrvInfo599_get_networkerrortreshold(PyObject *obj, void *closure)
10290 {
10291         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10292         PyObject *py_networkerrortreshold;
10293         py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
10294         return py_networkerrortreshold;
10295 }
10296
10297 static int py_srvsvc_NetSrvInfo599_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
10298 {
10299         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10300         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10301         object->networkerrortreshold = PyInt_AsLong(value);
10302         return 0;
10303 }
10304
10305 static PyObject *py_srvsvc_NetSrvInfo599_get_diskspacetreshold(PyObject *obj, void *closure)
10306 {
10307         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10308         PyObject *py_diskspacetreshold;
10309         py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
10310         return py_diskspacetreshold;
10311 }
10312
10313 static int py_srvsvc_NetSrvInfo599_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
10314 {
10315         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10316         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10317         object->diskspacetreshold = PyInt_AsLong(value);
10318         return 0;
10319 }
10320
10321 static PyObject *py_srvsvc_NetSrvInfo599_get_reserved(PyObject *obj, void *closure)
10322 {
10323         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10324         PyObject *py_reserved;
10325         py_reserved = PyInt_FromLong(object->reserved);
10326         return py_reserved;
10327 }
10328
10329 static int py_srvsvc_NetSrvInfo599_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
10330 {
10331         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10332         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10333         object->reserved = PyInt_AsLong(value);
10334         return 0;
10335 }
10336
10337 static PyObject *py_srvsvc_NetSrvInfo599_get_maxlinkdelay(PyObject *obj, void *closure)
10338 {
10339         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10340         PyObject *py_maxlinkdelay;
10341         py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
10342         return py_maxlinkdelay;
10343 }
10344
10345 static int py_srvsvc_NetSrvInfo599_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
10346 {
10347         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10348         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10349         object->maxlinkdelay = PyInt_AsLong(value);
10350         return 0;
10351 }
10352
10353 static PyObject *py_srvsvc_NetSrvInfo599_get_minlinkthroughput(PyObject *obj, void *closure)
10354 {
10355         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10356         PyObject *py_minlinkthroughput;
10357         py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
10358         return py_minlinkthroughput;
10359 }
10360
10361 static int py_srvsvc_NetSrvInfo599_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
10362 {
10363         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10364         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10365         object->minlinkthroughput = PyInt_AsLong(value);
10366         return 0;
10367 }
10368
10369 static PyObject *py_srvsvc_NetSrvInfo599_get_linkinfovalidtime(PyObject *obj, void *closure)
10370 {
10371         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10372         PyObject *py_linkinfovalidtime;
10373         py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
10374         return py_linkinfovalidtime;
10375 }
10376
10377 static int py_srvsvc_NetSrvInfo599_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
10378 {
10379         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10380         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10381         object->linkinfovalidtime = PyInt_AsLong(value);
10382         return 0;
10383 }
10384
10385 static PyObject *py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
10386 {
10387         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10388         PyObject *py_scavqosinfoupdatetime;
10389         py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
10390         return py_scavqosinfoupdatetime;
10391 }
10392
10393 static int py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
10394 {
10395         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10396         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10397         object->scavqosinfoupdatetime = PyInt_AsLong(value);
10398         return 0;
10399 }
10400
10401 static PyObject *py_srvsvc_NetSrvInfo599_get_maxworkitemidletime(PyObject *obj, void *closure)
10402 {
10403         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(obj);
10404         PyObject *py_maxworkitemidletime;
10405         py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
10406         return py_maxworkitemidletime;
10407 }
10408
10409 static int py_srvsvc_NetSrvInfo599_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
10410 {
10411         struct srvsvc_NetSrvInfo599 *object = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(py_obj);
10412         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10413         object->maxworkitemidletime = PyInt_AsLong(value);
10414         return 0;
10415 }
10416
10417 static PyGetSetDef py_srvsvc_NetSrvInfo599_getsetters[] = {
10418         { discard_const_p(char, "sessopen"), py_srvsvc_NetSrvInfo599_get_sessopen, py_srvsvc_NetSrvInfo599_set_sessopen },
10419         { discard_const_p(char, "sesssvc"), py_srvsvc_NetSrvInfo599_get_sesssvc, py_srvsvc_NetSrvInfo599_set_sesssvc },
10420         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo599_get_opensearch, py_srvsvc_NetSrvInfo599_set_opensearch },
10421         { discard_const_p(char, "sizereqbufs"), py_srvsvc_NetSrvInfo599_get_sizereqbufs, py_srvsvc_NetSrvInfo599_set_sizereqbufs },
10422         { discard_const_p(char, "initworkitems"), py_srvsvc_NetSrvInfo599_get_initworkitems, py_srvsvc_NetSrvInfo599_set_initworkitems },
10423         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo599_get_maxworkitems, py_srvsvc_NetSrvInfo599_set_maxworkitems },
10424         { discard_const_p(char, "rawworkitems"), py_srvsvc_NetSrvInfo599_get_rawworkitems, py_srvsvc_NetSrvInfo599_set_rawworkitems },
10425         { discard_const_p(char, "irpstacksize"), py_srvsvc_NetSrvInfo599_get_irpstacksize, py_srvsvc_NetSrvInfo599_set_irpstacksize },
10426         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo599_get_maxrawbuflen, py_srvsvc_NetSrvInfo599_set_maxrawbuflen },
10427         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo599_get_sessusers, py_srvsvc_NetSrvInfo599_set_sessusers },
10428         { discard_const_p(char, "sessconns"), py_srvsvc_NetSrvInfo599_get_sessconns, py_srvsvc_NetSrvInfo599_set_sessconns },
10429         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxpagedmemoryusage },
10430         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo599_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo599_set_maxnonpagedmemoryusage },
10431         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo599_get_enablesoftcompat, py_srvsvc_NetSrvInfo599_set_enablesoftcompat },
10432         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo599_get_enableforcedlogoff, py_srvsvc_NetSrvInfo599_set_enableforcedlogoff },
10433         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo599_get_timesource, py_srvsvc_NetSrvInfo599_set_timesource },
10434         { discard_const_p(char, "acceptdownlevelapis"), py_srvsvc_NetSrvInfo599_get_acceptdownlevelapis, py_srvsvc_NetSrvInfo599_set_acceptdownlevelapis },
10435         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo599_get_lmannounce, py_srvsvc_NetSrvInfo599_set_lmannounce },
10436         { discard_const_p(char, "domain"), py_srvsvc_NetSrvInfo599_get_domain, py_srvsvc_NetSrvInfo599_set_domain },
10437         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo599_get_maxcopyreadlen, py_srvsvc_NetSrvInfo599_set_maxcopyreadlen },
10438         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo599_get_maxcopywritelen, py_srvsvc_NetSrvInfo599_set_maxcopywritelen },
10439         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo599_get_minkeepsearch, py_srvsvc_NetSrvInfo599_set_minkeepsearch },
10440         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_minkeepcomplsearch },
10441         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo599_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo599_set_maxkeepcomplsearch },
10442         { discard_const_p(char, "threadcountadd"), py_srvsvc_NetSrvInfo599_get_threadcountadd, py_srvsvc_NetSrvInfo599_set_threadcountadd },
10443         { discard_const_p(char, "numlockthreads"), py_srvsvc_NetSrvInfo599_get_numlockthreads, py_srvsvc_NetSrvInfo599_set_numlockthreads },
10444         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo599_get_scavtimeout, py_srvsvc_NetSrvInfo599_set_scavtimeout },
10445         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo599_get_minrcvqueue, py_srvsvc_NetSrvInfo599_set_minrcvqueue },
10446         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo599_get_minfreeworkitems, py_srvsvc_NetSrvInfo599_set_minfreeworkitems },
10447         { discard_const_p(char, "xactmemsize"), py_srvsvc_NetSrvInfo599_get_xactmemsize, py_srvsvc_NetSrvInfo599_set_xactmemsize },
10448         { discard_const_p(char, "threadpriority"), py_srvsvc_NetSrvInfo599_get_threadpriority, py_srvsvc_NetSrvInfo599_set_threadpriority },
10449         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo599_get_maxmpxct, py_srvsvc_NetSrvInfo599_set_maxmpxct },
10450         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo599_get_oplockbreakwait, py_srvsvc_NetSrvInfo599_set_oplockbreakwait },
10451         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo599_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo599_set_oplockbreakresponsewait },
10452         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo599_get_enableoplocks, py_srvsvc_NetSrvInfo599_set_enableoplocks },
10453         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo599_get_enableoplockforceclose, py_srvsvc_NetSrvInfo599_set_enableoplockforceclose },
10454         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo599_get_enablefcbopens, py_srvsvc_NetSrvInfo599_set_enablefcbopens },
10455         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo599_get_enableraw, py_srvsvc_NetSrvInfo599_set_enableraw },
10456         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo599_get_enablesharednetdrives, py_srvsvc_NetSrvInfo599_set_enablesharednetdrives },
10457         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo599_get_minfreeconnections, py_srvsvc_NetSrvInfo599_set_minfreeconnections },
10458         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo599_get_maxfreeconnections, py_srvsvc_NetSrvInfo599_set_maxfreeconnections },
10459         { discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo599_get_initsesstable, py_srvsvc_NetSrvInfo599_set_initsesstable },
10460         { discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo599_get_initconntable, py_srvsvc_NetSrvInfo599_set_initconntable },
10461         { discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo599_get_initfiletable, py_srvsvc_NetSrvInfo599_set_initfiletable },
10462         { discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo599_get_initsearchtable, py_srvsvc_NetSrvInfo599_set_initsearchtable },
10463         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo599_get_alertsched, py_srvsvc_NetSrvInfo599_set_alertsched },
10464         { discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo599_get_errortreshold, py_srvsvc_NetSrvInfo599_set_errortreshold },
10465         { discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo599_get_networkerrortreshold, py_srvsvc_NetSrvInfo599_set_networkerrortreshold },
10466         { discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo599_get_diskspacetreshold, py_srvsvc_NetSrvInfo599_set_diskspacetreshold },
10467         { discard_const_p(char, "reserved"), py_srvsvc_NetSrvInfo599_get_reserved, py_srvsvc_NetSrvInfo599_set_reserved },
10468         { discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo599_get_maxlinkdelay, py_srvsvc_NetSrvInfo599_set_maxlinkdelay },
10469         { discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo599_get_minlinkthroughput, py_srvsvc_NetSrvInfo599_set_minlinkthroughput },
10470         { discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo599_get_linkinfovalidtime, py_srvsvc_NetSrvInfo599_set_linkinfovalidtime },
10471         { discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo599_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo599_set_scavqosinfoupdatetime },
10472         { discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo599_get_maxworkitemidletime, py_srvsvc_NetSrvInfo599_set_maxworkitemidletime },
10473         { NULL }
10474 };
10475
10476 static PyObject *py_srvsvc_NetSrvInfo599_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10477 {
10478         return pytalloc_new(struct srvsvc_NetSrvInfo599, type);
10479 }
10480
10481
10482 static PyTypeObject srvsvc_NetSrvInfo599_Type = {
10483         PyObject_HEAD_INIT(NULL) 0,
10484         .tp_name = "srvsvc.NetSrvInfo599",
10485         .tp_getset = py_srvsvc_NetSrvInfo599_getsetters,
10486         .tp_methods = NULL,
10487         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10488         .tp_basicsize = sizeof(pytalloc_Object),
10489         .tp_new = py_srvsvc_NetSrvInfo599_new,
10490 };
10491
10492
10493 static PyObject *py_srvsvc_NetSrvInfo1005_get_comment(PyObject *obj, void *closure)
10494 {
10495         struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(obj);
10496         PyObject *py_comment;
10497         if (object->comment == NULL) {
10498                 py_comment = Py_None;
10499                 Py_INCREF(py_comment);
10500         } else {
10501                 if (object->comment == NULL) {
10502                         py_comment = Py_None;
10503                         Py_INCREF(py_comment);
10504                 } else {
10505                         py_comment = PyUnicode_Decode(object->comment, strlen(object->comment), "utf-8", "ignore");
10506                 }
10507         }
10508         return py_comment;
10509 }
10510
10511 static int py_srvsvc_NetSrvInfo1005_set_comment(PyObject *py_obj, PyObject *value, void *closure)
10512 {
10513         struct srvsvc_NetSrvInfo1005 *object = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(py_obj);
10514         if (value == Py_None) {
10515                 object->comment = NULL;
10516         } else {
10517                 object->comment = NULL;
10518                 if (PyUnicode_Check(value)) {
10519                         object->comment = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
10520                 } else if (PyString_Check(value)) {
10521                         object->comment = PyString_AS_STRING(value);
10522                 } else {
10523                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
10524                         return -1;
10525                 }
10526         }
10527         return 0;
10528 }
10529
10530 static PyGetSetDef py_srvsvc_NetSrvInfo1005_getsetters[] = {
10531         { discard_const_p(char, "comment"), py_srvsvc_NetSrvInfo1005_get_comment, py_srvsvc_NetSrvInfo1005_set_comment },
10532         { NULL }
10533 };
10534
10535 static PyObject *py_srvsvc_NetSrvInfo1005_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10536 {
10537         return pytalloc_new(struct srvsvc_NetSrvInfo1005, type);
10538 }
10539
10540
10541 static PyTypeObject srvsvc_NetSrvInfo1005_Type = {
10542         PyObject_HEAD_INIT(NULL) 0,
10543         .tp_name = "srvsvc.NetSrvInfo1005",
10544         .tp_getset = py_srvsvc_NetSrvInfo1005_getsetters,
10545         .tp_methods = NULL,
10546         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10547         .tp_basicsize = sizeof(pytalloc_Object),
10548         .tp_new = py_srvsvc_NetSrvInfo1005_new,
10549 };
10550
10551
10552 static PyObject *py_srvsvc_NetSrvInfo1010_get_disc(PyObject *obj, void *closure)
10553 {
10554         struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(obj);
10555         PyObject *py_disc;
10556         py_disc = PyInt_FromLong(object->disc);
10557         return py_disc;
10558 }
10559
10560 static int py_srvsvc_NetSrvInfo1010_set_disc(PyObject *py_obj, PyObject *value, void *closure)
10561 {
10562         struct srvsvc_NetSrvInfo1010 *object = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(py_obj);
10563         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10564         object->disc = PyInt_AsLong(value);
10565         return 0;
10566 }
10567
10568 static PyGetSetDef py_srvsvc_NetSrvInfo1010_getsetters[] = {
10569         { discard_const_p(char, "disc"), py_srvsvc_NetSrvInfo1010_get_disc, py_srvsvc_NetSrvInfo1010_set_disc },
10570         { NULL }
10571 };
10572
10573 static PyObject *py_srvsvc_NetSrvInfo1010_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10574 {
10575         return pytalloc_new(struct srvsvc_NetSrvInfo1010, type);
10576 }
10577
10578
10579 static PyTypeObject srvsvc_NetSrvInfo1010_Type = {
10580         PyObject_HEAD_INIT(NULL) 0,
10581         .tp_name = "srvsvc.NetSrvInfo1010",
10582         .tp_getset = py_srvsvc_NetSrvInfo1010_getsetters,
10583         .tp_methods = NULL,
10584         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10585         .tp_basicsize = sizeof(pytalloc_Object),
10586         .tp_new = py_srvsvc_NetSrvInfo1010_new,
10587 };
10588
10589
10590 static PyObject *py_srvsvc_NetSrvInfo1016_get_hidden(PyObject *obj, void *closure)
10591 {
10592         struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(obj);
10593         PyObject *py_hidden;
10594         py_hidden = PyInt_FromLong(object->hidden);
10595         return py_hidden;
10596 }
10597
10598 static int py_srvsvc_NetSrvInfo1016_set_hidden(PyObject *py_obj, PyObject *value, void *closure)
10599 {
10600         struct srvsvc_NetSrvInfo1016 *object = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(py_obj);
10601         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10602         object->hidden = PyInt_AsLong(value);
10603         return 0;
10604 }
10605
10606 static PyGetSetDef py_srvsvc_NetSrvInfo1016_getsetters[] = {
10607         { discard_const_p(char, "hidden"), py_srvsvc_NetSrvInfo1016_get_hidden, py_srvsvc_NetSrvInfo1016_set_hidden },
10608         { NULL }
10609 };
10610
10611 static PyObject *py_srvsvc_NetSrvInfo1016_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10612 {
10613         return pytalloc_new(struct srvsvc_NetSrvInfo1016, type);
10614 }
10615
10616
10617 static PyTypeObject srvsvc_NetSrvInfo1016_Type = {
10618         PyObject_HEAD_INIT(NULL) 0,
10619         .tp_name = "srvsvc.NetSrvInfo1016",
10620         .tp_getset = py_srvsvc_NetSrvInfo1016_getsetters,
10621         .tp_methods = NULL,
10622         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10623         .tp_basicsize = sizeof(pytalloc_Object),
10624         .tp_new = py_srvsvc_NetSrvInfo1016_new,
10625 };
10626
10627
10628 static PyObject *py_srvsvc_NetSrvInfo1017_get_announce(PyObject *obj, void *closure)
10629 {
10630         struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(obj);
10631         PyObject *py_announce;
10632         py_announce = PyInt_FromLong(object->announce);
10633         return py_announce;
10634 }
10635
10636 static int py_srvsvc_NetSrvInfo1017_set_announce(PyObject *py_obj, PyObject *value, void *closure)
10637 {
10638         struct srvsvc_NetSrvInfo1017 *object = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(py_obj);
10639         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10640         object->announce = PyInt_AsLong(value);
10641         return 0;
10642 }
10643
10644 static PyGetSetDef py_srvsvc_NetSrvInfo1017_getsetters[] = {
10645         { discard_const_p(char, "announce"), py_srvsvc_NetSrvInfo1017_get_announce, py_srvsvc_NetSrvInfo1017_set_announce },
10646         { NULL }
10647 };
10648
10649 static PyObject *py_srvsvc_NetSrvInfo1017_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10650 {
10651         return pytalloc_new(struct srvsvc_NetSrvInfo1017, type);
10652 }
10653
10654
10655 static PyTypeObject srvsvc_NetSrvInfo1017_Type = {
10656         PyObject_HEAD_INIT(NULL) 0,
10657         .tp_name = "srvsvc.NetSrvInfo1017",
10658         .tp_getset = py_srvsvc_NetSrvInfo1017_getsetters,
10659         .tp_methods = NULL,
10660         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10661         .tp_basicsize = sizeof(pytalloc_Object),
10662         .tp_new = py_srvsvc_NetSrvInfo1017_new,
10663 };
10664
10665
10666 static PyObject *py_srvsvc_NetSrvInfo1018_get_anndelta(PyObject *obj, void *closure)
10667 {
10668         struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(obj);
10669         PyObject *py_anndelta;
10670         py_anndelta = PyInt_FromLong(object->anndelta);
10671         return py_anndelta;
10672 }
10673
10674 static int py_srvsvc_NetSrvInfo1018_set_anndelta(PyObject *py_obj, PyObject *value, void *closure)
10675 {
10676         struct srvsvc_NetSrvInfo1018 *object = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(py_obj);
10677         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10678         object->anndelta = PyInt_AsLong(value);
10679         return 0;
10680 }
10681
10682 static PyGetSetDef py_srvsvc_NetSrvInfo1018_getsetters[] = {
10683         { discard_const_p(char, "anndelta"), py_srvsvc_NetSrvInfo1018_get_anndelta, py_srvsvc_NetSrvInfo1018_set_anndelta },
10684         { NULL }
10685 };
10686
10687 static PyObject *py_srvsvc_NetSrvInfo1018_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10688 {
10689         return pytalloc_new(struct srvsvc_NetSrvInfo1018, type);
10690 }
10691
10692
10693 static PyTypeObject srvsvc_NetSrvInfo1018_Type = {
10694         PyObject_HEAD_INIT(NULL) 0,
10695         .tp_name = "srvsvc.NetSrvInfo1018",
10696         .tp_getset = py_srvsvc_NetSrvInfo1018_getsetters,
10697         .tp_methods = NULL,
10698         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10699         .tp_basicsize = sizeof(pytalloc_Object),
10700         .tp_new = py_srvsvc_NetSrvInfo1018_new,
10701 };
10702
10703
10704 static PyObject *py_srvsvc_NetSrvInfo1107_get_users(PyObject *obj, void *closure)
10705 {
10706         struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(obj);
10707         PyObject *py_users;
10708         py_users = PyInt_FromLong(object->users);
10709         return py_users;
10710 }
10711
10712 static int py_srvsvc_NetSrvInfo1107_set_users(PyObject *py_obj, PyObject *value, void *closure)
10713 {
10714         struct srvsvc_NetSrvInfo1107 *object = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(py_obj);
10715         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10716         object->users = PyInt_AsLong(value);
10717         return 0;
10718 }
10719
10720 static PyGetSetDef py_srvsvc_NetSrvInfo1107_getsetters[] = {
10721         { discard_const_p(char, "users"), py_srvsvc_NetSrvInfo1107_get_users, py_srvsvc_NetSrvInfo1107_set_users },
10722         { NULL }
10723 };
10724
10725 static PyObject *py_srvsvc_NetSrvInfo1107_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10726 {
10727         return pytalloc_new(struct srvsvc_NetSrvInfo1107, type);
10728 }
10729
10730
10731 static PyTypeObject srvsvc_NetSrvInfo1107_Type = {
10732         PyObject_HEAD_INIT(NULL) 0,
10733         .tp_name = "srvsvc.NetSrvInfo1107",
10734         .tp_getset = py_srvsvc_NetSrvInfo1107_getsetters,
10735         .tp_methods = NULL,
10736         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10737         .tp_basicsize = sizeof(pytalloc_Object),
10738         .tp_new = py_srvsvc_NetSrvInfo1107_new,
10739 };
10740
10741
10742 static PyObject *py_srvsvc_NetSrvInfo1501_get_sessopens(PyObject *obj, void *closure)
10743 {
10744         struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(obj);
10745         PyObject *py_sessopens;
10746         py_sessopens = PyInt_FromLong(object->sessopens);
10747         return py_sessopens;
10748 }
10749
10750 static int py_srvsvc_NetSrvInfo1501_set_sessopens(PyObject *py_obj, PyObject *value, void *closure)
10751 {
10752         struct srvsvc_NetSrvInfo1501 *object = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(py_obj);
10753         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10754         object->sessopens = PyInt_AsLong(value);
10755         return 0;
10756 }
10757
10758 static PyGetSetDef py_srvsvc_NetSrvInfo1501_getsetters[] = {
10759         { discard_const_p(char, "sessopens"), py_srvsvc_NetSrvInfo1501_get_sessopens, py_srvsvc_NetSrvInfo1501_set_sessopens },
10760         { NULL }
10761 };
10762
10763 static PyObject *py_srvsvc_NetSrvInfo1501_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10764 {
10765         return pytalloc_new(struct srvsvc_NetSrvInfo1501, type);
10766 }
10767
10768
10769 static PyTypeObject srvsvc_NetSrvInfo1501_Type = {
10770         PyObject_HEAD_INIT(NULL) 0,
10771         .tp_name = "srvsvc.NetSrvInfo1501",
10772         .tp_getset = py_srvsvc_NetSrvInfo1501_getsetters,
10773         .tp_methods = NULL,
10774         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10775         .tp_basicsize = sizeof(pytalloc_Object),
10776         .tp_new = py_srvsvc_NetSrvInfo1501_new,
10777 };
10778
10779
10780 static PyObject *py_srvsvc_NetSrvInfo1502_get_sessvcs(PyObject *obj, void *closure)
10781 {
10782         struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(obj);
10783         PyObject *py_sessvcs;
10784         py_sessvcs = PyInt_FromLong(object->sessvcs);
10785         return py_sessvcs;
10786 }
10787
10788 static int py_srvsvc_NetSrvInfo1502_set_sessvcs(PyObject *py_obj, PyObject *value, void *closure)
10789 {
10790         struct srvsvc_NetSrvInfo1502 *object = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(py_obj);
10791         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10792         object->sessvcs = PyInt_AsLong(value);
10793         return 0;
10794 }
10795
10796 static PyGetSetDef py_srvsvc_NetSrvInfo1502_getsetters[] = {
10797         { discard_const_p(char, "sessvcs"), py_srvsvc_NetSrvInfo1502_get_sessvcs, py_srvsvc_NetSrvInfo1502_set_sessvcs },
10798         { NULL }
10799 };
10800
10801 static PyObject *py_srvsvc_NetSrvInfo1502_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10802 {
10803         return pytalloc_new(struct srvsvc_NetSrvInfo1502, type);
10804 }
10805
10806
10807 static PyTypeObject srvsvc_NetSrvInfo1502_Type = {
10808         PyObject_HEAD_INIT(NULL) 0,
10809         .tp_name = "srvsvc.NetSrvInfo1502",
10810         .tp_getset = py_srvsvc_NetSrvInfo1502_getsetters,
10811         .tp_methods = NULL,
10812         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10813         .tp_basicsize = sizeof(pytalloc_Object),
10814         .tp_new = py_srvsvc_NetSrvInfo1502_new,
10815 };
10816
10817
10818 static PyObject *py_srvsvc_NetSrvInfo1503_get_opensearch(PyObject *obj, void *closure)
10819 {
10820         struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(obj);
10821         PyObject *py_opensearch;
10822         py_opensearch = PyInt_FromLong(object->opensearch);
10823         return py_opensearch;
10824 }
10825
10826 static int py_srvsvc_NetSrvInfo1503_set_opensearch(PyObject *py_obj, PyObject *value, void *closure)
10827 {
10828         struct srvsvc_NetSrvInfo1503 *object = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(py_obj);
10829         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10830         object->opensearch = PyInt_AsLong(value);
10831         return 0;
10832 }
10833
10834 static PyGetSetDef py_srvsvc_NetSrvInfo1503_getsetters[] = {
10835         { discard_const_p(char, "opensearch"), py_srvsvc_NetSrvInfo1503_get_opensearch, py_srvsvc_NetSrvInfo1503_set_opensearch },
10836         { NULL }
10837 };
10838
10839 static PyObject *py_srvsvc_NetSrvInfo1503_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10840 {
10841         return pytalloc_new(struct srvsvc_NetSrvInfo1503, type);
10842 }
10843
10844
10845 static PyTypeObject srvsvc_NetSrvInfo1503_Type = {
10846         PyObject_HEAD_INIT(NULL) 0,
10847         .tp_name = "srvsvc.NetSrvInfo1503",
10848         .tp_getset = py_srvsvc_NetSrvInfo1503_getsetters,
10849         .tp_methods = NULL,
10850         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10851         .tp_basicsize = sizeof(pytalloc_Object),
10852         .tp_new = py_srvsvc_NetSrvInfo1503_new,
10853 };
10854
10855
10856 static PyObject *py_srvsvc_NetSrvInfo1506_get_maxworkitems(PyObject *obj, void *closure)
10857 {
10858         struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(obj);
10859         PyObject *py_maxworkitems;
10860         py_maxworkitems = PyInt_FromLong(object->maxworkitems);
10861         return py_maxworkitems;
10862 }
10863
10864 static int py_srvsvc_NetSrvInfo1506_set_maxworkitems(PyObject *py_obj, PyObject *value, void *closure)
10865 {
10866         struct srvsvc_NetSrvInfo1506 *object = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(py_obj);
10867         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10868         object->maxworkitems = PyInt_AsLong(value);
10869         return 0;
10870 }
10871
10872 static PyGetSetDef py_srvsvc_NetSrvInfo1506_getsetters[] = {
10873         { discard_const_p(char, "maxworkitems"), py_srvsvc_NetSrvInfo1506_get_maxworkitems, py_srvsvc_NetSrvInfo1506_set_maxworkitems },
10874         { NULL }
10875 };
10876
10877 static PyObject *py_srvsvc_NetSrvInfo1506_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10878 {
10879         return pytalloc_new(struct srvsvc_NetSrvInfo1506, type);
10880 }
10881
10882
10883 static PyTypeObject srvsvc_NetSrvInfo1506_Type = {
10884         PyObject_HEAD_INIT(NULL) 0,
10885         .tp_name = "srvsvc.NetSrvInfo1506",
10886         .tp_getset = py_srvsvc_NetSrvInfo1506_getsetters,
10887         .tp_methods = NULL,
10888         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10889         .tp_basicsize = sizeof(pytalloc_Object),
10890         .tp_new = py_srvsvc_NetSrvInfo1506_new,
10891 };
10892
10893
10894 static PyObject *py_srvsvc_NetSrvInfo1509_get_maxrawbuflen(PyObject *obj, void *closure)
10895 {
10896         struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(obj);
10897         PyObject *py_maxrawbuflen;
10898         py_maxrawbuflen = PyInt_FromLong(object->maxrawbuflen);
10899         return py_maxrawbuflen;
10900 }
10901
10902 static int py_srvsvc_NetSrvInfo1509_set_maxrawbuflen(PyObject *py_obj, PyObject *value, void *closure)
10903 {
10904         struct srvsvc_NetSrvInfo1509 *object = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(py_obj);
10905         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10906         object->maxrawbuflen = PyInt_AsLong(value);
10907         return 0;
10908 }
10909
10910 static PyGetSetDef py_srvsvc_NetSrvInfo1509_getsetters[] = {
10911         { discard_const_p(char, "maxrawbuflen"), py_srvsvc_NetSrvInfo1509_get_maxrawbuflen, py_srvsvc_NetSrvInfo1509_set_maxrawbuflen },
10912         { NULL }
10913 };
10914
10915 static PyObject *py_srvsvc_NetSrvInfo1509_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10916 {
10917         return pytalloc_new(struct srvsvc_NetSrvInfo1509, type);
10918 }
10919
10920
10921 static PyTypeObject srvsvc_NetSrvInfo1509_Type = {
10922         PyObject_HEAD_INIT(NULL) 0,
10923         .tp_name = "srvsvc.NetSrvInfo1509",
10924         .tp_getset = py_srvsvc_NetSrvInfo1509_getsetters,
10925         .tp_methods = NULL,
10926         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10927         .tp_basicsize = sizeof(pytalloc_Object),
10928         .tp_new = py_srvsvc_NetSrvInfo1509_new,
10929 };
10930
10931
10932 static PyObject *py_srvsvc_NetSrvInfo1510_get_sessusers(PyObject *obj, void *closure)
10933 {
10934         struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(obj);
10935         PyObject *py_sessusers;
10936         py_sessusers = PyInt_FromLong(object->sessusers);
10937         return py_sessusers;
10938 }
10939
10940 static int py_srvsvc_NetSrvInfo1510_set_sessusers(PyObject *py_obj, PyObject *value, void *closure)
10941 {
10942         struct srvsvc_NetSrvInfo1510 *object = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(py_obj);
10943         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10944         object->sessusers = PyInt_AsLong(value);
10945         return 0;
10946 }
10947
10948 static PyGetSetDef py_srvsvc_NetSrvInfo1510_getsetters[] = {
10949         { discard_const_p(char, "sessusers"), py_srvsvc_NetSrvInfo1510_get_sessusers, py_srvsvc_NetSrvInfo1510_set_sessusers },
10950         { NULL }
10951 };
10952
10953 static PyObject *py_srvsvc_NetSrvInfo1510_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10954 {
10955         return pytalloc_new(struct srvsvc_NetSrvInfo1510, type);
10956 }
10957
10958
10959 static PyTypeObject srvsvc_NetSrvInfo1510_Type = {
10960         PyObject_HEAD_INIT(NULL) 0,
10961         .tp_name = "srvsvc.NetSrvInfo1510",
10962         .tp_getset = py_srvsvc_NetSrvInfo1510_getsetters,
10963         .tp_methods = NULL,
10964         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
10965         .tp_basicsize = sizeof(pytalloc_Object),
10966         .tp_new = py_srvsvc_NetSrvInfo1510_new,
10967 };
10968
10969
10970 static PyObject *py_srvsvc_NetSrvInfo1511_get_sesscons(PyObject *obj, void *closure)
10971 {
10972         struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(obj);
10973         PyObject *py_sesscons;
10974         py_sesscons = PyInt_FromLong(object->sesscons);
10975         return py_sesscons;
10976 }
10977
10978 static int py_srvsvc_NetSrvInfo1511_set_sesscons(PyObject *py_obj, PyObject *value, void *closure)
10979 {
10980         struct srvsvc_NetSrvInfo1511 *object = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(py_obj);
10981         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
10982         object->sesscons = PyInt_AsLong(value);
10983         return 0;
10984 }
10985
10986 static PyGetSetDef py_srvsvc_NetSrvInfo1511_getsetters[] = {
10987         { discard_const_p(char, "sesscons"), py_srvsvc_NetSrvInfo1511_get_sesscons, py_srvsvc_NetSrvInfo1511_set_sesscons },
10988         { NULL }
10989 };
10990
10991 static PyObject *py_srvsvc_NetSrvInfo1511_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
10992 {
10993         return pytalloc_new(struct srvsvc_NetSrvInfo1511, type);
10994 }
10995
10996
10997 static PyTypeObject srvsvc_NetSrvInfo1511_Type = {
10998         PyObject_HEAD_INIT(NULL) 0,
10999         .tp_name = "srvsvc.NetSrvInfo1511",
11000         .tp_getset = py_srvsvc_NetSrvInfo1511_getsetters,
11001         .tp_methods = NULL,
11002         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11003         .tp_basicsize = sizeof(pytalloc_Object),
11004         .tp_new = py_srvsvc_NetSrvInfo1511_new,
11005 };
11006
11007
11008 static PyObject *py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage(PyObject *obj, void *closure)
11009 {
11010         struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(obj);
11011         PyObject *py_maxnonpagedmemoryusage;
11012         py_maxnonpagedmemoryusage = PyInt_FromLong(object->maxnonpagedmemoryusage);
11013         return py_maxnonpagedmemoryusage;
11014 }
11015
11016 static int py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
11017 {
11018         struct srvsvc_NetSrvInfo1512 *object = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(py_obj);
11019         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11020         object->maxnonpagedmemoryusage = PyInt_AsLong(value);
11021         return 0;
11022 }
11023
11024 static PyGetSetDef py_srvsvc_NetSrvInfo1512_getsetters[] = {
11025         { discard_const_p(char, "maxnonpagedmemoryusage"), py_srvsvc_NetSrvInfo1512_get_maxnonpagedmemoryusage, py_srvsvc_NetSrvInfo1512_set_maxnonpagedmemoryusage },
11026         { NULL }
11027 };
11028
11029 static PyObject *py_srvsvc_NetSrvInfo1512_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11030 {
11031         return pytalloc_new(struct srvsvc_NetSrvInfo1512, type);
11032 }
11033
11034
11035 static PyTypeObject srvsvc_NetSrvInfo1512_Type = {
11036         PyObject_HEAD_INIT(NULL) 0,
11037         .tp_name = "srvsvc.NetSrvInfo1512",
11038         .tp_getset = py_srvsvc_NetSrvInfo1512_getsetters,
11039         .tp_methods = NULL,
11040         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11041         .tp_basicsize = sizeof(pytalloc_Object),
11042         .tp_new = py_srvsvc_NetSrvInfo1512_new,
11043 };
11044
11045
11046 static PyObject *py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage(PyObject *obj, void *closure)
11047 {
11048         struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(obj);
11049         PyObject *py_maxpagedmemoryusage;
11050         py_maxpagedmemoryusage = PyInt_FromLong(object->maxpagedmemoryusage);
11051         return py_maxpagedmemoryusage;
11052 }
11053
11054 static int py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage(PyObject *py_obj, PyObject *value, void *closure)
11055 {
11056         struct srvsvc_NetSrvInfo1513 *object = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(py_obj);
11057         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11058         object->maxpagedmemoryusage = PyInt_AsLong(value);
11059         return 0;
11060 }
11061
11062 static PyGetSetDef py_srvsvc_NetSrvInfo1513_getsetters[] = {
11063         { discard_const_p(char, "maxpagedmemoryusage"), py_srvsvc_NetSrvInfo1513_get_maxpagedmemoryusage, py_srvsvc_NetSrvInfo1513_set_maxpagedmemoryusage },
11064         { NULL }
11065 };
11066
11067 static PyObject *py_srvsvc_NetSrvInfo1513_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11068 {
11069         return pytalloc_new(struct srvsvc_NetSrvInfo1513, type);
11070 }
11071
11072
11073 static PyTypeObject srvsvc_NetSrvInfo1513_Type = {
11074         PyObject_HEAD_INIT(NULL) 0,
11075         .tp_name = "srvsvc.NetSrvInfo1513",
11076         .tp_getset = py_srvsvc_NetSrvInfo1513_getsetters,
11077         .tp_methods = NULL,
11078         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11079         .tp_basicsize = sizeof(pytalloc_Object),
11080         .tp_new = py_srvsvc_NetSrvInfo1513_new,
11081 };
11082
11083
11084 static PyObject *py_srvsvc_NetSrvInfo1514_get_enablesoftcompat(PyObject *obj, void *closure)
11085 {
11086         struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(obj);
11087         PyObject *py_enablesoftcompat;
11088         py_enablesoftcompat = PyInt_FromLong(object->enablesoftcompat);
11089         return py_enablesoftcompat;
11090 }
11091
11092 static int py_srvsvc_NetSrvInfo1514_set_enablesoftcompat(PyObject *py_obj, PyObject *value, void *closure)
11093 {
11094         struct srvsvc_NetSrvInfo1514 *object = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(py_obj);
11095         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11096         object->enablesoftcompat = PyInt_AsLong(value);
11097         return 0;
11098 }
11099
11100 static PyGetSetDef py_srvsvc_NetSrvInfo1514_getsetters[] = {
11101         { discard_const_p(char, "enablesoftcompat"), py_srvsvc_NetSrvInfo1514_get_enablesoftcompat, py_srvsvc_NetSrvInfo1514_set_enablesoftcompat },
11102         { NULL }
11103 };
11104
11105 static PyObject *py_srvsvc_NetSrvInfo1514_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11106 {
11107         return pytalloc_new(struct srvsvc_NetSrvInfo1514, type);
11108 }
11109
11110
11111 static PyTypeObject srvsvc_NetSrvInfo1514_Type = {
11112         PyObject_HEAD_INIT(NULL) 0,
11113         .tp_name = "srvsvc.NetSrvInfo1514",
11114         .tp_getset = py_srvsvc_NetSrvInfo1514_getsetters,
11115         .tp_methods = NULL,
11116         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11117         .tp_basicsize = sizeof(pytalloc_Object),
11118         .tp_new = py_srvsvc_NetSrvInfo1514_new,
11119 };
11120
11121
11122 static PyObject *py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff(PyObject *obj, void *closure)
11123 {
11124         struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(obj);
11125         PyObject *py_enableforcedlogoff;
11126         py_enableforcedlogoff = PyInt_FromLong(object->enableforcedlogoff);
11127         return py_enableforcedlogoff;
11128 }
11129
11130 static int py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff(PyObject *py_obj, PyObject *value, void *closure)
11131 {
11132         struct srvsvc_NetSrvInfo1515 *object = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(py_obj);
11133         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11134         object->enableforcedlogoff = PyInt_AsLong(value);
11135         return 0;
11136 }
11137
11138 static PyGetSetDef py_srvsvc_NetSrvInfo1515_getsetters[] = {
11139         { discard_const_p(char, "enableforcedlogoff"), py_srvsvc_NetSrvInfo1515_get_enableforcedlogoff, py_srvsvc_NetSrvInfo1515_set_enableforcedlogoff },
11140         { NULL }
11141 };
11142
11143 static PyObject *py_srvsvc_NetSrvInfo1515_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11144 {
11145         return pytalloc_new(struct srvsvc_NetSrvInfo1515, type);
11146 }
11147
11148
11149 static PyTypeObject srvsvc_NetSrvInfo1515_Type = {
11150         PyObject_HEAD_INIT(NULL) 0,
11151         .tp_name = "srvsvc.NetSrvInfo1515",
11152         .tp_getset = py_srvsvc_NetSrvInfo1515_getsetters,
11153         .tp_methods = NULL,
11154         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11155         .tp_basicsize = sizeof(pytalloc_Object),
11156         .tp_new = py_srvsvc_NetSrvInfo1515_new,
11157 };
11158
11159
11160 static PyObject *py_srvsvc_NetSrvInfo1516_get_timesource(PyObject *obj, void *closure)
11161 {
11162         struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(obj);
11163         PyObject *py_timesource;
11164         py_timesource = PyInt_FromLong(object->timesource);
11165         return py_timesource;
11166 }
11167
11168 static int py_srvsvc_NetSrvInfo1516_set_timesource(PyObject *py_obj, PyObject *value, void *closure)
11169 {
11170         struct srvsvc_NetSrvInfo1516 *object = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(py_obj);
11171         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11172         object->timesource = PyInt_AsLong(value);
11173         return 0;
11174 }
11175
11176 static PyGetSetDef py_srvsvc_NetSrvInfo1516_getsetters[] = {
11177         { discard_const_p(char, "timesource"), py_srvsvc_NetSrvInfo1516_get_timesource, py_srvsvc_NetSrvInfo1516_set_timesource },
11178         { NULL }
11179 };
11180
11181 static PyObject *py_srvsvc_NetSrvInfo1516_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11182 {
11183         return pytalloc_new(struct srvsvc_NetSrvInfo1516, type);
11184 }
11185
11186
11187 static PyTypeObject srvsvc_NetSrvInfo1516_Type = {
11188         PyObject_HEAD_INIT(NULL) 0,
11189         .tp_name = "srvsvc.NetSrvInfo1516",
11190         .tp_getset = py_srvsvc_NetSrvInfo1516_getsetters,
11191         .tp_methods = NULL,
11192         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11193         .tp_basicsize = sizeof(pytalloc_Object),
11194         .tp_new = py_srvsvc_NetSrvInfo1516_new,
11195 };
11196
11197
11198 static PyObject *py_srvsvc_NetSrvInfo1518_get_lmannounce(PyObject *obj, void *closure)
11199 {
11200         struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(obj);
11201         PyObject *py_lmannounce;
11202         py_lmannounce = PyInt_FromLong(object->lmannounce);
11203         return py_lmannounce;
11204 }
11205
11206 static int py_srvsvc_NetSrvInfo1518_set_lmannounce(PyObject *py_obj, PyObject *value, void *closure)
11207 {
11208         struct srvsvc_NetSrvInfo1518 *object = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(py_obj);
11209         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11210         object->lmannounce = PyInt_AsLong(value);
11211         return 0;
11212 }
11213
11214 static PyGetSetDef py_srvsvc_NetSrvInfo1518_getsetters[] = {
11215         { discard_const_p(char, "lmannounce"), py_srvsvc_NetSrvInfo1518_get_lmannounce, py_srvsvc_NetSrvInfo1518_set_lmannounce },
11216         { NULL }
11217 };
11218
11219 static PyObject *py_srvsvc_NetSrvInfo1518_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11220 {
11221         return pytalloc_new(struct srvsvc_NetSrvInfo1518, type);
11222 }
11223
11224
11225 static PyTypeObject srvsvc_NetSrvInfo1518_Type = {
11226         PyObject_HEAD_INIT(NULL) 0,
11227         .tp_name = "srvsvc.NetSrvInfo1518",
11228         .tp_getset = py_srvsvc_NetSrvInfo1518_getsetters,
11229         .tp_methods = NULL,
11230         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11231         .tp_basicsize = sizeof(pytalloc_Object),
11232         .tp_new = py_srvsvc_NetSrvInfo1518_new,
11233 };
11234
11235
11236 static PyObject *py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen(PyObject *obj, void *closure)
11237 {
11238         struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(obj);
11239         PyObject *py_maxcopyreadlen;
11240         py_maxcopyreadlen = PyInt_FromLong(object->maxcopyreadlen);
11241         return py_maxcopyreadlen;
11242 }
11243
11244 static int py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen(PyObject *py_obj, PyObject *value, void *closure)
11245 {
11246         struct srvsvc_NetSrvInfo1520 *object = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(py_obj);
11247         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11248         object->maxcopyreadlen = PyInt_AsLong(value);
11249         return 0;
11250 }
11251
11252 static PyGetSetDef py_srvsvc_NetSrvInfo1520_getsetters[] = {
11253         { discard_const_p(char, "maxcopyreadlen"), py_srvsvc_NetSrvInfo1520_get_maxcopyreadlen, py_srvsvc_NetSrvInfo1520_set_maxcopyreadlen },
11254         { NULL }
11255 };
11256
11257 static PyObject *py_srvsvc_NetSrvInfo1520_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11258 {
11259         return pytalloc_new(struct srvsvc_NetSrvInfo1520, type);
11260 }
11261
11262
11263 static PyTypeObject srvsvc_NetSrvInfo1520_Type = {
11264         PyObject_HEAD_INIT(NULL) 0,
11265         .tp_name = "srvsvc.NetSrvInfo1520",
11266         .tp_getset = py_srvsvc_NetSrvInfo1520_getsetters,
11267         .tp_methods = NULL,
11268         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11269         .tp_basicsize = sizeof(pytalloc_Object),
11270         .tp_new = py_srvsvc_NetSrvInfo1520_new,
11271 };
11272
11273
11274 static PyObject *py_srvsvc_NetSrvInfo1521_get_maxcopywritelen(PyObject *obj, void *closure)
11275 {
11276         struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(obj);
11277         PyObject *py_maxcopywritelen;
11278         py_maxcopywritelen = PyInt_FromLong(object->maxcopywritelen);
11279         return py_maxcopywritelen;
11280 }
11281
11282 static int py_srvsvc_NetSrvInfo1521_set_maxcopywritelen(PyObject *py_obj, PyObject *value, void *closure)
11283 {
11284         struct srvsvc_NetSrvInfo1521 *object = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(py_obj);
11285         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11286         object->maxcopywritelen = PyInt_AsLong(value);
11287         return 0;
11288 }
11289
11290 static PyGetSetDef py_srvsvc_NetSrvInfo1521_getsetters[] = {
11291         { discard_const_p(char, "maxcopywritelen"), py_srvsvc_NetSrvInfo1521_get_maxcopywritelen, py_srvsvc_NetSrvInfo1521_set_maxcopywritelen },
11292         { NULL }
11293 };
11294
11295 static PyObject *py_srvsvc_NetSrvInfo1521_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11296 {
11297         return pytalloc_new(struct srvsvc_NetSrvInfo1521, type);
11298 }
11299
11300
11301 static PyTypeObject srvsvc_NetSrvInfo1521_Type = {
11302         PyObject_HEAD_INIT(NULL) 0,
11303         .tp_name = "srvsvc.NetSrvInfo1521",
11304         .tp_getset = py_srvsvc_NetSrvInfo1521_getsetters,
11305         .tp_methods = NULL,
11306         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11307         .tp_basicsize = sizeof(pytalloc_Object),
11308         .tp_new = py_srvsvc_NetSrvInfo1521_new,
11309 };
11310
11311
11312 static PyObject *py_srvsvc_NetSrvInfo1522_get_minkeepsearch(PyObject *obj, void *closure)
11313 {
11314         struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(obj);
11315         PyObject *py_minkeepsearch;
11316         py_minkeepsearch = PyInt_FromLong(object->minkeepsearch);
11317         return py_minkeepsearch;
11318 }
11319
11320 static int py_srvsvc_NetSrvInfo1522_set_minkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
11321 {
11322         struct srvsvc_NetSrvInfo1522 *object = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(py_obj);
11323         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11324         object->minkeepsearch = PyInt_AsLong(value);
11325         return 0;
11326 }
11327
11328 static PyGetSetDef py_srvsvc_NetSrvInfo1522_getsetters[] = {
11329         { discard_const_p(char, "minkeepsearch"), py_srvsvc_NetSrvInfo1522_get_minkeepsearch, py_srvsvc_NetSrvInfo1522_set_minkeepsearch },
11330         { NULL }
11331 };
11332
11333 static PyObject *py_srvsvc_NetSrvInfo1522_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11334 {
11335         return pytalloc_new(struct srvsvc_NetSrvInfo1522, type);
11336 }
11337
11338
11339 static PyTypeObject srvsvc_NetSrvInfo1522_Type = {
11340         PyObject_HEAD_INIT(NULL) 0,
11341         .tp_name = "srvsvc.NetSrvInfo1522",
11342         .tp_getset = py_srvsvc_NetSrvInfo1522_getsetters,
11343         .tp_methods = NULL,
11344         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11345         .tp_basicsize = sizeof(pytalloc_Object),
11346         .tp_new = py_srvsvc_NetSrvInfo1522_new,
11347 };
11348
11349
11350 static PyObject *py_srvsvc_NetSrvInfo1523_get_maxkeepsearch(PyObject *obj, void *closure)
11351 {
11352         struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(obj);
11353         PyObject *py_maxkeepsearch;
11354         py_maxkeepsearch = PyInt_FromLong(object->maxkeepsearch);
11355         return py_maxkeepsearch;
11356 }
11357
11358 static int py_srvsvc_NetSrvInfo1523_set_maxkeepsearch(PyObject *py_obj, PyObject *value, void *closure)
11359 {
11360         struct srvsvc_NetSrvInfo1523 *object = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(py_obj);
11361         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11362         object->maxkeepsearch = PyInt_AsLong(value);
11363         return 0;
11364 }
11365
11366 static PyGetSetDef py_srvsvc_NetSrvInfo1523_getsetters[] = {
11367         { discard_const_p(char, "maxkeepsearch"), py_srvsvc_NetSrvInfo1523_get_maxkeepsearch, py_srvsvc_NetSrvInfo1523_set_maxkeepsearch },
11368         { NULL }
11369 };
11370
11371 static PyObject *py_srvsvc_NetSrvInfo1523_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11372 {
11373         return pytalloc_new(struct srvsvc_NetSrvInfo1523, type);
11374 }
11375
11376
11377 static PyTypeObject srvsvc_NetSrvInfo1523_Type = {
11378         PyObject_HEAD_INIT(NULL) 0,
11379         .tp_name = "srvsvc.NetSrvInfo1523",
11380         .tp_getset = py_srvsvc_NetSrvInfo1523_getsetters,
11381         .tp_methods = NULL,
11382         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11383         .tp_basicsize = sizeof(pytalloc_Object),
11384         .tp_new = py_srvsvc_NetSrvInfo1523_new,
11385 };
11386
11387
11388 static PyObject *py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch(PyObject *obj, void *closure)
11389 {
11390         struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(obj);
11391         PyObject *py_minkeepcomplsearch;
11392         py_minkeepcomplsearch = PyInt_FromLong(object->minkeepcomplsearch);
11393         return py_minkeepcomplsearch;
11394 }
11395
11396 static int py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
11397 {
11398         struct srvsvc_NetSrvInfo1524 *object = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(py_obj);
11399         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11400         object->minkeepcomplsearch = PyInt_AsLong(value);
11401         return 0;
11402 }
11403
11404 static PyGetSetDef py_srvsvc_NetSrvInfo1524_getsetters[] = {
11405         { discard_const_p(char, "minkeepcomplsearch"), py_srvsvc_NetSrvInfo1524_get_minkeepcomplsearch, py_srvsvc_NetSrvInfo1524_set_minkeepcomplsearch },
11406         { NULL }
11407 };
11408
11409 static PyObject *py_srvsvc_NetSrvInfo1524_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11410 {
11411         return pytalloc_new(struct srvsvc_NetSrvInfo1524, type);
11412 }
11413
11414
11415 static PyTypeObject srvsvc_NetSrvInfo1524_Type = {
11416         PyObject_HEAD_INIT(NULL) 0,
11417         .tp_name = "srvsvc.NetSrvInfo1524",
11418         .tp_getset = py_srvsvc_NetSrvInfo1524_getsetters,
11419         .tp_methods = NULL,
11420         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11421         .tp_basicsize = sizeof(pytalloc_Object),
11422         .tp_new = py_srvsvc_NetSrvInfo1524_new,
11423 };
11424
11425
11426 static PyObject *py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch(PyObject *obj, void *closure)
11427 {
11428         struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(obj);
11429         PyObject *py_maxkeepcomplsearch;
11430         py_maxkeepcomplsearch = PyInt_FromLong(object->maxkeepcomplsearch);
11431         return py_maxkeepcomplsearch;
11432 }
11433
11434 static int py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch(PyObject *py_obj, PyObject *value, void *closure)
11435 {
11436         struct srvsvc_NetSrvInfo1525 *object = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(py_obj);
11437         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11438         object->maxkeepcomplsearch = PyInt_AsLong(value);
11439         return 0;
11440 }
11441
11442 static PyGetSetDef py_srvsvc_NetSrvInfo1525_getsetters[] = {
11443         { discard_const_p(char, "maxkeepcomplsearch"), py_srvsvc_NetSrvInfo1525_get_maxkeepcomplsearch, py_srvsvc_NetSrvInfo1525_set_maxkeepcomplsearch },
11444         { NULL }
11445 };
11446
11447 static PyObject *py_srvsvc_NetSrvInfo1525_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11448 {
11449         return pytalloc_new(struct srvsvc_NetSrvInfo1525, type);
11450 }
11451
11452
11453 static PyTypeObject srvsvc_NetSrvInfo1525_Type = {
11454         PyObject_HEAD_INIT(NULL) 0,
11455         .tp_name = "srvsvc.NetSrvInfo1525",
11456         .tp_getset = py_srvsvc_NetSrvInfo1525_getsetters,
11457         .tp_methods = NULL,
11458         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11459         .tp_basicsize = sizeof(pytalloc_Object),
11460         .tp_new = py_srvsvc_NetSrvInfo1525_new,
11461 };
11462
11463
11464 static PyObject *py_srvsvc_NetSrvInfo1528_get_scavtimeout(PyObject *obj, void *closure)
11465 {
11466         struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(obj);
11467         PyObject *py_scavtimeout;
11468         py_scavtimeout = PyInt_FromLong(object->scavtimeout);
11469         return py_scavtimeout;
11470 }
11471
11472 static int py_srvsvc_NetSrvInfo1528_set_scavtimeout(PyObject *py_obj, PyObject *value, void *closure)
11473 {
11474         struct srvsvc_NetSrvInfo1528 *object = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(py_obj);
11475         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11476         object->scavtimeout = PyInt_AsLong(value);
11477         return 0;
11478 }
11479
11480 static PyGetSetDef py_srvsvc_NetSrvInfo1528_getsetters[] = {
11481         { discard_const_p(char, "scavtimeout"), py_srvsvc_NetSrvInfo1528_get_scavtimeout, py_srvsvc_NetSrvInfo1528_set_scavtimeout },
11482         { NULL }
11483 };
11484
11485 static PyObject *py_srvsvc_NetSrvInfo1528_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11486 {
11487         return pytalloc_new(struct srvsvc_NetSrvInfo1528, type);
11488 }
11489
11490
11491 static PyTypeObject srvsvc_NetSrvInfo1528_Type = {
11492         PyObject_HEAD_INIT(NULL) 0,
11493         .tp_name = "srvsvc.NetSrvInfo1528",
11494         .tp_getset = py_srvsvc_NetSrvInfo1528_getsetters,
11495         .tp_methods = NULL,
11496         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11497         .tp_basicsize = sizeof(pytalloc_Object),
11498         .tp_new = py_srvsvc_NetSrvInfo1528_new,
11499 };
11500
11501
11502 static PyObject *py_srvsvc_NetSrvInfo1529_get_minrcvqueue(PyObject *obj, void *closure)
11503 {
11504         struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(obj);
11505         PyObject *py_minrcvqueue;
11506         py_minrcvqueue = PyInt_FromLong(object->minrcvqueue);
11507         return py_minrcvqueue;
11508 }
11509
11510 static int py_srvsvc_NetSrvInfo1529_set_minrcvqueue(PyObject *py_obj, PyObject *value, void *closure)
11511 {
11512         struct srvsvc_NetSrvInfo1529 *object = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(py_obj);
11513         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11514         object->minrcvqueue = PyInt_AsLong(value);
11515         return 0;
11516 }
11517
11518 static PyGetSetDef py_srvsvc_NetSrvInfo1529_getsetters[] = {
11519         { discard_const_p(char, "minrcvqueue"), py_srvsvc_NetSrvInfo1529_get_minrcvqueue, py_srvsvc_NetSrvInfo1529_set_minrcvqueue },
11520         { NULL }
11521 };
11522
11523 static PyObject *py_srvsvc_NetSrvInfo1529_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11524 {
11525         return pytalloc_new(struct srvsvc_NetSrvInfo1529, type);
11526 }
11527
11528
11529 static PyTypeObject srvsvc_NetSrvInfo1529_Type = {
11530         PyObject_HEAD_INIT(NULL) 0,
11531         .tp_name = "srvsvc.NetSrvInfo1529",
11532         .tp_getset = py_srvsvc_NetSrvInfo1529_getsetters,
11533         .tp_methods = NULL,
11534         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11535         .tp_basicsize = sizeof(pytalloc_Object),
11536         .tp_new = py_srvsvc_NetSrvInfo1529_new,
11537 };
11538
11539
11540 static PyObject *py_srvsvc_NetSrvInfo1530_get_minfreeworkitems(PyObject *obj, void *closure)
11541 {
11542         struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(obj);
11543         PyObject *py_minfreeworkitems;
11544         py_minfreeworkitems = PyInt_FromLong(object->minfreeworkitems);
11545         return py_minfreeworkitems;
11546 }
11547
11548 static int py_srvsvc_NetSrvInfo1530_set_minfreeworkitems(PyObject *py_obj, PyObject *value, void *closure)
11549 {
11550         struct srvsvc_NetSrvInfo1530 *object = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(py_obj);
11551         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11552         object->minfreeworkitems = PyInt_AsLong(value);
11553         return 0;
11554 }
11555
11556 static PyGetSetDef py_srvsvc_NetSrvInfo1530_getsetters[] = {
11557         { discard_const_p(char, "minfreeworkitems"), py_srvsvc_NetSrvInfo1530_get_minfreeworkitems, py_srvsvc_NetSrvInfo1530_set_minfreeworkitems },
11558         { NULL }
11559 };
11560
11561 static PyObject *py_srvsvc_NetSrvInfo1530_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11562 {
11563         return pytalloc_new(struct srvsvc_NetSrvInfo1530, type);
11564 }
11565
11566
11567 static PyTypeObject srvsvc_NetSrvInfo1530_Type = {
11568         PyObject_HEAD_INIT(NULL) 0,
11569         .tp_name = "srvsvc.NetSrvInfo1530",
11570         .tp_getset = py_srvsvc_NetSrvInfo1530_getsetters,
11571         .tp_methods = NULL,
11572         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11573         .tp_basicsize = sizeof(pytalloc_Object),
11574         .tp_new = py_srvsvc_NetSrvInfo1530_new,
11575 };
11576
11577
11578 static PyObject *py_srvsvc_NetSrvInfo1533_get_maxmpxct(PyObject *obj, void *closure)
11579 {
11580         struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(obj);
11581         PyObject *py_maxmpxct;
11582         py_maxmpxct = PyInt_FromLong(object->maxmpxct);
11583         return py_maxmpxct;
11584 }
11585
11586 static int py_srvsvc_NetSrvInfo1533_set_maxmpxct(PyObject *py_obj, PyObject *value, void *closure)
11587 {
11588         struct srvsvc_NetSrvInfo1533 *object = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(py_obj);
11589         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11590         object->maxmpxct = PyInt_AsLong(value);
11591         return 0;
11592 }
11593
11594 static PyGetSetDef py_srvsvc_NetSrvInfo1533_getsetters[] = {
11595         { discard_const_p(char, "maxmpxct"), py_srvsvc_NetSrvInfo1533_get_maxmpxct, py_srvsvc_NetSrvInfo1533_set_maxmpxct },
11596         { NULL }
11597 };
11598
11599 static PyObject *py_srvsvc_NetSrvInfo1533_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11600 {
11601         return pytalloc_new(struct srvsvc_NetSrvInfo1533, type);
11602 }
11603
11604
11605 static PyTypeObject srvsvc_NetSrvInfo1533_Type = {
11606         PyObject_HEAD_INIT(NULL) 0,
11607         .tp_name = "srvsvc.NetSrvInfo1533",
11608         .tp_getset = py_srvsvc_NetSrvInfo1533_getsetters,
11609         .tp_methods = NULL,
11610         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11611         .tp_basicsize = sizeof(pytalloc_Object),
11612         .tp_new = py_srvsvc_NetSrvInfo1533_new,
11613 };
11614
11615
11616 static PyObject *py_srvsvc_NetSrvInfo1534_get_oplockbreakwait(PyObject *obj, void *closure)
11617 {
11618         struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(obj);
11619         PyObject *py_oplockbreakwait;
11620         py_oplockbreakwait = PyInt_FromLong(object->oplockbreakwait);
11621         return py_oplockbreakwait;
11622 }
11623
11624 static int py_srvsvc_NetSrvInfo1534_set_oplockbreakwait(PyObject *py_obj, PyObject *value, void *closure)
11625 {
11626         struct srvsvc_NetSrvInfo1534 *object = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(py_obj);
11627         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11628         object->oplockbreakwait = PyInt_AsLong(value);
11629         return 0;
11630 }
11631
11632 static PyGetSetDef py_srvsvc_NetSrvInfo1534_getsetters[] = {
11633         { discard_const_p(char, "oplockbreakwait"), py_srvsvc_NetSrvInfo1534_get_oplockbreakwait, py_srvsvc_NetSrvInfo1534_set_oplockbreakwait },
11634         { NULL }
11635 };
11636
11637 static PyObject *py_srvsvc_NetSrvInfo1534_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11638 {
11639         return pytalloc_new(struct srvsvc_NetSrvInfo1534, type);
11640 }
11641
11642
11643 static PyTypeObject srvsvc_NetSrvInfo1534_Type = {
11644         PyObject_HEAD_INIT(NULL) 0,
11645         .tp_name = "srvsvc.NetSrvInfo1534",
11646         .tp_getset = py_srvsvc_NetSrvInfo1534_getsetters,
11647         .tp_methods = NULL,
11648         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11649         .tp_basicsize = sizeof(pytalloc_Object),
11650         .tp_new = py_srvsvc_NetSrvInfo1534_new,
11651 };
11652
11653
11654 static PyObject *py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait(PyObject *obj, void *closure)
11655 {
11656         struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(obj);
11657         PyObject *py_oplockbreakresponsewait;
11658         py_oplockbreakresponsewait = PyInt_FromLong(object->oplockbreakresponsewait);
11659         return py_oplockbreakresponsewait;
11660 }
11661
11662 static int py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait(PyObject *py_obj, PyObject *value, void *closure)
11663 {
11664         struct srvsvc_NetSrvInfo1535 *object = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(py_obj);
11665         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11666         object->oplockbreakresponsewait = PyInt_AsLong(value);
11667         return 0;
11668 }
11669
11670 static PyGetSetDef py_srvsvc_NetSrvInfo1535_getsetters[] = {
11671         { discard_const_p(char, "oplockbreakresponsewait"), py_srvsvc_NetSrvInfo1535_get_oplockbreakresponsewait, py_srvsvc_NetSrvInfo1535_set_oplockbreakresponsewait },
11672         { NULL }
11673 };
11674
11675 static PyObject *py_srvsvc_NetSrvInfo1535_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11676 {
11677         return pytalloc_new(struct srvsvc_NetSrvInfo1535, type);
11678 }
11679
11680
11681 static PyTypeObject srvsvc_NetSrvInfo1535_Type = {
11682         PyObject_HEAD_INIT(NULL) 0,
11683         .tp_name = "srvsvc.NetSrvInfo1535",
11684         .tp_getset = py_srvsvc_NetSrvInfo1535_getsetters,
11685         .tp_methods = NULL,
11686         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11687         .tp_basicsize = sizeof(pytalloc_Object),
11688         .tp_new = py_srvsvc_NetSrvInfo1535_new,
11689 };
11690
11691
11692 static PyObject *py_srvsvc_NetSrvInfo1536_get_enableoplocks(PyObject *obj, void *closure)
11693 {
11694         struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(obj);
11695         PyObject *py_enableoplocks;
11696         py_enableoplocks = PyInt_FromLong(object->enableoplocks);
11697         return py_enableoplocks;
11698 }
11699
11700 static int py_srvsvc_NetSrvInfo1536_set_enableoplocks(PyObject *py_obj, PyObject *value, void *closure)
11701 {
11702         struct srvsvc_NetSrvInfo1536 *object = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(py_obj);
11703         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11704         object->enableoplocks = PyInt_AsLong(value);
11705         return 0;
11706 }
11707
11708 static PyGetSetDef py_srvsvc_NetSrvInfo1536_getsetters[] = {
11709         { discard_const_p(char, "enableoplocks"), py_srvsvc_NetSrvInfo1536_get_enableoplocks, py_srvsvc_NetSrvInfo1536_set_enableoplocks },
11710         { NULL }
11711 };
11712
11713 static PyObject *py_srvsvc_NetSrvInfo1536_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11714 {
11715         return pytalloc_new(struct srvsvc_NetSrvInfo1536, type);
11716 }
11717
11718
11719 static PyTypeObject srvsvc_NetSrvInfo1536_Type = {
11720         PyObject_HEAD_INIT(NULL) 0,
11721         .tp_name = "srvsvc.NetSrvInfo1536",
11722         .tp_getset = py_srvsvc_NetSrvInfo1536_getsetters,
11723         .tp_methods = NULL,
11724         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11725         .tp_basicsize = sizeof(pytalloc_Object),
11726         .tp_new = py_srvsvc_NetSrvInfo1536_new,
11727 };
11728
11729
11730 static PyObject *py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose(PyObject *obj, void *closure)
11731 {
11732         struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(obj);
11733         PyObject *py_enableoplockforceclose;
11734         py_enableoplockforceclose = PyInt_FromLong(object->enableoplockforceclose);
11735         return py_enableoplockforceclose;
11736 }
11737
11738 static int py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose(PyObject *py_obj, PyObject *value, void *closure)
11739 {
11740         struct srvsvc_NetSrvInfo1537 *object = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(py_obj);
11741         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11742         object->enableoplockforceclose = PyInt_AsLong(value);
11743         return 0;
11744 }
11745
11746 static PyGetSetDef py_srvsvc_NetSrvInfo1537_getsetters[] = {
11747         { discard_const_p(char, "enableoplockforceclose"), py_srvsvc_NetSrvInfo1537_get_enableoplockforceclose, py_srvsvc_NetSrvInfo1537_set_enableoplockforceclose },
11748         { NULL }
11749 };
11750
11751 static PyObject *py_srvsvc_NetSrvInfo1537_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11752 {
11753         return pytalloc_new(struct srvsvc_NetSrvInfo1537, type);
11754 }
11755
11756
11757 static PyTypeObject srvsvc_NetSrvInfo1537_Type = {
11758         PyObject_HEAD_INIT(NULL) 0,
11759         .tp_name = "srvsvc.NetSrvInfo1537",
11760         .tp_getset = py_srvsvc_NetSrvInfo1537_getsetters,
11761         .tp_methods = NULL,
11762         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11763         .tp_basicsize = sizeof(pytalloc_Object),
11764         .tp_new = py_srvsvc_NetSrvInfo1537_new,
11765 };
11766
11767
11768 static PyObject *py_srvsvc_NetSrvInfo1538_get_enablefcbopens(PyObject *obj, void *closure)
11769 {
11770         struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(obj);
11771         PyObject *py_enablefcbopens;
11772         py_enablefcbopens = PyInt_FromLong(object->enablefcbopens);
11773         return py_enablefcbopens;
11774 }
11775
11776 static int py_srvsvc_NetSrvInfo1538_set_enablefcbopens(PyObject *py_obj, PyObject *value, void *closure)
11777 {
11778         struct srvsvc_NetSrvInfo1538 *object = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(py_obj);
11779         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11780         object->enablefcbopens = PyInt_AsLong(value);
11781         return 0;
11782 }
11783
11784 static PyGetSetDef py_srvsvc_NetSrvInfo1538_getsetters[] = {
11785         { discard_const_p(char, "enablefcbopens"), py_srvsvc_NetSrvInfo1538_get_enablefcbopens, py_srvsvc_NetSrvInfo1538_set_enablefcbopens },
11786         { NULL }
11787 };
11788
11789 static PyObject *py_srvsvc_NetSrvInfo1538_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11790 {
11791         return pytalloc_new(struct srvsvc_NetSrvInfo1538, type);
11792 }
11793
11794
11795 static PyTypeObject srvsvc_NetSrvInfo1538_Type = {
11796         PyObject_HEAD_INIT(NULL) 0,
11797         .tp_name = "srvsvc.NetSrvInfo1538",
11798         .tp_getset = py_srvsvc_NetSrvInfo1538_getsetters,
11799         .tp_methods = NULL,
11800         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11801         .tp_basicsize = sizeof(pytalloc_Object),
11802         .tp_new = py_srvsvc_NetSrvInfo1538_new,
11803 };
11804
11805
11806 static PyObject *py_srvsvc_NetSrvInfo1539_get_enableraw(PyObject *obj, void *closure)
11807 {
11808         struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(obj);
11809         PyObject *py_enableraw;
11810         py_enableraw = PyInt_FromLong(object->enableraw);
11811         return py_enableraw;
11812 }
11813
11814 static int py_srvsvc_NetSrvInfo1539_set_enableraw(PyObject *py_obj, PyObject *value, void *closure)
11815 {
11816         struct srvsvc_NetSrvInfo1539 *object = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(py_obj);
11817         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11818         object->enableraw = PyInt_AsLong(value);
11819         return 0;
11820 }
11821
11822 static PyGetSetDef py_srvsvc_NetSrvInfo1539_getsetters[] = {
11823         { discard_const_p(char, "enableraw"), py_srvsvc_NetSrvInfo1539_get_enableraw, py_srvsvc_NetSrvInfo1539_set_enableraw },
11824         { NULL }
11825 };
11826
11827 static PyObject *py_srvsvc_NetSrvInfo1539_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11828 {
11829         return pytalloc_new(struct srvsvc_NetSrvInfo1539, type);
11830 }
11831
11832
11833 static PyTypeObject srvsvc_NetSrvInfo1539_Type = {
11834         PyObject_HEAD_INIT(NULL) 0,
11835         .tp_name = "srvsvc.NetSrvInfo1539",
11836         .tp_getset = py_srvsvc_NetSrvInfo1539_getsetters,
11837         .tp_methods = NULL,
11838         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11839         .tp_basicsize = sizeof(pytalloc_Object),
11840         .tp_new = py_srvsvc_NetSrvInfo1539_new,
11841 };
11842
11843
11844 static PyObject *py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives(PyObject *obj, void *closure)
11845 {
11846         struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(obj);
11847         PyObject *py_enablesharednetdrives;
11848         py_enablesharednetdrives = PyInt_FromLong(object->enablesharednetdrives);
11849         return py_enablesharednetdrives;
11850 }
11851
11852 static int py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives(PyObject *py_obj, PyObject *value, void *closure)
11853 {
11854         struct srvsvc_NetSrvInfo1540 *object = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(py_obj);
11855         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11856         object->enablesharednetdrives = PyInt_AsLong(value);
11857         return 0;
11858 }
11859
11860 static PyGetSetDef py_srvsvc_NetSrvInfo1540_getsetters[] = {
11861         { discard_const_p(char, "enablesharednetdrives"), py_srvsvc_NetSrvInfo1540_get_enablesharednetdrives, py_srvsvc_NetSrvInfo1540_set_enablesharednetdrives },
11862         { NULL }
11863 };
11864
11865 static PyObject *py_srvsvc_NetSrvInfo1540_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11866 {
11867         return pytalloc_new(struct srvsvc_NetSrvInfo1540, type);
11868 }
11869
11870
11871 static PyTypeObject srvsvc_NetSrvInfo1540_Type = {
11872         PyObject_HEAD_INIT(NULL) 0,
11873         .tp_name = "srvsvc.NetSrvInfo1540",
11874         .tp_getset = py_srvsvc_NetSrvInfo1540_getsetters,
11875         .tp_methods = NULL,
11876         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11877         .tp_basicsize = sizeof(pytalloc_Object),
11878         .tp_new = py_srvsvc_NetSrvInfo1540_new,
11879 };
11880
11881
11882 static PyObject *py_srvsvc_NetSrvInfo1541_get_minfreeconnections(PyObject *obj, void *closure)
11883 {
11884         struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(obj);
11885         PyObject *py_minfreeconnections;
11886         py_minfreeconnections = PyInt_FromLong(object->minfreeconnections);
11887         return py_minfreeconnections;
11888 }
11889
11890 static int py_srvsvc_NetSrvInfo1541_set_minfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
11891 {
11892         struct srvsvc_NetSrvInfo1541 *object = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(py_obj);
11893         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11894         object->minfreeconnections = PyInt_AsLong(value);
11895         return 0;
11896 }
11897
11898 static PyGetSetDef py_srvsvc_NetSrvInfo1541_getsetters[] = {
11899         { discard_const_p(char, "minfreeconnections"), py_srvsvc_NetSrvInfo1541_get_minfreeconnections, py_srvsvc_NetSrvInfo1541_set_minfreeconnections },
11900         { NULL }
11901 };
11902
11903 static PyObject *py_srvsvc_NetSrvInfo1541_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11904 {
11905         return pytalloc_new(struct srvsvc_NetSrvInfo1541, type);
11906 }
11907
11908
11909 static PyTypeObject srvsvc_NetSrvInfo1541_Type = {
11910         PyObject_HEAD_INIT(NULL) 0,
11911         .tp_name = "srvsvc.NetSrvInfo1541",
11912         .tp_getset = py_srvsvc_NetSrvInfo1541_getsetters,
11913         .tp_methods = NULL,
11914         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11915         .tp_basicsize = sizeof(pytalloc_Object),
11916         .tp_new = py_srvsvc_NetSrvInfo1541_new,
11917 };
11918
11919
11920 static PyObject *py_srvsvc_NetSrvInfo1542_get_maxfreeconnections(PyObject *obj, void *closure)
11921 {
11922         struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(obj);
11923         PyObject *py_maxfreeconnections;
11924         py_maxfreeconnections = PyInt_FromLong(object->maxfreeconnections);
11925         return py_maxfreeconnections;
11926 }
11927
11928 static int py_srvsvc_NetSrvInfo1542_set_maxfreeconnections(PyObject *py_obj, PyObject *value, void *closure)
11929 {
11930         struct srvsvc_NetSrvInfo1542 *object = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(py_obj);
11931         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11932         object->maxfreeconnections = PyInt_AsLong(value);
11933         return 0;
11934 }
11935
11936 static PyGetSetDef py_srvsvc_NetSrvInfo1542_getsetters[] = {
11937         { discard_const_p(char, "maxfreeconnections"), py_srvsvc_NetSrvInfo1542_get_maxfreeconnections, py_srvsvc_NetSrvInfo1542_set_maxfreeconnections },
11938         { NULL }
11939 };
11940
11941 static PyObject *py_srvsvc_NetSrvInfo1542_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11942 {
11943         return pytalloc_new(struct srvsvc_NetSrvInfo1542, type);
11944 }
11945
11946
11947 static PyTypeObject srvsvc_NetSrvInfo1542_Type = {
11948         PyObject_HEAD_INIT(NULL) 0,
11949         .tp_name = "srvsvc.NetSrvInfo1542",
11950         .tp_getset = py_srvsvc_NetSrvInfo1542_getsetters,
11951         .tp_methods = NULL,
11952         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11953         .tp_basicsize = sizeof(pytalloc_Object),
11954         .tp_new = py_srvsvc_NetSrvInfo1542_new,
11955 };
11956
11957
11958 static PyObject *py_srvsvc_NetSrvInfo1543_get_initsesstable(PyObject *obj, void *closure)
11959 {
11960         struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(obj);
11961         PyObject *py_initsesstable;
11962         py_initsesstable = PyInt_FromLong(object->initsesstable);
11963         return py_initsesstable;
11964 }
11965
11966 static int py_srvsvc_NetSrvInfo1543_set_initsesstable(PyObject *py_obj, PyObject *value, void *closure)
11967 {
11968         struct srvsvc_NetSrvInfo1543 *object = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(py_obj);
11969         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
11970         object->initsesstable = PyInt_AsLong(value);
11971         return 0;
11972 }
11973
11974 static PyGetSetDef py_srvsvc_NetSrvInfo1543_getsetters[] = {
11975         { discard_const_p(char, "initsesstable"), py_srvsvc_NetSrvInfo1543_get_initsesstable, py_srvsvc_NetSrvInfo1543_set_initsesstable },
11976         { NULL }
11977 };
11978
11979 static PyObject *py_srvsvc_NetSrvInfo1543_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
11980 {
11981         return pytalloc_new(struct srvsvc_NetSrvInfo1543, type);
11982 }
11983
11984
11985 static PyTypeObject srvsvc_NetSrvInfo1543_Type = {
11986         PyObject_HEAD_INIT(NULL) 0,
11987         .tp_name = "srvsvc.NetSrvInfo1543",
11988         .tp_getset = py_srvsvc_NetSrvInfo1543_getsetters,
11989         .tp_methods = NULL,
11990         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
11991         .tp_basicsize = sizeof(pytalloc_Object),
11992         .tp_new = py_srvsvc_NetSrvInfo1543_new,
11993 };
11994
11995
11996 static PyObject *py_srvsvc_NetSrvInfo1544_get_initconntable(PyObject *obj, void *closure)
11997 {
11998         struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(obj);
11999         PyObject *py_initconntable;
12000         py_initconntable = PyInt_FromLong(object->initconntable);
12001         return py_initconntable;
12002 }
12003
12004 static int py_srvsvc_NetSrvInfo1544_set_initconntable(PyObject *py_obj, PyObject *value, void *closure)
12005 {
12006         struct srvsvc_NetSrvInfo1544 *object = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(py_obj);
12007         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12008         object->initconntable = PyInt_AsLong(value);
12009         return 0;
12010 }
12011
12012 static PyGetSetDef py_srvsvc_NetSrvInfo1544_getsetters[] = {
12013         { discard_const_p(char, "initconntable"), py_srvsvc_NetSrvInfo1544_get_initconntable, py_srvsvc_NetSrvInfo1544_set_initconntable },
12014         { NULL }
12015 };
12016
12017 static PyObject *py_srvsvc_NetSrvInfo1544_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12018 {
12019         return pytalloc_new(struct srvsvc_NetSrvInfo1544, type);
12020 }
12021
12022
12023 static PyTypeObject srvsvc_NetSrvInfo1544_Type = {
12024         PyObject_HEAD_INIT(NULL) 0,
12025         .tp_name = "srvsvc.NetSrvInfo1544",
12026         .tp_getset = py_srvsvc_NetSrvInfo1544_getsetters,
12027         .tp_methods = NULL,
12028         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12029         .tp_basicsize = sizeof(pytalloc_Object),
12030         .tp_new = py_srvsvc_NetSrvInfo1544_new,
12031 };
12032
12033
12034 static PyObject *py_srvsvc_NetSrvInfo1545_get_initfiletable(PyObject *obj, void *closure)
12035 {
12036         struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(obj);
12037         PyObject *py_initfiletable;
12038         py_initfiletable = PyInt_FromLong(object->initfiletable);
12039         return py_initfiletable;
12040 }
12041
12042 static int py_srvsvc_NetSrvInfo1545_set_initfiletable(PyObject *py_obj, PyObject *value, void *closure)
12043 {
12044         struct srvsvc_NetSrvInfo1545 *object = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(py_obj);
12045         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12046         object->initfiletable = PyInt_AsLong(value);
12047         return 0;
12048 }
12049
12050 static PyGetSetDef py_srvsvc_NetSrvInfo1545_getsetters[] = {
12051         { discard_const_p(char, "initfiletable"), py_srvsvc_NetSrvInfo1545_get_initfiletable, py_srvsvc_NetSrvInfo1545_set_initfiletable },
12052         { NULL }
12053 };
12054
12055 static PyObject *py_srvsvc_NetSrvInfo1545_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12056 {
12057         return pytalloc_new(struct srvsvc_NetSrvInfo1545, type);
12058 }
12059
12060
12061 static PyTypeObject srvsvc_NetSrvInfo1545_Type = {
12062         PyObject_HEAD_INIT(NULL) 0,
12063         .tp_name = "srvsvc.NetSrvInfo1545",
12064         .tp_getset = py_srvsvc_NetSrvInfo1545_getsetters,
12065         .tp_methods = NULL,
12066         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12067         .tp_basicsize = sizeof(pytalloc_Object),
12068         .tp_new = py_srvsvc_NetSrvInfo1545_new,
12069 };
12070
12071
12072 static PyObject *py_srvsvc_NetSrvInfo1546_get_initsearchtable(PyObject *obj, void *closure)
12073 {
12074         struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(obj);
12075         PyObject *py_initsearchtable;
12076         py_initsearchtable = PyInt_FromLong(object->initsearchtable);
12077         return py_initsearchtable;
12078 }
12079
12080 static int py_srvsvc_NetSrvInfo1546_set_initsearchtable(PyObject *py_obj, PyObject *value, void *closure)
12081 {
12082         struct srvsvc_NetSrvInfo1546 *object = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(py_obj);
12083         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12084         object->initsearchtable = PyInt_AsLong(value);
12085         return 0;
12086 }
12087
12088 static PyGetSetDef py_srvsvc_NetSrvInfo1546_getsetters[] = {
12089         { discard_const_p(char, "initsearchtable"), py_srvsvc_NetSrvInfo1546_get_initsearchtable, py_srvsvc_NetSrvInfo1546_set_initsearchtable },
12090         { NULL }
12091 };
12092
12093 static PyObject *py_srvsvc_NetSrvInfo1546_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12094 {
12095         return pytalloc_new(struct srvsvc_NetSrvInfo1546, type);
12096 }
12097
12098
12099 static PyTypeObject srvsvc_NetSrvInfo1546_Type = {
12100         PyObject_HEAD_INIT(NULL) 0,
12101         .tp_name = "srvsvc.NetSrvInfo1546",
12102         .tp_getset = py_srvsvc_NetSrvInfo1546_getsetters,
12103         .tp_methods = NULL,
12104         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12105         .tp_basicsize = sizeof(pytalloc_Object),
12106         .tp_new = py_srvsvc_NetSrvInfo1546_new,
12107 };
12108
12109
12110 static PyObject *py_srvsvc_NetSrvInfo1547_get_alertsched(PyObject *obj, void *closure)
12111 {
12112         struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(obj);
12113         PyObject *py_alertsched;
12114         py_alertsched = PyInt_FromLong(object->alertsched);
12115         return py_alertsched;
12116 }
12117
12118 static int py_srvsvc_NetSrvInfo1547_set_alertsched(PyObject *py_obj, PyObject *value, void *closure)
12119 {
12120         struct srvsvc_NetSrvInfo1547 *object = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(py_obj);
12121         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12122         object->alertsched = PyInt_AsLong(value);
12123         return 0;
12124 }
12125
12126 static PyGetSetDef py_srvsvc_NetSrvInfo1547_getsetters[] = {
12127         { discard_const_p(char, "alertsched"), py_srvsvc_NetSrvInfo1547_get_alertsched, py_srvsvc_NetSrvInfo1547_set_alertsched },
12128         { NULL }
12129 };
12130
12131 static PyObject *py_srvsvc_NetSrvInfo1547_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12132 {
12133         return pytalloc_new(struct srvsvc_NetSrvInfo1547, type);
12134 }
12135
12136
12137 static PyTypeObject srvsvc_NetSrvInfo1547_Type = {
12138         PyObject_HEAD_INIT(NULL) 0,
12139         .tp_name = "srvsvc.NetSrvInfo1547",
12140         .tp_getset = py_srvsvc_NetSrvInfo1547_getsetters,
12141         .tp_methods = NULL,
12142         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12143         .tp_basicsize = sizeof(pytalloc_Object),
12144         .tp_new = py_srvsvc_NetSrvInfo1547_new,
12145 };
12146
12147
12148 static PyObject *py_srvsvc_NetSrvInfo1548_get_errortreshold(PyObject *obj, void *closure)
12149 {
12150         struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(obj);
12151         PyObject *py_errortreshold;
12152         py_errortreshold = PyInt_FromLong(object->errortreshold);
12153         return py_errortreshold;
12154 }
12155
12156 static int py_srvsvc_NetSrvInfo1548_set_errortreshold(PyObject *py_obj, PyObject *value, void *closure)
12157 {
12158         struct srvsvc_NetSrvInfo1548 *object = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(py_obj);
12159         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12160         object->errortreshold = PyInt_AsLong(value);
12161         return 0;
12162 }
12163
12164 static PyGetSetDef py_srvsvc_NetSrvInfo1548_getsetters[] = {
12165         { discard_const_p(char, "errortreshold"), py_srvsvc_NetSrvInfo1548_get_errortreshold, py_srvsvc_NetSrvInfo1548_set_errortreshold },
12166         { NULL }
12167 };
12168
12169 static PyObject *py_srvsvc_NetSrvInfo1548_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12170 {
12171         return pytalloc_new(struct srvsvc_NetSrvInfo1548, type);
12172 }
12173
12174
12175 static PyTypeObject srvsvc_NetSrvInfo1548_Type = {
12176         PyObject_HEAD_INIT(NULL) 0,
12177         .tp_name = "srvsvc.NetSrvInfo1548",
12178         .tp_getset = py_srvsvc_NetSrvInfo1548_getsetters,
12179         .tp_methods = NULL,
12180         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12181         .tp_basicsize = sizeof(pytalloc_Object),
12182         .tp_new = py_srvsvc_NetSrvInfo1548_new,
12183 };
12184
12185
12186 static PyObject *py_srvsvc_NetSrvInfo1549_get_networkerrortreshold(PyObject *obj, void *closure)
12187 {
12188         struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(obj);
12189         PyObject *py_networkerrortreshold;
12190         py_networkerrortreshold = PyInt_FromLong(object->networkerrortreshold);
12191         return py_networkerrortreshold;
12192 }
12193
12194 static int py_srvsvc_NetSrvInfo1549_set_networkerrortreshold(PyObject *py_obj, PyObject *value, void *closure)
12195 {
12196         struct srvsvc_NetSrvInfo1549 *object = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(py_obj);
12197         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12198         object->networkerrortreshold = PyInt_AsLong(value);
12199         return 0;
12200 }
12201
12202 static PyGetSetDef py_srvsvc_NetSrvInfo1549_getsetters[] = {
12203         { discard_const_p(char, "networkerrortreshold"), py_srvsvc_NetSrvInfo1549_get_networkerrortreshold, py_srvsvc_NetSrvInfo1549_set_networkerrortreshold },
12204         { NULL }
12205 };
12206
12207 static PyObject *py_srvsvc_NetSrvInfo1549_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12208 {
12209         return pytalloc_new(struct srvsvc_NetSrvInfo1549, type);
12210 }
12211
12212
12213 static PyTypeObject srvsvc_NetSrvInfo1549_Type = {
12214         PyObject_HEAD_INIT(NULL) 0,
12215         .tp_name = "srvsvc.NetSrvInfo1549",
12216         .tp_getset = py_srvsvc_NetSrvInfo1549_getsetters,
12217         .tp_methods = NULL,
12218         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12219         .tp_basicsize = sizeof(pytalloc_Object),
12220         .tp_new = py_srvsvc_NetSrvInfo1549_new,
12221 };
12222
12223
12224 static PyObject *py_srvsvc_NetSrvInfo1550_get_diskspacetreshold(PyObject *obj, void *closure)
12225 {
12226         struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(obj);
12227         PyObject *py_diskspacetreshold;
12228         py_diskspacetreshold = PyInt_FromLong(object->diskspacetreshold);
12229         return py_diskspacetreshold;
12230 }
12231
12232 static int py_srvsvc_NetSrvInfo1550_set_diskspacetreshold(PyObject *py_obj, PyObject *value, void *closure)
12233 {
12234         struct srvsvc_NetSrvInfo1550 *object = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(py_obj);
12235         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12236         object->diskspacetreshold = PyInt_AsLong(value);
12237         return 0;
12238 }
12239
12240 static PyGetSetDef py_srvsvc_NetSrvInfo1550_getsetters[] = {
12241         { discard_const_p(char, "diskspacetreshold"), py_srvsvc_NetSrvInfo1550_get_diskspacetreshold, py_srvsvc_NetSrvInfo1550_set_diskspacetreshold },
12242         { NULL }
12243 };
12244
12245 static PyObject *py_srvsvc_NetSrvInfo1550_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12246 {
12247         return pytalloc_new(struct srvsvc_NetSrvInfo1550, type);
12248 }
12249
12250
12251 static PyTypeObject srvsvc_NetSrvInfo1550_Type = {
12252         PyObject_HEAD_INIT(NULL) 0,
12253         .tp_name = "srvsvc.NetSrvInfo1550",
12254         .tp_getset = py_srvsvc_NetSrvInfo1550_getsetters,
12255         .tp_methods = NULL,
12256         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12257         .tp_basicsize = sizeof(pytalloc_Object),
12258         .tp_new = py_srvsvc_NetSrvInfo1550_new,
12259 };
12260
12261
12262 static PyObject *py_srvsvc_NetSrvInfo1552_get_maxlinkdelay(PyObject *obj, void *closure)
12263 {
12264         struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(obj);
12265         PyObject *py_maxlinkdelay;
12266         py_maxlinkdelay = PyInt_FromLong(object->maxlinkdelay);
12267         return py_maxlinkdelay;
12268 }
12269
12270 static int py_srvsvc_NetSrvInfo1552_set_maxlinkdelay(PyObject *py_obj, PyObject *value, void *closure)
12271 {
12272         struct srvsvc_NetSrvInfo1552 *object = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(py_obj);
12273         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12274         object->maxlinkdelay = PyInt_AsLong(value);
12275         return 0;
12276 }
12277
12278 static PyGetSetDef py_srvsvc_NetSrvInfo1552_getsetters[] = {
12279         { discard_const_p(char, "maxlinkdelay"), py_srvsvc_NetSrvInfo1552_get_maxlinkdelay, py_srvsvc_NetSrvInfo1552_set_maxlinkdelay },
12280         { NULL }
12281 };
12282
12283 static PyObject *py_srvsvc_NetSrvInfo1552_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12284 {
12285         return pytalloc_new(struct srvsvc_NetSrvInfo1552, type);
12286 }
12287
12288
12289 static PyTypeObject srvsvc_NetSrvInfo1552_Type = {
12290         PyObject_HEAD_INIT(NULL) 0,
12291         .tp_name = "srvsvc.NetSrvInfo1552",
12292         .tp_getset = py_srvsvc_NetSrvInfo1552_getsetters,
12293         .tp_methods = NULL,
12294         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12295         .tp_basicsize = sizeof(pytalloc_Object),
12296         .tp_new = py_srvsvc_NetSrvInfo1552_new,
12297 };
12298
12299
12300 static PyObject *py_srvsvc_NetSrvInfo1553_get_minlinkthroughput(PyObject *obj, void *closure)
12301 {
12302         struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(obj);
12303         PyObject *py_minlinkthroughput;
12304         py_minlinkthroughput = PyInt_FromLong(object->minlinkthroughput);
12305         return py_minlinkthroughput;
12306 }
12307
12308 static int py_srvsvc_NetSrvInfo1553_set_minlinkthroughput(PyObject *py_obj, PyObject *value, void *closure)
12309 {
12310         struct srvsvc_NetSrvInfo1553 *object = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(py_obj);
12311         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12312         object->minlinkthroughput = PyInt_AsLong(value);
12313         return 0;
12314 }
12315
12316 static PyGetSetDef py_srvsvc_NetSrvInfo1553_getsetters[] = {
12317         { discard_const_p(char, "minlinkthroughput"), py_srvsvc_NetSrvInfo1553_get_minlinkthroughput, py_srvsvc_NetSrvInfo1553_set_minlinkthroughput },
12318         { NULL }
12319 };
12320
12321 static PyObject *py_srvsvc_NetSrvInfo1553_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12322 {
12323         return pytalloc_new(struct srvsvc_NetSrvInfo1553, type);
12324 }
12325
12326
12327 static PyTypeObject srvsvc_NetSrvInfo1553_Type = {
12328         PyObject_HEAD_INIT(NULL) 0,
12329         .tp_name = "srvsvc.NetSrvInfo1553",
12330         .tp_getset = py_srvsvc_NetSrvInfo1553_getsetters,
12331         .tp_methods = NULL,
12332         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12333         .tp_basicsize = sizeof(pytalloc_Object),
12334         .tp_new = py_srvsvc_NetSrvInfo1553_new,
12335 };
12336
12337
12338 static PyObject *py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime(PyObject *obj, void *closure)
12339 {
12340         struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(obj);
12341         PyObject *py_linkinfovalidtime;
12342         py_linkinfovalidtime = PyInt_FromLong(object->linkinfovalidtime);
12343         return py_linkinfovalidtime;
12344 }
12345
12346 static int py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime(PyObject *py_obj, PyObject *value, void *closure)
12347 {
12348         struct srvsvc_NetSrvInfo1554 *object = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(py_obj);
12349         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12350         object->linkinfovalidtime = PyInt_AsLong(value);
12351         return 0;
12352 }
12353
12354 static PyGetSetDef py_srvsvc_NetSrvInfo1554_getsetters[] = {
12355         { discard_const_p(char, "linkinfovalidtime"), py_srvsvc_NetSrvInfo1554_get_linkinfovalidtime, py_srvsvc_NetSrvInfo1554_set_linkinfovalidtime },
12356         { NULL }
12357 };
12358
12359 static PyObject *py_srvsvc_NetSrvInfo1554_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12360 {
12361         return pytalloc_new(struct srvsvc_NetSrvInfo1554, type);
12362 }
12363
12364
12365 static PyTypeObject srvsvc_NetSrvInfo1554_Type = {
12366         PyObject_HEAD_INIT(NULL) 0,
12367         .tp_name = "srvsvc.NetSrvInfo1554",
12368         .tp_getset = py_srvsvc_NetSrvInfo1554_getsetters,
12369         .tp_methods = NULL,
12370         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12371         .tp_basicsize = sizeof(pytalloc_Object),
12372         .tp_new = py_srvsvc_NetSrvInfo1554_new,
12373 };
12374
12375
12376 static PyObject *py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime(PyObject *obj, void *closure)
12377 {
12378         struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(obj);
12379         PyObject *py_scavqosinfoupdatetime;
12380         py_scavqosinfoupdatetime = PyInt_FromLong(object->scavqosinfoupdatetime);
12381         return py_scavqosinfoupdatetime;
12382 }
12383
12384 static int py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime(PyObject *py_obj, PyObject *value, void *closure)
12385 {
12386         struct srvsvc_NetSrvInfo1555 *object = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(py_obj);
12387         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12388         object->scavqosinfoupdatetime = PyInt_AsLong(value);
12389         return 0;
12390 }
12391
12392 static PyGetSetDef py_srvsvc_NetSrvInfo1555_getsetters[] = {
12393         { discard_const_p(char, "scavqosinfoupdatetime"), py_srvsvc_NetSrvInfo1555_get_scavqosinfoupdatetime, py_srvsvc_NetSrvInfo1555_set_scavqosinfoupdatetime },
12394         { NULL }
12395 };
12396
12397 static PyObject *py_srvsvc_NetSrvInfo1555_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12398 {
12399         return pytalloc_new(struct srvsvc_NetSrvInfo1555, type);
12400 }
12401
12402
12403 static PyTypeObject srvsvc_NetSrvInfo1555_Type = {
12404         PyObject_HEAD_INIT(NULL) 0,
12405         .tp_name = "srvsvc.NetSrvInfo1555",
12406         .tp_getset = py_srvsvc_NetSrvInfo1555_getsetters,
12407         .tp_methods = NULL,
12408         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12409         .tp_basicsize = sizeof(pytalloc_Object),
12410         .tp_new = py_srvsvc_NetSrvInfo1555_new,
12411 };
12412
12413
12414 static PyObject *py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime(PyObject *obj, void *closure)
12415 {
12416         struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(obj);
12417         PyObject *py_maxworkitemidletime;
12418         py_maxworkitemidletime = PyInt_FromLong(object->maxworkitemidletime);
12419         return py_maxworkitemidletime;
12420 }
12421
12422 static int py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime(PyObject *py_obj, PyObject *value, void *closure)
12423 {
12424         struct srvsvc_NetSrvInfo1556 *object = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(py_obj);
12425         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
12426         object->maxworkitemidletime = PyInt_AsLong(value);
12427         return 0;
12428 }
12429
12430 static PyGetSetDef py_srvsvc_NetSrvInfo1556_getsetters[] = {
12431         { discard_const_p(char, "maxworkitemidletime"), py_srvsvc_NetSrvInfo1556_get_maxworkitemidletime, py_srvsvc_NetSrvInfo1556_set_maxworkitemidletime },
12432         { NULL }
12433 };
12434
12435 static PyObject *py_srvsvc_NetSrvInfo1556_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
12436 {
12437         return pytalloc_new(struct srvsvc_NetSrvInfo1556, type);
12438 }
12439
12440
12441 static PyTypeObject srvsvc_NetSrvInfo1556_Type = {
12442         PyObject_HEAD_INIT(NULL) 0,
12443         .tp_name = "srvsvc.NetSrvInfo1556",
12444         .tp_getset = py_srvsvc_NetSrvInfo1556_getsetters,
12445         .tp_methods = NULL,
12446         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
12447         .tp_basicsize = sizeof(pytalloc_Object),
12448         .tp_new = py_srvsvc_NetSrvInfo1556_new,
12449 };
12450
12451 PyObject *py_import_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetSrvInfo *in)
12452 {
12453         PyObject *ret;
12454
12455         switch (level) {
12456                 case 100:
12457                         if (in->info100 == NULL) {
12458                                 ret = Py_None;
12459                                 Py_INCREF(ret);
12460                         } else {
12461                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo100_Type, in->info100, in->info100);
12462                         }
12463                         return ret;
12464
12465                 case 101:
12466                         if (in->info101 == NULL) {
12467                                 ret = Py_None;
12468                                 Py_INCREF(ret);
12469                         } else {
12470                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo101_Type, in->info101, in->info101);
12471                         }
12472                         return ret;
12473
12474                 case 102:
12475                         if (in->info102 == NULL) {
12476                                 ret = Py_None;
12477                                 Py_INCREF(ret);
12478                         } else {
12479                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo102_Type, in->info102, in->info102);
12480                         }
12481                         return ret;
12482
12483                 case 402:
12484                         if (in->info402 == NULL) {
12485                                 ret = Py_None;
12486                                 Py_INCREF(ret);
12487                         } else {
12488                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo402_Type, in->info402, in->info402);
12489                         }
12490                         return ret;
12491
12492                 case 403:
12493                         if (in->info403 == NULL) {
12494                                 ret = Py_None;
12495                                 Py_INCREF(ret);
12496                         } else {
12497                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo403_Type, in->info403, in->info403);
12498                         }
12499                         return ret;
12500
12501                 case 502:
12502                         if (in->info502 == NULL) {
12503                                 ret = Py_None;
12504                                 Py_INCREF(ret);
12505                         } else {
12506                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo502_Type, in->info502, in->info502);
12507                         }
12508                         return ret;
12509
12510                 case 503:
12511                         if (in->info503 == NULL) {
12512                                 ret = Py_None;
12513                                 Py_INCREF(ret);
12514                         } else {
12515                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo503_Type, in->info503, in->info503);
12516                         }
12517                         return ret;
12518
12519                 case 599:
12520                         if (in->info599 == NULL) {
12521                                 ret = Py_None;
12522                                 Py_INCREF(ret);
12523                         } else {
12524                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo599_Type, in->info599, in->info599);
12525                         }
12526                         return ret;
12527
12528                 case 1005:
12529                         if (in->info1005 == NULL) {
12530                                 ret = Py_None;
12531                                 Py_INCREF(ret);
12532                         } else {
12533                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1005_Type, in->info1005, in->info1005);
12534                         }
12535                         return ret;
12536
12537                 case 1010:
12538                         if (in->info1010 == NULL) {
12539                                 ret = Py_None;
12540                                 Py_INCREF(ret);
12541                         } else {
12542                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1010_Type, in->info1010, in->info1010);
12543                         }
12544                         return ret;
12545
12546                 case 1016:
12547                         if (in->info1016 == NULL) {
12548                                 ret = Py_None;
12549                                 Py_INCREF(ret);
12550                         } else {
12551                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1016_Type, in->info1016, in->info1016);
12552                         }
12553                         return ret;
12554
12555                 case 1017:
12556                         if (in->info1017 == NULL) {
12557                                 ret = Py_None;
12558                                 Py_INCREF(ret);
12559                         } else {
12560                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1017_Type, in->info1017, in->info1017);
12561                         }
12562                         return ret;
12563
12564                 case 1018:
12565                         if (in->info1018 == NULL) {
12566                                 ret = Py_None;
12567                                 Py_INCREF(ret);
12568                         } else {
12569                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1018_Type, in->info1018, in->info1018);
12570                         }
12571                         return ret;
12572
12573                 case 1107:
12574                         if (in->info1107 == NULL) {
12575                                 ret = Py_None;
12576                                 Py_INCREF(ret);
12577                         } else {
12578                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1107_Type, in->info1107, in->info1107);
12579                         }
12580                         return ret;
12581
12582                 case 1501:
12583                         if (in->info1501 == NULL) {
12584                                 ret = Py_None;
12585                                 Py_INCREF(ret);
12586                         } else {
12587                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1501_Type, in->info1501, in->info1501);
12588                         }
12589                         return ret;
12590
12591                 case 1502:
12592                         if (in->info1502 == NULL) {
12593                                 ret = Py_None;
12594                                 Py_INCREF(ret);
12595                         } else {
12596                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1502_Type, in->info1502, in->info1502);
12597                         }
12598                         return ret;
12599
12600                 case 1503:
12601                         if (in->info1503 == NULL) {
12602                                 ret = Py_None;
12603                                 Py_INCREF(ret);
12604                         } else {
12605                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1503_Type, in->info1503, in->info1503);
12606                         }
12607                         return ret;
12608
12609                 case 1506:
12610                         if (in->info1506 == NULL) {
12611                                 ret = Py_None;
12612                                 Py_INCREF(ret);
12613                         } else {
12614                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1506_Type, in->info1506, in->info1506);
12615                         }
12616                         return ret;
12617
12618                 case 1509:
12619                         if (in->info1509 == NULL) {
12620                                 ret = Py_None;
12621                                 Py_INCREF(ret);
12622                         } else {
12623                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1509_Type, in->info1509, in->info1509);
12624                         }
12625                         return ret;
12626
12627                 case 1510:
12628                         if (in->info1510 == NULL) {
12629                                 ret = Py_None;
12630                                 Py_INCREF(ret);
12631                         } else {
12632                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1510_Type, in->info1510, in->info1510);
12633                         }
12634                         return ret;
12635
12636                 case 1511:
12637                         if (in->info1511 == NULL) {
12638                                 ret = Py_None;
12639                                 Py_INCREF(ret);
12640                         } else {
12641                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1511_Type, in->info1511, in->info1511);
12642                         }
12643                         return ret;
12644
12645                 case 1512:
12646                         if (in->info1512 == NULL) {
12647                                 ret = Py_None;
12648                                 Py_INCREF(ret);
12649                         } else {
12650                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1512_Type, in->info1512, in->info1512);
12651                         }
12652                         return ret;
12653
12654                 case 1513:
12655                         if (in->info1513 == NULL) {
12656                                 ret = Py_None;
12657                                 Py_INCREF(ret);
12658                         } else {
12659                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1513_Type, in->info1513, in->info1513);
12660                         }
12661                         return ret;
12662
12663                 case 1514:
12664                         if (in->info1514 == NULL) {
12665                                 ret = Py_None;
12666                                 Py_INCREF(ret);
12667                         } else {
12668                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1514_Type, in->info1514, in->info1514);
12669                         }
12670                         return ret;
12671
12672                 case 1515:
12673                         if (in->info1515 == NULL) {
12674                                 ret = Py_None;
12675                                 Py_INCREF(ret);
12676                         } else {
12677                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1515_Type, in->info1515, in->info1515);
12678                         }
12679                         return ret;
12680
12681                 case 1516:
12682                         if (in->info1516 == NULL) {
12683                                 ret = Py_None;
12684                                 Py_INCREF(ret);
12685                         } else {
12686                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1516_Type, in->info1516, in->info1516);
12687                         }
12688                         return ret;
12689
12690                 case 1518:
12691                         if (in->info1518 == NULL) {
12692                                 ret = Py_None;
12693                                 Py_INCREF(ret);
12694                         } else {
12695                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1518_Type, in->info1518, in->info1518);
12696                         }
12697                         return ret;
12698
12699                 case 1520:
12700                         if (in->info1520 == NULL) {
12701                                 ret = Py_None;
12702                                 Py_INCREF(ret);
12703                         } else {
12704                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1520_Type, in->info1520, in->info1520);
12705                         }
12706                         return ret;
12707
12708                 case 1521:
12709                         if (in->info1521 == NULL) {
12710                                 ret = Py_None;
12711                                 Py_INCREF(ret);
12712                         } else {
12713                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1521_Type, in->info1521, in->info1521);
12714                         }
12715                         return ret;
12716
12717                 case 1522:
12718                         if (in->info1522 == NULL) {
12719                                 ret = Py_None;
12720                                 Py_INCREF(ret);
12721                         } else {
12722                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1522_Type, in->info1522, in->info1522);
12723                         }
12724                         return ret;
12725
12726                 case 1523:
12727                         if (in->info1523 == NULL) {
12728                                 ret = Py_None;
12729                                 Py_INCREF(ret);
12730                         } else {
12731                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1523_Type, in->info1523, in->info1523);
12732                         }
12733                         return ret;
12734
12735                 case 1524:
12736                         if (in->info1524 == NULL) {
12737                                 ret = Py_None;
12738                                 Py_INCREF(ret);
12739                         } else {
12740                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1524_Type, in->info1524, in->info1524);
12741                         }
12742                         return ret;
12743
12744                 case 1525:
12745                         if (in->info1525 == NULL) {
12746                                 ret = Py_None;
12747                                 Py_INCREF(ret);
12748                         } else {
12749                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1525_Type, in->info1525, in->info1525);
12750                         }
12751                         return ret;
12752
12753                 case 1528:
12754                         if (in->info1528 == NULL) {
12755                                 ret = Py_None;
12756                                 Py_INCREF(ret);
12757                         } else {
12758                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1528_Type, in->info1528, in->info1528);
12759                         }
12760                         return ret;
12761
12762                 case 1529:
12763                         if (in->info1529 == NULL) {
12764                                 ret = Py_None;
12765                                 Py_INCREF(ret);
12766                         } else {
12767                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1529_Type, in->info1529, in->info1529);
12768                         }
12769                         return ret;
12770
12771                 case 1530:
12772                         if (in->info1530 == NULL) {
12773                                 ret = Py_None;
12774                                 Py_INCREF(ret);
12775                         } else {
12776                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1530_Type, in->info1530, in->info1530);
12777                         }
12778                         return ret;
12779
12780                 case 1533:
12781                         if (in->info1533 == NULL) {
12782                                 ret = Py_None;
12783                                 Py_INCREF(ret);
12784                         } else {
12785                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1533_Type, in->info1533, in->info1533);
12786                         }
12787                         return ret;
12788
12789                 case 1534:
12790                         if (in->info1534 == NULL) {
12791                                 ret = Py_None;
12792                                 Py_INCREF(ret);
12793                         } else {
12794                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1534_Type, in->info1534, in->info1534);
12795                         }
12796                         return ret;
12797
12798                 case 1535:
12799                         if (in->info1535 == NULL) {
12800                                 ret = Py_None;
12801                                 Py_INCREF(ret);
12802                         } else {
12803                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1535_Type, in->info1535, in->info1535);
12804                         }
12805                         return ret;
12806
12807                 case 1536:
12808                         if (in->info1536 == NULL) {
12809                                 ret = Py_None;
12810                                 Py_INCREF(ret);
12811                         } else {
12812                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1536_Type, in->info1536, in->info1536);
12813                         }
12814                         return ret;
12815
12816                 case 1537:
12817                         if (in->info1537 == NULL) {
12818                                 ret = Py_None;
12819                                 Py_INCREF(ret);
12820                         } else {
12821                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1537_Type, in->info1537, in->info1537);
12822                         }
12823                         return ret;
12824
12825                 case 1538:
12826                         if (in->info1538 == NULL) {
12827                                 ret = Py_None;
12828                                 Py_INCREF(ret);
12829                         } else {
12830                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1538_Type, in->info1538, in->info1538);
12831                         }
12832                         return ret;
12833
12834                 case 1539:
12835                         if (in->info1539 == NULL) {
12836                                 ret = Py_None;
12837                                 Py_INCREF(ret);
12838                         } else {
12839                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1539_Type, in->info1539, in->info1539);
12840                         }
12841                         return ret;
12842
12843                 case 1540:
12844                         if (in->info1540 == NULL) {
12845                                 ret = Py_None;
12846                                 Py_INCREF(ret);
12847                         } else {
12848                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1540_Type, in->info1540, in->info1540);
12849                         }
12850                         return ret;
12851
12852                 case 1541:
12853                         if (in->info1541 == NULL) {
12854                                 ret = Py_None;
12855                                 Py_INCREF(ret);
12856                         } else {
12857                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1541_Type, in->info1541, in->info1541);
12858                         }
12859                         return ret;
12860
12861                 case 1542:
12862                         if (in->info1542 == NULL) {
12863                                 ret = Py_None;
12864                                 Py_INCREF(ret);
12865                         } else {
12866                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1542_Type, in->info1542, in->info1542);
12867                         }
12868                         return ret;
12869
12870                 case 1543:
12871                         if (in->info1543 == NULL) {
12872                                 ret = Py_None;
12873                                 Py_INCREF(ret);
12874                         } else {
12875                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1543_Type, in->info1543, in->info1543);
12876                         }
12877                         return ret;
12878
12879                 case 1544:
12880                         if (in->info1544 == NULL) {
12881                                 ret = Py_None;
12882                                 Py_INCREF(ret);
12883                         } else {
12884                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1544_Type, in->info1544, in->info1544);
12885                         }
12886                         return ret;
12887
12888                 case 1545:
12889                         if (in->info1545 == NULL) {
12890                                 ret = Py_None;
12891                                 Py_INCREF(ret);
12892                         } else {
12893                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1545_Type, in->info1545, in->info1545);
12894                         }
12895                         return ret;
12896
12897                 case 1546:
12898                         if (in->info1546 == NULL) {
12899                                 ret = Py_None;
12900                                 Py_INCREF(ret);
12901                         } else {
12902                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1546_Type, in->info1546, in->info1546);
12903                         }
12904                         return ret;
12905
12906                 case 1547:
12907                         if (in->info1547 == NULL) {
12908                                 ret = Py_None;
12909                                 Py_INCREF(ret);
12910                         } else {
12911                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1547_Type, in->info1547, in->info1547);
12912                         }
12913                         return ret;
12914
12915                 case 1548:
12916                         if (in->info1548 == NULL) {
12917                                 ret = Py_None;
12918                                 Py_INCREF(ret);
12919                         } else {
12920                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1548_Type, in->info1548, in->info1548);
12921                         }
12922                         return ret;
12923
12924                 case 1549:
12925                         if (in->info1549 == NULL) {
12926                                 ret = Py_None;
12927                                 Py_INCREF(ret);
12928                         } else {
12929                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1549_Type, in->info1549, in->info1549);
12930                         }
12931                         return ret;
12932
12933                 case 1550:
12934                         if (in->info1550 == NULL) {
12935                                 ret = Py_None;
12936                                 Py_INCREF(ret);
12937                         } else {
12938                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1550_Type, in->info1550, in->info1550);
12939                         }
12940                         return ret;
12941
12942                 case 1552:
12943                         if (in->info1552 == NULL) {
12944                                 ret = Py_None;
12945                                 Py_INCREF(ret);
12946                         } else {
12947                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1552_Type, in->info1552, in->info1552);
12948                         }
12949                         return ret;
12950
12951                 case 1553:
12952                         if (in->info1553 == NULL) {
12953                                 ret = Py_None;
12954                                 Py_INCREF(ret);
12955                         } else {
12956                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1553_Type, in->info1553, in->info1553);
12957                         }
12958                         return ret;
12959
12960                 case 1554:
12961                         if (in->info1554 == NULL) {
12962                                 ret = Py_None;
12963                                 Py_INCREF(ret);
12964                         } else {
12965                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1554_Type, in->info1554, in->info1554);
12966                         }
12967                         return ret;
12968
12969                 case 1555:
12970                         if (in->info1555 == NULL) {
12971                                 ret = Py_None;
12972                                 Py_INCREF(ret);
12973                         } else {
12974                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1555_Type, in->info1555, in->info1555);
12975                         }
12976                         return ret;
12977
12978                 case 1556:
12979                         if (in->info1556 == NULL) {
12980                                 ret = Py_None;
12981                                 Py_INCREF(ret);
12982                         } else {
12983                                 ret = pytalloc_reference_ex(&srvsvc_NetSrvInfo1556_Type, in->info1556, in->info1556);
12984                         }
12985                         return ret;
12986
12987                 default:
12988                         ret = Py_None;
12989                         Py_INCREF(ret);
12990                         return ret;
12991
12992         }
12993         PyErr_SetString(PyExc_TypeError, "unknown union level");
12994         return NULL;
12995 }
12996
12997 union srvsvc_NetSrvInfo *py_export_srvsvc_NetSrvInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
12998 {
12999         union srvsvc_NetSrvInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetSrvInfo);
13000         switch (level) {
13001                 case 100:
13002                         if (in == Py_None) {
13003                                 ret->info100 = NULL;
13004                         } else {
13005                                 ret->info100 = NULL;
13006                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo100_Type, in, talloc_free(ret); return NULL;);
13007                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13008                                         PyErr_NoMemory();
13009                                         talloc_free(ret); return NULL;
13010                                 }
13011                                 ret->info100 = (struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(in);
13012                         }
13013                         break;
13014
13015                 case 101:
13016                         if (in == Py_None) {
13017                                 ret->info101 = NULL;
13018                         } else {
13019                                 ret->info101 = NULL;
13020                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo101_Type, in, talloc_free(ret); return NULL;);
13021                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13022                                         PyErr_NoMemory();
13023                                         talloc_free(ret); return NULL;
13024                                 }
13025                                 ret->info101 = (struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(in);
13026                         }
13027                         break;
13028
13029                 case 102:
13030                         if (in == Py_None) {
13031                                 ret->info102 = NULL;
13032                         } else {
13033                                 ret->info102 = NULL;
13034                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo102_Type, in, talloc_free(ret); return NULL;);
13035                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13036                                         PyErr_NoMemory();
13037                                         talloc_free(ret); return NULL;
13038                                 }
13039                                 ret->info102 = (struct srvsvc_NetSrvInfo102 *)pytalloc_get_ptr(in);
13040                         }
13041                         break;
13042
13043                 case 402:
13044                         if (in == Py_None) {
13045                                 ret->info402 = NULL;
13046                         } else {
13047                                 ret->info402 = NULL;
13048                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo402_Type, in, talloc_free(ret); return NULL;);
13049                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13050                                         PyErr_NoMemory();
13051                                         talloc_free(ret); return NULL;
13052                                 }
13053                                 ret->info402 = (struct srvsvc_NetSrvInfo402 *)pytalloc_get_ptr(in);
13054                         }
13055                         break;
13056
13057                 case 403:
13058                         if (in == Py_None) {
13059                                 ret->info403 = NULL;
13060                         } else {
13061                                 ret->info403 = NULL;
13062                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo403_Type, in, talloc_free(ret); return NULL;);
13063                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13064                                         PyErr_NoMemory();
13065                                         talloc_free(ret); return NULL;
13066                                 }
13067                                 ret->info403 = (struct srvsvc_NetSrvInfo403 *)pytalloc_get_ptr(in);
13068                         }
13069                         break;
13070
13071                 case 502:
13072                         if (in == Py_None) {
13073                                 ret->info502 = NULL;
13074                         } else {
13075                                 ret->info502 = NULL;
13076                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo502_Type, in, talloc_free(ret); return NULL;);
13077                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13078                                         PyErr_NoMemory();
13079                                         talloc_free(ret); return NULL;
13080                                 }
13081                                 ret->info502 = (struct srvsvc_NetSrvInfo502 *)pytalloc_get_ptr(in);
13082                         }
13083                         break;
13084
13085                 case 503:
13086                         if (in == Py_None) {
13087                                 ret->info503 = NULL;
13088                         } else {
13089                                 ret->info503 = NULL;
13090                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo503_Type, in, talloc_free(ret); return NULL;);
13091                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13092                                         PyErr_NoMemory();
13093                                         talloc_free(ret); return NULL;
13094                                 }
13095                                 ret->info503 = (struct srvsvc_NetSrvInfo503 *)pytalloc_get_ptr(in);
13096                         }
13097                         break;
13098
13099                 case 599:
13100                         if (in == Py_None) {
13101                                 ret->info599 = NULL;
13102                         } else {
13103                                 ret->info599 = NULL;
13104                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo599_Type, in, talloc_free(ret); return NULL;);
13105                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13106                                         PyErr_NoMemory();
13107                                         talloc_free(ret); return NULL;
13108                                 }
13109                                 ret->info599 = (struct srvsvc_NetSrvInfo599 *)pytalloc_get_ptr(in);
13110                         }
13111                         break;
13112
13113                 case 1005:
13114                         if (in == Py_None) {
13115                                 ret->info1005 = NULL;
13116                         } else {
13117                                 ret->info1005 = NULL;
13118                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1005_Type, in, talloc_free(ret); return NULL;);
13119                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13120                                         PyErr_NoMemory();
13121                                         talloc_free(ret); return NULL;
13122                                 }
13123                                 ret->info1005 = (struct srvsvc_NetSrvInfo1005 *)pytalloc_get_ptr(in);
13124                         }
13125                         break;
13126
13127                 case 1010:
13128                         if (in == Py_None) {
13129                                 ret->info1010 = NULL;
13130                         } else {
13131                                 ret->info1010 = NULL;
13132                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1010_Type, in, talloc_free(ret); return NULL;);
13133                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13134                                         PyErr_NoMemory();
13135                                         talloc_free(ret); return NULL;
13136                                 }
13137                                 ret->info1010 = (struct srvsvc_NetSrvInfo1010 *)pytalloc_get_ptr(in);
13138                         }
13139                         break;
13140
13141                 case 1016:
13142                         if (in == Py_None) {
13143                                 ret->info1016 = NULL;
13144                         } else {
13145                                 ret->info1016 = NULL;
13146                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1016_Type, in, talloc_free(ret); return NULL;);
13147                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13148                                         PyErr_NoMemory();
13149                                         talloc_free(ret); return NULL;
13150                                 }
13151                                 ret->info1016 = (struct srvsvc_NetSrvInfo1016 *)pytalloc_get_ptr(in);
13152                         }
13153                         break;
13154
13155                 case 1017:
13156                         if (in == Py_None) {
13157                                 ret->info1017 = NULL;
13158                         } else {
13159                                 ret->info1017 = NULL;
13160                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1017_Type, in, talloc_free(ret); return NULL;);
13161                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13162                                         PyErr_NoMemory();
13163                                         talloc_free(ret); return NULL;
13164                                 }
13165                                 ret->info1017 = (struct srvsvc_NetSrvInfo1017 *)pytalloc_get_ptr(in);
13166                         }
13167                         break;
13168
13169                 case 1018:
13170                         if (in == Py_None) {
13171                                 ret->info1018 = NULL;
13172                         } else {
13173                                 ret->info1018 = NULL;
13174                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1018_Type, in, talloc_free(ret); return NULL;);
13175                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13176                                         PyErr_NoMemory();
13177                                         talloc_free(ret); return NULL;
13178                                 }
13179                                 ret->info1018 = (struct srvsvc_NetSrvInfo1018 *)pytalloc_get_ptr(in);
13180                         }
13181                         break;
13182
13183                 case 1107:
13184                         if (in == Py_None) {
13185                                 ret->info1107 = NULL;
13186                         } else {
13187                                 ret->info1107 = NULL;
13188                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1107_Type, in, talloc_free(ret); return NULL;);
13189                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13190                                         PyErr_NoMemory();
13191                                         talloc_free(ret); return NULL;
13192                                 }
13193                                 ret->info1107 = (struct srvsvc_NetSrvInfo1107 *)pytalloc_get_ptr(in);
13194                         }
13195                         break;
13196
13197                 case 1501:
13198                         if (in == Py_None) {
13199                                 ret->info1501 = NULL;
13200                         } else {
13201                                 ret->info1501 = NULL;
13202                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1501_Type, in, talloc_free(ret); return NULL;);
13203                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13204                                         PyErr_NoMemory();
13205                                         talloc_free(ret); return NULL;
13206                                 }
13207                                 ret->info1501 = (struct srvsvc_NetSrvInfo1501 *)pytalloc_get_ptr(in);
13208                         }
13209                         break;
13210
13211                 case 1502:
13212                         if (in == Py_None) {
13213                                 ret->info1502 = NULL;
13214                         } else {
13215                                 ret->info1502 = NULL;
13216                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1502_Type, in, talloc_free(ret); return NULL;);
13217                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13218                                         PyErr_NoMemory();
13219                                         talloc_free(ret); return NULL;
13220                                 }
13221                                 ret->info1502 = (struct srvsvc_NetSrvInfo1502 *)pytalloc_get_ptr(in);
13222                         }
13223                         break;
13224
13225                 case 1503:
13226                         if (in == Py_None) {
13227                                 ret->info1503 = NULL;
13228                         } else {
13229                                 ret->info1503 = NULL;
13230                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1503_Type, in, talloc_free(ret); return NULL;);
13231                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13232                                         PyErr_NoMemory();
13233                                         talloc_free(ret); return NULL;
13234                                 }
13235                                 ret->info1503 = (struct srvsvc_NetSrvInfo1503 *)pytalloc_get_ptr(in);
13236                         }
13237                         break;
13238
13239                 case 1506:
13240                         if (in == Py_None) {
13241                                 ret->info1506 = NULL;
13242                         } else {
13243                                 ret->info1506 = NULL;
13244                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1506_Type, in, talloc_free(ret); return NULL;);
13245                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13246                                         PyErr_NoMemory();
13247                                         talloc_free(ret); return NULL;
13248                                 }
13249                                 ret->info1506 = (struct srvsvc_NetSrvInfo1506 *)pytalloc_get_ptr(in);
13250                         }
13251                         break;
13252
13253                 case 1509:
13254                         if (in == Py_None) {
13255                                 ret->info1509 = NULL;
13256                         } else {
13257                                 ret->info1509 = NULL;
13258                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1509_Type, in, talloc_free(ret); return NULL;);
13259                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13260                                         PyErr_NoMemory();
13261                                         talloc_free(ret); return NULL;
13262                                 }
13263                                 ret->info1509 = (struct srvsvc_NetSrvInfo1509 *)pytalloc_get_ptr(in);
13264                         }
13265                         break;
13266
13267                 case 1510:
13268                         if (in == Py_None) {
13269                                 ret->info1510 = NULL;
13270                         } else {
13271                                 ret->info1510 = NULL;
13272                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1510_Type, in, talloc_free(ret); return NULL;);
13273                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13274                                         PyErr_NoMemory();
13275                                         talloc_free(ret); return NULL;
13276                                 }
13277                                 ret->info1510 = (struct srvsvc_NetSrvInfo1510 *)pytalloc_get_ptr(in);
13278                         }
13279                         break;
13280
13281                 case 1511:
13282                         if (in == Py_None) {
13283                                 ret->info1511 = NULL;
13284                         } else {
13285                                 ret->info1511 = NULL;
13286                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1511_Type, in, talloc_free(ret); return NULL;);
13287                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13288                                         PyErr_NoMemory();
13289                                         talloc_free(ret); return NULL;
13290                                 }
13291                                 ret->info1511 = (struct srvsvc_NetSrvInfo1511 *)pytalloc_get_ptr(in);
13292                         }
13293                         break;
13294
13295                 case 1512:
13296                         if (in == Py_None) {
13297                                 ret->info1512 = NULL;
13298                         } else {
13299                                 ret->info1512 = NULL;
13300                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1512_Type, in, talloc_free(ret); return NULL;);
13301                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13302                                         PyErr_NoMemory();
13303                                         talloc_free(ret); return NULL;
13304                                 }
13305                                 ret->info1512 = (struct srvsvc_NetSrvInfo1512 *)pytalloc_get_ptr(in);
13306                         }
13307                         break;
13308
13309                 case 1513:
13310                         if (in == Py_None) {
13311                                 ret->info1513 = NULL;
13312                         } else {
13313                                 ret->info1513 = NULL;
13314                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1513_Type, in, talloc_free(ret); return NULL;);
13315                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13316                                         PyErr_NoMemory();
13317                                         talloc_free(ret); return NULL;
13318                                 }
13319                                 ret->info1513 = (struct srvsvc_NetSrvInfo1513 *)pytalloc_get_ptr(in);
13320                         }
13321                         break;
13322
13323                 case 1514:
13324                         if (in == Py_None) {
13325                                 ret->info1514 = NULL;
13326                         } else {
13327                                 ret->info1514 = NULL;
13328                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1514_Type, in, talloc_free(ret); return NULL;);
13329                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13330                                         PyErr_NoMemory();
13331                                         talloc_free(ret); return NULL;
13332                                 }
13333                                 ret->info1514 = (struct srvsvc_NetSrvInfo1514 *)pytalloc_get_ptr(in);
13334                         }
13335                         break;
13336
13337                 case 1515:
13338                         if (in == Py_None) {
13339                                 ret->info1515 = NULL;
13340                         } else {
13341                                 ret->info1515 = NULL;
13342                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1515_Type, in, talloc_free(ret); return NULL;);
13343                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13344                                         PyErr_NoMemory();
13345                                         talloc_free(ret); return NULL;
13346                                 }
13347                                 ret->info1515 = (struct srvsvc_NetSrvInfo1515 *)pytalloc_get_ptr(in);
13348                         }
13349                         break;
13350
13351                 case 1516:
13352                         if (in == Py_None) {
13353                                 ret->info1516 = NULL;
13354                         } else {
13355                                 ret->info1516 = NULL;
13356                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1516_Type, in, talloc_free(ret); return NULL;);
13357                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13358                                         PyErr_NoMemory();
13359                                         talloc_free(ret); return NULL;
13360                                 }
13361                                 ret->info1516 = (struct srvsvc_NetSrvInfo1516 *)pytalloc_get_ptr(in);
13362                         }
13363                         break;
13364
13365                 case 1518:
13366                         if (in == Py_None) {
13367                                 ret->info1518 = NULL;
13368                         } else {
13369                                 ret->info1518 = NULL;
13370                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1518_Type, in, talloc_free(ret); return NULL;);
13371                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13372                                         PyErr_NoMemory();
13373                                         talloc_free(ret); return NULL;
13374                                 }
13375                                 ret->info1518 = (struct srvsvc_NetSrvInfo1518 *)pytalloc_get_ptr(in);
13376                         }
13377                         break;
13378
13379                 case 1520:
13380                         if (in == Py_None) {
13381                                 ret->info1520 = NULL;
13382                         } else {
13383                                 ret->info1520 = NULL;
13384                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1520_Type, in, talloc_free(ret); return NULL;);
13385                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13386                                         PyErr_NoMemory();
13387                                         talloc_free(ret); return NULL;
13388                                 }
13389                                 ret->info1520 = (struct srvsvc_NetSrvInfo1520 *)pytalloc_get_ptr(in);
13390                         }
13391                         break;
13392
13393                 case 1521:
13394                         if (in == Py_None) {
13395                                 ret->info1521 = NULL;
13396                         } else {
13397                                 ret->info1521 = NULL;
13398                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1521_Type, in, talloc_free(ret); return NULL;);
13399                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13400                                         PyErr_NoMemory();
13401                                         talloc_free(ret); return NULL;
13402                                 }
13403                                 ret->info1521 = (struct srvsvc_NetSrvInfo1521 *)pytalloc_get_ptr(in);
13404                         }
13405                         break;
13406
13407                 case 1522:
13408                         if (in == Py_None) {
13409                                 ret->info1522 = NULL;
13410                         } else {
13411                                 ret->info1522 = NULL;
13412                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1522_Type, in, talloc_free(ret); return NULL;);
13413                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13414                                         PyErr_NoMemory();
13415                                         talloc_free(ret); return NULL;
13416                                 }
13417                                 ret->info1522 = (struct srvsvc_NetSrvInfo1522 *)pytalloc_get_ptr(in);
13418                         }
13419                         break;
13420
13421                 case 1523:
13422                         if (in == Py_None) {
13423                                 ret->info1523 = NULL;
13424                         } else {
13425                                 ret->info1523 = NULL;
13426                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1523_Type, in, talloc_free(ret); return NULL;);
13427                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13428                                         PyErr_NoMemory();
13429                                         talloc_free(ret); return NULL;
13430                                 }
13431                                 ret->info1523 = (struct srvsvc_NetSrvInfo1523 *)pytalloc_get_ptr(in);
13432                         }
13433                         break;
13434
13435                 case 1524:
13436                         if (in == Py_None) {
13437                                 ret->info1524 = NULL;
13438                         } else {
13439                                 ret->info1524 = NULL;
13440                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1524_Type, in, talloc_free(ret); return NULL;);
13441                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13442                                         PyErr_NoMemory();
13443                                         talloc_free(ret); return NULL;
13444                                 }
13445                                 ret->info1524 = (struct srvsvc_NetSrvInfo1524 *)pytalloc_get_ptr(in);
13446                         }
13447                         break;
13448
13449                 case 1525:
13450                         if (in == Py_None) {
13451                                 ret->info1525 = NULL;
13452                         } else {
13453                                 ret->info1525 = NULL;
13454                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1525_Type, in, talloc_free(ret); return NULL;);
13455                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13456                                         PyErr_NoMemory();
13457                                         talloc_free(ret); return NULL;
13458                                 }
13459                                 ret->info1525 = (struct srvsvc_NetSrvInfo1525 *)pytalloc_get_ptr(in);
13460                         }
13461                         break;
13462
13463                 case 1528:
13464                         if (in == Py_None) {
13465                                 ret->info1528 = NULL;
13466                         } else {
13467                                 ret->info1528 = NULL;
13468                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1528_Type, in, talloc_free(ret); return NULL;);
13469                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13470                                         PyErr_NoMemory();
13471                                         talloc_free(ret); return NULL;
13472                                 }
13473                                 ret->info1528 = (struct srvsvc_NetSrvInfo1528 *)pytalloc_get_ptr(in);
13474                         }
13475                         break;
13476
13477                 case 1529:
13478                         if (in == Py_None) {
13479                                 ret->info1529 = NULL;
13480                         } else {
13481                                 ret->info1529 = NULL;
13482                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1529_Type, in, talloc_free(ret); return NULL;);
13483                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13484                                         PyErr_NoMemory();
13485                                         talloc_free(ret); return NULL;
13486                                 }
13487                                 ret->info1529 = (struct srvsvc_NetSrvInfo1529 *)pytalloc_get_ptr(in);
13488                         }
13489                         break;
13490
13491                 case 1530:
13492                         if (in == Py_None) {
13493                                 ret->info1530 = NULL;
13494                         } else {
13495                                 ret->info1530 = NULL;
13496                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1530_Type, in, talloc_free(ret); return NULL;);
13497                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13498                                         PyErr_NoMemory();
13499                                         talloc_free(ret); return NULL;
13500                                 }
13501                                 ret->info1530 = (struct srvsvc_NetSrvInfo1530 *)pytalloc_get_ptr(in);
13502                         }
13503                         break;
13504
13505                 case 1533:
13506                         if (in == Py_None) {
13507                                 ret->info1533 = NULL;
13508                         } else {
13509                                 ret->info1533 = NULL;
13510                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1533_Type, in, talloc_free(ret); return NULL;);
13511                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13512                                         PyErr_NoMemory();
13513                                         talloc_free(ret); return NULL;
13514                                 }
13515                                 ret->info1533 = (struct srvsvc_NetSrvInfo1533 *)pytalloc_get_ptr(in);
13516                         }
13517                         break;
13518
13519                 case 1534:
13520                         if (in == Py_None) {
13521                                 ret->info1534 = NULL;
13522                         } else {
13523                                 ret->info1534 = NULL;
13524                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1534_Type, in, talloc_free(ret); return NULL;);
13525                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13526                                         PyErr_NoMemory();
13527                                         talloc_free(ret); return NULL;
13528                                 }
13529                                 ret->info1534 = (struct srvsvc_NetSrvInfo1534 *)pytalloc_get_ptr(in);
13530                         }
13531                         break;
13532
13533                 case 1535:
13534                         if (in == Py_None) {
13535                                 ret->info1535 = NULL;
13536                         } else {
13537                                 ret->info1535 = NULL;
13538                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1535_Type, in, talloc_free(ret); return NULL;);
13539                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13540                                         PyErr_NoMemory();
13541                                         talloc_free(ret); return NULL;
13542                                 }
13543                                 ret->info1535 = (struct srvsvc_NetSrvInfo1535 *)pytalloc_get_ptr(in);
13544                         }
13545                         break;
13546
13547                 case 1536:
13548                         if (in == Py_None) {
13549                                 ret->info1536 = NULL;
13550                         } else {
13551                                 ret->info1536 = NULL;
13552                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1536_Type, in, talloc_free(ret); return NULL;);
13553                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13554                                         PyErr_NoMemory();
13555                                         talloc_free(ret); return NULL;
13556                                 }
13557                                 ret->info1536 = (struct srvsvc_NetSrvInfo1536 *)pytalloc_get_ptr(in);
13558                         }
13559                         break;
13560
13561                 case 1537:
13562                         if (in == Py_None) {
13563                                 ret->info1537 = NULL;
13564                         } else {
13565                                 ret->info1537 = NULL;
13566                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1537_Type, in, talloc_free(ret); return NULL;);
13567                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13568                                         PyErr_NoMemory();
13569                                         talloc_free(ret); return NULL;
13570                                 }
13571                                 ret->info1537 = (struct srvsvc_NetSrvInfo1537 *)pytalloc_get_ptr(in);
13572                         }
13573                         break;
13574
13575                 case 1538:
13576                         if (in == Py_None) {
13577                                 ret->info1538 = NULL;
13578                         } else {
13579                                 ret->info1538 = NULL;
13580                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1538_Type, in, talloc_free(ret); return NULL;);
13581                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13582                                         PyErr_NoMemory();
13583                                         talloc_free(ret); return NULL;
13584                                 }
13585                                 ret->info1538 = (struct srvsvc_NetSrvInfo1538 *)pytalloc_get_ptr(in);
13586                         }
13587                         break;
13588
13589                 case 1539:
13590                         if (in == Py_None) {
13591                                 ret->info1539 = NULL;
13592                         } else {
13593                                 ret->info1539 = NULL;
13594                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1539_Type, in, talloc_free(ret); return NULL;);
13595                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13596                                         PyErr_NoMemory();
13597                                         talloc_free(ret); return NULL;
13598                                 }
13599                                 ret->info1539 = (struct srvsvc_NetSrvInfo1539 *)pytalloc_get_ptr(in);
13600                         }
13601                         break;
13602
13603                 case 1540:
13604                         if (in == Py_None) {
13605                                 ret->info1540 = NULL;
13606                         } else {
13607                                 ret->info1540 = NULL;
13608                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1540_Type, in, talloc_free(ret); return NULL;);
13609                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13610                                         PyErr_NoMemory();
13611                                         talloc_free(ret); return NULL;
13612                                 }
13613                                 ret->info1540 = (struct srvsvc_NetSrvInfo1540 *)pytalloc_get_ptr(in);
13614                         }
13615                         break;
13616
13617                 case 1541:
13618                         if (in == Py_None) {
13619                                 ret->info1541 = NULL;
13620                         } else {
13621                                 ret->info1541 = NULL;
13622                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1541_Type, in, talloc_free(ret); return NULL;);
13623                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13624                                         PyErr_NoMemory();
13625                                         talloc_free(ret); return NULL;
13626                                 }
13627                                 ret->info1541 = (struct srvsvc_NetSrvInfo1541 *)pytalloc_get_ptr(in);
13628                         }
13629                         break;
13630
13631                 case 1542:
13632                         if (in == Py_None) {
13633                                 ret->info1542 = NULL;
13634                         } else {
13635                                 ret->info1542 = NULL;
13636                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1542_Type, in, talloc_free(ret); return NULL;);
13637                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13638                                         PyErr_NoMemory();
13639                                         talloc_free(ret); return NULL;
13640                                 }
13641                                 ret->info1542 = (struct srvsvc_NetSrvInfo1542 *)pytalloc_get_ptr(in);
13642                         }
13643                         break;
13644
13645                 case 1543:
13646                         if (in == Py_None) {
13647                                 ret->info1543 = NULL;
13648                         } else {
13649                                 ret->info1543 = NULL;
13650                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1543_Type, in, talloc_free(ret); return NULL;);
13651                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13652                                         PyErr_NoMemory();
13653                                         talloc_free(ret); return NULL;
13654                                 }
13655                                 ret->info1543 = (struct srvsvc_NetSrvInfo1543 *)pytalloc_get_ptr(in);
13656                         }
13657                         break;
13658
13659                 case 1544:
13660                         if (in == Py_None) {
13661                                 ret->info1544 = NULL;
13662                         } else {
13663                                 ret->info1544 = NULL;
13664                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1544_Type, in, talloc_free(ret); return NULL;);
13665                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13666                                         PyErr_NoMemory();
13667                                         talloc_free(ret); return NULL;
13668                                 }
13669                                 ret->info1544 = (struct srvsvc_NetSrvInfo1544 *)pytalloc_get_ptr(in);
13670                         }
13671                         break;
13672
13673                 case 1545:
13674                         if (in == Py_None) {
13675                                 ret->info1545 = NULL;
13676                         } else {
13677                                 ret->info1545 = NULL;
13678                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1545_Type, in, talloc_free(ret); return NULL;);
13679                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13680                                         PyErr_NoMemory();
13681                                         talloc_free(ret); return NULL;
13682                                 }
13683                                 ret->info1545 = (struct srvsvc_NetSrvInfo1545 *)pytalloc_get_ptr(in);
13684                         }
13685                         break;
13686
13687                 case 1546:
13688                         if (in == Py_None) {
13689                                 ret->info1546 = NULL;
13690                         } else {
13691                                 ret->info1546 = NULL;
13692                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1546_Type, in, talloc_free(ret); return NULL;);
13693                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13694                                         PyErr_NoMemory();
13695                                         talloc_free(ret); return NULL;
13696                                 }
13697                                 ret->info1546 = (struct srvsvc_NetSrvInfo1546 *)pytalloc_get_ptr(in);
13698                         }
13699                         break;
13700
13701                 case 1547:
13702                         if (in == Py_None) {
13703                                 ret->info1547 = NULL;
13704                         } else {
13705                                 ret->info1547 = NULL;
13706                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1547_Type, in, talloc_free(ret); return NULL;);
13707                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13708                                         PyErr_NoMemory();
13709                                         talloc_free(ret); return NULL;
13710                                 }
13711                                 ret->info1547 = (struct srvsvc_NetSrvInfo1547 *)pytalloc_get_ptr(in);
13712                         }
13713                         break;
13714
13715                 case 1548:
13716                         if (in == Py_None) {
13717                                 ret->info1548 = NULL;
13718                         } else {
13719                                 ret->info1548 = NULL;
13720                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1548_Type, in, talloc_free(ret); return NULL;);
13721                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13722                                         PyErr_NoMemory();
13723                                         talloc_free(ret); return NULL;
13724                                 }
13725                                 ret->info1548 = (struct srvsvc_NetSrvInfo1548 *)pytalloc_get_ptr(in);
13726                         }
13727                         break;
13728
13729                 case 1549:
13730                         if (in == Py_None) {
13731                                 ret->info1549 = NULL;
13732                         } else {
13733                                 ret->info1549 = NULL;
13734                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1549_Type, in, talloc_free(ret); return NULL;);
13735                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13736                                         PyErr_NoMemory();
13737                                         talloc_free(ret); return NULL;
13738                                 }
13739                                 ret->info1549 = (struct srvsvc_NetSrvInfo1549 *)pytalloc_get_ptr(in);
13740                         }
13741                         break;
13742
13743                 case 1550:
13744                         if (in == Py_None) {
13745                                 ret->info1550 = NULL;
13746                         } else {
13747                                 ret->info1550 = NULL;
13748                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1550_Type, in, talloc_free(ret); return NULL;);
13749                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13750                                         PyErr_NoMemory();
13751                                         talloc_free(ret); return NULL;
13752                                 }
13753                                 ret->info1550 = (struct srvsvc_NetSrvInfo1550 *)pytalloc_get_ptr(in);
13754                         }
13755                         break;
13756
13757                 case 1552:
13758                         if (in == Py_None) {
13759                                 ret->info1552 = NULL;
13760                         } else {
13761                                 ret->info1552 = NULL;
13762                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1552_Type, in, talloc_free(ret); return NULL;);
13763                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13764                                         PyErr_NoMemory();
13765                                         talloc_free(ret); return NULL;
13766                                 }
13767                                 ret->info1552 = (struct srvsvc_NetSrvInfo1552 *)pytalloc_get_ptr(in);
13768                         }
13769                         break;
13770
13771                 case 1553:
13772                         if (in == Py_None) {
13773                                 ret->info1553 = NULL;
13774                         } else {
13775                                 ret->info1553 = NULL;
13776                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1553_Type, in, talloc_free(ret); return NULL;);
13777                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13778                                         PyErr_NoMemory();
13779                                         talloc_free(ret); return NULL;
13780                                 }
13781                                 ret->info1553 = (struct srvsvc_NetSrvInfo1553 *)pytalloc_get_ptr(in);
13782                         }
13783                         break;
13784
13785                 case 1554:
13786                         if (in == Py_None) {
13787                                 ret->info1554 = NULL;
13788                         } else {
13789                                 ret->info1554 = NULL;
13790                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1554_Type, in, talloc_free(ret); return NULL;);
13791                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13792                                         PyErr_NoMemory();
13793                                         talloc_free(ret); return NULL;
13794                                 }
13795                                 ret->info1554 = (struct srvsvc_NetSrvInfo1554 *)pytalloc_get_ptr(in);
13796                         }
13797                         break;
13798
13799                 case 1555:
13800                         if (in == Py_None) {
13801                                 ret->info1555 = NULL;
13802                         } else {
13803                                 ret->info1555 = NULL;
13804                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1555_Type, in, talloc_free(ret); return NULL;);
13805                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13806                                         PyErr_NoMemory();
13807                                         talloc_free(ret); return NULL;
13808                                 }
13809                                 ret->info1555 = (struct srvsvc_NetSrvInfo1555 *)pytalloc_get_ptr(in);
13810                         }
13811                         break;
13812
13813                 case 1556:
13814                         if (in == Py_None) {
13815                                 ret->info1556 = NULL;
13816                         } else {
13817                                 ret->info1556 = NULL;
13818                                 PY_CHECK_TYPE(&srvsvc_NetSrvInfo1556_Type, in, talloc_free(ret); return NULL;);
13819                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
13820                                         PyErr_NoMemory();
13821                                         talloc_free(ret); return NULL;
13822                                 }
13823                                 ret->info1556 = (struct srvsvc_NetSrvInfo1556 *)pytalloc_get_ptr(in);
13824                         }
13825                         break;
13826
13827                 default:
13828                         break;
13829
13830         }
13831
13832         return ret;
13833 }
13834
13835
13836 static PyObject *py_srvsvc_NetDiskInfo0_get___disk_offset(PyObject *obj, void *closure)
13837 {
13838         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13839         PyObject *py___disk_offset;
13840         py___disk_offset = PyInt_FromLong(object->__disk_offset);
13841         return py___disk_offset;
13842 }
13843
13844 static int py_srvsvc_NetDiskInfo0_set___disk_offset(PyObject *py_obj, PyObject *value, void *closure)
13845 {
13846         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13847         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13848         object->__disk_offset = PyInt_AsLong(value);
13849         return 0;
13850 }
13851
13852 static PyObject *py_srvsvc_NetDiskInfo0_get___disk_length(PyObject *obj, void *closure)
13853 {
13854         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13855         PyObject *py___disk_length;
13856         py___disk_length = PyInt_FromLong(object->__disk_length);
13857         return py___disk_length;
13858 }
13859
13860 static int py_srvsvc_NetDiskInfo0_set___disk_length(PyObject *py_obj, PyObject *value, void *closure)
13861 {
13862         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13863         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13864         object->__disk_length = PyInt_AsLong(value);
13865         return 0;
13866 }
13867
13868 static PyObject *py_srvsvc_NetDiskInfo0_get_disk(PyObject *obj, void *closure)
13869 {
13870         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(obj);
13871         PyObject *py_disk;
13872         if (object->disk == NULL) {
13873                 py_disk = Py_None;
13874                 Py_INCREF(py_disk);
13875         } else {
13876                 py_disk = PyUnicode_Decode(object->disk, strlen(object->disk), "utf-8", "ignore");
13877         }
13878         return py_disk;
13879 }
13880
13881 static int py_srvsvc_NetDiskInfo0_set_disk(PyObject *py_obj, PyObject *value, void *closure)
13882 {
13883         struct srvsvc_NetDiskInfo0 *object = (struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(py_obj);
13884         if (PyUnicode_Check(value)) {
13885                 object->disk = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
13886         } else if (PyString_Check(value)) {
13887                 object->disk = PyString_AS_STRING(value);
13888         } else {
13889                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
13890                 return -1;
13891         }
13892         return 0;
13893 }
13894
13895 static PyGetSetDef py_srvsvc_NetDiskInfo0_getsetters[] = {
13896         { discard_const_p(char, "__disk_offset"), py_srvsvc_NetDiskInfo0_get___disk_offset, py_srvsvc_NetDiskInfo0_set___disk_offset },
13897         { discard_const_p(char, "__disk_length"), py_srvsvc_NetDiskInfo0_get___disk_length, py_srvsvc_NetDiskInfo0_set___disk_length },
13898         { discard_const_p(char, "disk"), py_srvsvc_NetDiskInfo0_get_disk, py_srvsvc_NetDiskInfo0_set_disk },
13899         { NULL }
13900 };
13901
13902 static PyObject *py_srvsvc_NetDiskInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
13903 {
13904         return pytalloc_new(struct srvsvc_NetDiskInfo0, type);
13905 }
13906
13907
13908 static PyTypeObject srvsvc_NetDiskInfo0_Type = {
13909         PyObject_HEAD_INIT(NULL) 0,
13910         .tp_name = "srvsvc.NetDiskInfo0",
13911         .tp_getset = py_srvsvc_NetDiskInfo0_getsetters,
13912         .tp_methods = NULL,
13913         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
13914         .tp_basicsize = sizeof(pytalloc_Object),
13915         .tp_new = py_srvsvc_NetDiskInfo0_new,
13916 };
13917
13918
13919 static PyObject *py_srvsvc_NetDiskInfo_get_count(PyObject *obj, void *closure)
13920 {
13921         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
13922         PyObject *py_count;
13923         py_count = PyInt_FromLong(object->count);
13924         return py_count;
13925 }
13926
13927 static int py_srvsvc_NetDiskInfo_set_count(PyObject *py_obj, PyObject *value, void *closure)
13928 {
13929         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_obj);
13930         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
13931         object->count = PyInt_AsLong(value);
13932         return 0;
13933 }
13934
13935 static PyObject *py_srvsvc_NetDiskInfo_get_disks(PyObject *obj, void *closure)
13936 {
13937         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(obj);
13938         PyObject *py_disks;
13939         if (object->disks == NULL) {
13940                 py_disks = Py_None;
13941                 Py_INCREF(py_disks);
13942         } else {
13943                 py_disks = PyList_New(object->count);
13944                 if (py_disks == NULL) {
13945                         return NULL;
13946                 }
13947                 {
13948                         int disks_cntr_1;
13949                         for (disks_cntr_1 = 0; disks_cntr_1 < object->count; disks_cntr_1++) {
13950                                 PyObject *py_disks_1;
13951                                 py_disks_1 = pytalloc_reference_ex(&srvsvc_NetDiskInfo0_Type, object->disks, &object->disks[disks_cntr_1]);
13952                                 PyList_SetItem(py_disks, disks_cntr_1, py_disks_1);
13953                         }
13954                 }
13955         }
13956         return py_disks;
13957 }
13958
13959 static int py_srvsvc_NetDiskInfo_set_disks(PyObject *py_obj, PyObject *value, void *closure)
13960 {
13961         struct srvsvc_NetDiskInfo *object = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_obj);
13962         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->disks);
13963         if (value == Py_None) {
13964                 object->disks = NULL;
13965         } else {
13966                 object->disks = NULL;
13967                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
13968                 {
13969                         int disks_cntr_1;
13970                         object->disks = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->disks, PyList_GET_SIZE(value));
13971                         if (!object->disks) { return -1;; }
13972                         talloc_set_name_const(object->disks, "ARRAY: object->disks");
13973                         for (disks_cntr_1 = 0; disks_cntr_1 < PyList_GET_SIZE(value); disks_cntr_1++) {
13974                                 PY_CHECK_TYPE(&srvsvc_NetDiskInfo0_Type, PyList_GET_ITEM(value, disks_cntr_1), return -1;);
13975                                 if (talloc_reference(object->disks, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, disks_cntr_1))) == NULL) {
13976                                         PyErr_NoMemory();
13977                                         return -1;
13978                                 }
13979                                 object->disks[disks_cntr_1] = *(struct srvsvc_NetDiskInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, disks_cntr_1));
13980                         }
13981                 }
13982         }
13983         return 0;
13984 }
13985
13986 static PyGetSetDef py_srvsvc_NetDiskInfo_getsetters[] = {
13987         { discard_const_p(char, "count"), py_srvsvc_NetDiskInfo_get_count, py_srvsvc_NetDiskInfo_set_count },
13988         { discard_const_p(char, "disks"), py_srvsvc_NetDiskInfo_get_disks, py_srvsvc_NetDiskInfo_set_disks },
13989         { NULL }
13990 };
13991
13992 static PyObject *py_srvsvc_NetDiskInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
13993 {
13994         return pytalloc_new(struct srvsvc_NetDiskInfo, type);
13995 }
13996
13997
13998 static PyTypeObject srvsvc_NetDiskInfo_Type = {
13999         PyObject_HEAD_INIT(NULL) 0,
14000         .tp_name = "srvsvc.NetDiskInfo",
14001         .tp_getset = py_srvsvc_NetDiskInfo_getsetters,
14002         .tp_methods = NULL,
14003         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14004         .tp_basicsize = sizeof(pytalloc_Object),
14005         .tp_new = py_srvsvc_NetDiskInfo_new,
14006 };
14007
14008
14009 static PyObject *py_srvsvc_Statistics_get_start(PyObject *obj, void *closure)
14010 {
14011         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14012         PyObject *py_start;
14013         py_start = PyInt_FromLong(object->start);
14014         return py_start;
14015 }
14016
14017 static int py_srvsvc_Statistics_set_start(PyObject *py_obj, PyObject *value, void *closure)
14018 {
14019         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14020         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14021         object->start = PyInt_AsLong(value);
14022         return 0;
14023 }
14024
14025 static PyObject *py_srvsvc_Statistics_get_fopens(PyObject *obj, void *closure)
14026 {
14027         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14028         PyObject *py_fopens;
14029         py_fopens = PyInt_FromLong(object->fopens);
14030         return py_fopens;
14031 }
14032
14033 static int py_srvsvc_Statistics_set_fopens(PyObject *py_obj, PyObject *value, void *closure)
14034 {
14035         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14036         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14037         object->fopens = PyInt_AsLong(value);
14038         return 0;
14039 }
14040
14041 static PyObject *py_srvsvc_Statistics_get_devopens(PyObject *obj, void *closure)
14042 {
14043         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14044         PyObject *py_devopens;
14045         py_devopens = PyInt_FromLong(object->devopens);
14046         return py_devopens;
14047 }
14048
14049 static int py_srvsvc_Statistics_set_devopens(PyObject *py_obj, PyObject *value, void *closure)
14050 {
14051         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14052         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14053         object->devopens = PyInt_AsLong(value);
14054         return 0;
14055 }
14056
14057 static PyObject *py_srvsvc_Statistics_get_jobsqueued(PyObject *obj, void *closure)
14058 {
14059         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14060         PyObject *py_jobsqueued;
14061         py_jobsqueued = PyInt_FromLong(object->jobsqueued);
14062         return py_jobsqueued;
14063 }
14064
14065 static int py_srvsvc_Statistics_set_jobsqueued(PyObject *py_obj, PyObject *value, void *closure)
14066 {
14067         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14068         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14069         object->jobsqueued = PyInt_AsLong(value);
14070         return 0;
14071 }
14072
14073 static PyObject *py_srvsvc_Statistics_get_sopens(PyObject *obj, void *closure)
14074 {
14075         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14076         PyObject *py_sopens;
14077         py_sopens = PyInt_FromLong(object->sopens);
14078         return py_sopens;
14079 }
14080
14081 static int py_srvsvc_Statistics_set_sopens(PyObject *py_obj, PyObject *value, void *closure)
14082 {
14083         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14084         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14085         object->sopens = PyInt_AsLong(value);
14086         return 0;
14087 }
14088
14089 static PyObject *py_srvsvc_Statistics_get_stimeouts(PyObject *obj, void *closure)
14090 {
14091         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14092         PyObject *py_stimeouts;
14093         py_stimeouts = PyInt_FromLong(object->stimeouts);
14094         return py_stimeouts;
14095 }
14096
14097 static int py_srvsvc_Statistics_set_stimeouts(PyObject *py_obj, PyObject *value, void *closure)
14098 {
14099         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14100         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14101         object->stimeouts = PyInt_AsLong(value);
14102         return 0;
14103 }
14104
14105 static PyObject *py_srvsvc_Statistics_get_serrorout(PyObject *obj, void *closure)
14106 {
14107         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14108         PyObject *py_serrorout;
14109         py_serrorout = PyInt_FromLong(object->serrorout);
14110         return py_serrorout;
14111 }
14112
14113 static int py_srvsvc_Statistics_set_serrorout(PyObject *py_obj, PyObject *value, void *closure)
14114 {
14115         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14116         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14117         object->serrorout = PyInt_AsLong(value);
14118         return 0;
14119 }
14120
14121 static PyObject *py_srvsvc_Statistics_get_pwerrors(PyObject *obj, void *closure)
14122 {
14123         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14124         PyObject *py_pwerrors;
14125         py_pwerrors = PyInt_FromLong(object->pwerrors);
14126         return py_pwerrors;
14127 }
14128
14129 static int py_srvsvc_Statistics_set_pwerrors(PyObject *py_obj, PyObject *value, void *closure)
14130 {
14131         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14132         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14133         object->pwerrors = PyInt_AsLong(value);
14134         return 0;
14135 }
14136
14137 static PyObject *py_srvsvc_Statistics_get_permerrors(PyObject *obj, void *closure)
14138 {
14139         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14140         PyObject *py_permerrors;
14141         py_permerrors = PyInt_FromLong(object->permerrors);
14142         return py_permerrors;
14143 }
14144
14145 static int py_srvsvc_Statistics_set_permerrors(PyObject *py_obj, PyObject *value, void *closure)
14146 {
14147         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14148         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14149         object->permerrors = PyInt_AsLong(value);
14150         return 0;
14151 }
14152
14153 static PyObject *py_srvsvc_Statistics_get_syserrors(PyObject *obj, void *closure)
14154 {
14155         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14156         PyObject *py_syserrors;
14157         py_syserrors = PyInt_FromLong(object->syserrors);
14158         return py_syserrors;
14159 }
14160
14161 static int py_srvsvc_Statistics_set_syserrors(PyObject *py_obj, PyObject *value, void *closure)
14162 {
14163         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14164         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14165         object->syserrors = PyInt_AsLong(value);
14166         return 0;
14167 }
14168
14169 static PyObject *py_srvsvc_Statistics_get_bytessent_low(PyObject *obj, void *closure)
14170 {
14171         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14172         PyObject *py_bytessent_low;
14173         py_bytessent_low = PyInt_FromLong(object->bytessent_low);
14174         return py_bytessent_low;
14175 }
14176
14177 static int py_srvsvc_Statistics_set_bytessent_low(PyObject *py_obj, PyObject *value, void *closure)
14178 {
14179         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14180         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14181         object->bytessent_low = PyInt_AsLong(value);
14182         return 0;
14183 }
14184
14185 static PyObject *py_srvsvc_Statistics_get_bytessent_high(PyObject *obj, void *closure)
14186 {
14187         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14188         PyObject *py_bytessent_high;
14189         py_bytessent_high = PyInt_FromLong(object->bytessent_high);
14190         return py_bytessent_high;
14191 }
14192
14193 static int py_srvsvc_Statistics_set_bytessent_high(PyObject *py_obj, PyObject *value, void *closure)
14194 {
14195         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14196         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14197         object->bytessent_high = PyInt_AsLong(value);
14198         return 0;
14199 }
14200
14201 static PyObject *py_srvsvc_Statistics_get_bytesrcvd_low(PyObject *obj, void *closure)
14202 {
14203         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14204         PyObject *py_bytesrcvd_low;
14205         py_bytesrcvd_low = PyInt_FromLong(object->bytesrcvd_low);
14206         return py_bytesrcvd_low;
14207 }
14208
14209 static int py_srvsvc_Statistics_set_bytesrcvd_low(PyObject *py_obj, PyObject *value, void *closure)
14210 {
14211         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14212         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14213         object->bytesrcvd_low = PyInt_AsLong(value);
14214         return 0;
14215 }
14216
14217 static PyObject *py_srvsvc_Statistics_get_bytesrcvd_high(PyObject *obj, void *closure)
14218 {
14219         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14220         PyObject *py_bytesrcvd_high;
14221         py_bytesrcvd_high = PyInt_FromLong(object->bytesrcvd_high);
14222         return py_bytesrcvd_high;
14223 }
14224
14225 static int py_srvsvc_Statistics_set_bytesrcvd_high(PyObject *py_obj, PyObject *value, void *closure)
14226 {
14227         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14228         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14229         object->bytesrcvd_high = PyInt_AsLong(value);
14230         return 0;
14231 }
14232
14233 static PyObject *py_srvsvc_Statistics_get_avresponse(PyObject *obj, void *closure)
14234 {
14235         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14236         PyObject *py_avresponse;
14237         py_avresponse = PyInt_FromLong(object->avresponse);
14238         return py_avresponse;
14239 }
14240
14241 static int py_srvsvc_Statistics_set_avresponse(PyObject *py_obj, PyObject *value, void *closure)
14242 {
14243         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14244         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14245         object->avresponse = PyInt_AsLong(value);
14246         return 0;
14247 }
14248
14249 static PyObject *py_srvsvc_Statistics_get_reqbufneed(PyObject *obj, void *closure)
14250 {
14251         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14252         PyObject *py_reqbufneed;
14253         py_reqbufneed = PyInt_FromLong(object->reqbufneed);
14254         return py_reqbufneed;
14255 }
14256
14257 static int py_srvsvc_Statistics_set_reqbufneed(PyObject *py_obj, PyObject *value, void *closure)
14258 {
14259         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14260         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14261         object->reqbufneed = PyInt_AsLong(value);
14262         return 0;
14263 }
14264
14265 static PyObject *py_srvsvc_Statistics_get_bigbufneed(PyObject *obj, void *closure)
14266 {
14267         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(obj);
14268         PyObject *py_bigbufneed;
14269         py_bigbufneed = PyInt_FromLong(object->bigbufneed);
14270         return py_bigbufneed;
14271 }
14272
14273 static int py_srvsvc_Statistics_set_bigbufneed(PyObject *py_obj, PyObject *value, void *closure)
14274 {
14275         struct srvsvc_Statistics *object = (struct srvsvc_Statistics *)pytalloc_get_ptr(py_obj);
14276         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14277         object->bigbufneed = PyInt_AsLong(value);
14278         return 0;
14279 }
14280
14281 static PyGetSetDef py_srvsvc_Statistics_getsetters[] = {
14282         { discard_const_p(char, "start"), py_srvsvc_Statistics_get_start, py_srvsvc_Statistics_set_start },
14283         { discard_const_p(char, "fopens"), py_srvsvc_Statistics_get_fopens, py_srvsvc_Statistics_set_fopens },
14284         { discard_const_p(char, "devopens"), py_srvsvc_Statistics_get_devopens, py_srvsvc_Statistics_set_devopens },
14285         { discard_const_p(char, "jobsqueued"), py_srvsvc_Statistics_get_jobsqueued, py_srvsvc_Statistics_set_jobsqueued },
14286         { discard_const_p(char, "sopens"), py_srvsvc_Statistics_get_sopens, py_srvsvc_Statistics_set_sopens },
14287         { discard_const_p(char, "stimeouts"), py_srvsvc_Statistics_get_stimeouts, py_srvsvc_Statistics_set_stimeouts },
14288         { discard_const_p(char, "serrorout"), py_srvsvc_Statistics_get_serrorout, py_srvsvc_Statistics_set_serrorout },
14289         { discard_const_p(char, "pwerrors"), py_srvsvc_Statistics_get_pwerrors, py_srvsvc_Statistics_set_pwerrors },
14290         { discard_const_p(char, "permerrors"), py_srvsvc_Statistics_get_permerrors, py_srvsvc_Statistics_set_permerrors },
14291         { discard_const_p(char, "syserrors"), py_srvsvc_Statistics_get_syserrors, py_srvsvc_Statistics_set_syserrors },
14292         { discard_const_p(char, "bytessent_low"), py_srvsvc_Statistics_get_bytessent_low, py_srvsvc_Statistics_set_bytessent_low },
14293         { discard_const_p(char, "bytessent_high"), py_srvsvc_Statistics_get_bytessent_high, py_srvsvc_Statistics_set_bytessent_high },
14294         { discard_const_p(char, "bytesrcvd_low"), py_srvsvc_Statistics_get_bytesrcvd_low, py_srvsvc_Statistics_set_bytesrcvd_low },
14295         { discard_const_p(char, "bytesrcvd_high"), py_srvsvc_Statistics_get_bytesrcvd_high, py_srvsvc_Statistics_set_bytesrcvd_high },
14296         { discard_const_p(char, "avresponse"), py_srvsvc_Statistics_get_avresponse, py_srvsvc_Statistics_set_avresponse },
14297         { discard_const_p(char, "reqbufneed"), py_srvsvc_Statistics_get_reqbufneed, py_srvsvc_Statistics_set_reqbufneed },
14298         { discard_const_p(char, "bigbufneed"), py_srvsvc_Statistics_get_bigbufneed, py_srvsvc_Statistics_set_bigbufneed },
14299         { NULL }
14300 };
14301
14302 static PyObject *py_srvsvc_Statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14303 {
14304         return pytalloc_new(struct srvsvc_Statistics, type);
14305 }
14306
14307
14308 static PyTypeObject srvsvc_Statistics_Type = {
14309         PyObject_HEAD_INIT(NULL) 0,
14310         .tp_name = "srvsvc.Statistics",
14311         .tp_getset = py_srvsvc_Statistics_getsetters,
14312         .tp_methods = NULL,
14313         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14314         .tp_basicsize = sizeof(pytalloc_Object),
14315         .tp_new = py_srvsvc_Statistics_new,
14316 };
14317
14318
14319 static PyObject *py_srvsvc_NetTransportInfo0_get_vcs(PyObject *obj, void *closure)
14320 {
14321         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14322         PyObject *py_vcs;
14323         py_vcs = PyInt_FromLong(object->vcs);
14324         return py_vcs;
14325 }
14326
14327 static int py_srvsvc_NetTransportInfo0_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14328 {
14329         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14330         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14331         object->vcs = PyInt_AsLong(value);
14332         return 0;
14333 }
14334
14335 static PyObject *py_srvsvc_NetTransportInfo0_get_name(PyObject *obj, void *closure)
14336 {
14337         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14338         PyObject *py_name;
14339         if (object->name == NULL) {
14340                 py_name = Py_None;
14341                 Py_INCREF(py_name);
14342         } else {
14343                 if (object->name == NULL) {
14344                         py_name = Py_None;
14345                         Py_INCREF(py_name);
14346                 } else {
14347                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14348                 }
14349         }
14350         return py_name;
14351 }
14352
14353 static int py_srvsvc_NetTransportInfo0_set_name(PyObject *py_obj, PyObject *value, void *closure)
14354 {
14355         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14356         if (value == Py_None) {
14357                 object->name = NULL;
14358         } else {
14359                 object->name = NULL;
14360                 if (PyUnicode_Check(value)) {
14361                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14362                 } else if (PyString_Check(value)) {
14363                         object->name = PyString_AS_STRING(value);
14364                 } else {
14365                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14366                         return -1;
14367                 }
14368         }
14369         return 0;
14370 }
14371
14372 static PyObject *py_srvsvc_NetTransportInfo0_get_addr(PyObject *obj, void *closure)
14373 {
14374         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14375         PyObject *py_addr;
14376         if (object->addr == NULL) {
14377                 py_addr = Py_None;
14378                 Py_INCREF(py_addr);
14379         } else {
14380                 py_addr = PyList_New(object->addr_len);
14381                 if (py_addr == NULL) {
14382                         return NULL;
14383                 }
14384                 {
14385                         int addr_cntr_1;
14386                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14387                                 PyObject *py_addr_1;
14388                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14389                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14390                         }
14391                 }
14392         }
14393         return py_addr;
14394 }
14395
14396 static int py_srvsvc_NetTransportInfo0_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14397 {
14398         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14399         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14400         if (value == Py_None) {
14401                 object->addr = NULL;
14402         } else {
14403                 object->addr = NULL;
14404                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14405                 {
14406                         int addr_cntr_1;
14407                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14408                         if (!object->addr) { return -1;; }
14409                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14410                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14411                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14412                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14413                         }
14414                 }
14415         }
14416         return 0;
14417 }
14418
14419 static PyObject *py_srvsvc_NetTransportInfo0_get_addr_len(PyObject *obj, void *closure)
14420 {
14421         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14422         PyObject *py_addr_len;
14423         py_addr_len = PyInt_FromLong(object->addr_len);
14424         return py_addr_len;
14425 }
14426
14427 static int py_srvsvc_NetTransportInfo0_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
14428 {
14429         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14430         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14431         object->addr_len = PyInt_AsLong(value);
14432         return 0;
14433 }
14434
14435 static PyObject *py_srvsvc_NetTransportInfo0_get_net_addr(PyObject *obj, void *closure)
14436 {
14437         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(obj);
14438         PyObject *py_net_addr;
14439         if (object->net_addr == NULL) {
14440                 py_net_addr = Py_None;
14441                 Py_INCREF(py_net_addr);
14442         } else {
14443                 if (object->net_addr == NULL) {
14444                         py_net_addr = Py_None;
14445                         Py_INCREF(py_net_addr);
14446                 } else {
14447                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
14448                 }
14449         }
14450         return py_net_addr;
14451 }
14452
14453 static int py_srvsvc_NetTransportInfo0_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
14454 {
14455         struct srvsvc_NetTransportInfo0 *object = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_obj);
14456         if (value == Py_None) {
14457                 object->net_addr = NULL;
14458         } else {
14459                 object->net_addr = NULL;
14460                 if (PyUnicode_Check(value)) {
14461                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14462                 } else if (PyString_Check(value)) {
14463                         object->net_addr = PyString_AS_STRING(value);
14464                 } else {
14465                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14466                         return -1;
14467                 }
14468         }
14469         return 0;
14470 }
14471
14472 static PyGetSetDef py_srvsvc_NetTransportInfo0_getsetters[] = {
14473         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo0_get_vcs, py_srvsvc_NetTransportInfo0_set_vcs },
14474         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo0_get_name, py_srvsvc_NetTransportInfo0_set_name },
14475         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo0_get_addr, py_srvsvc_NetTransportInfo0_set_addr },
14476         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo0_get_addr_len, py_srvsvc_NetTransportInfo0_set_addr_len },
14477         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo0_get_net_addr, py_srvsvc_NetTransportInfo0_set_net_addr },
14478         { NULL }
14479 };
14480
14481 static PyObject *py_srvsvc_NetTransportInfo0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14482 {
14483         return pytalloc_new(struct srvsvc_NetTransportInfo0, type);
14484 }
14485
14486
14487 static PyTypeObject srvsvc_NetTransportInfo0_Type = {
14488         PyObject_HEAD_INIT(NULL) 0,
14489         .tp_name = "srvsvc.NetTransportInfo0",
14490         .tp_getset = py_srvsvc_NetTransportInfo0_getsetters,
14491         .tp_methods = NULL,
14492         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14493         .tp_basicsize = sizeof(pytalloc_Object),
14494         .tp_new = py_srvsvc_NetTransportInfo0_new,
14495 };
14496
14497
14498 static PyObject *py_srvsvc_NetTransportCtr0_get_count(PyObject *obj, void *closure)
14499 {
14500         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
14501         PyObject *py_count;
14502         py_count = PyInt_FromLong(object->count);
14503         return py_count;
14504 }
14505
14506 static int py_srvsvc_NetTransportCtr0_set_count(PyObject *py_obj, PyObject *value, void *closure)
14507 {
14508         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(py_obj);
14509         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14510         object->count = PyInt_AsLong(value);
14511         return 0;
14512 }
14513
14514 static PyObject *py_srvsvc_NetTransportCtr0_get_array(PyObject *obj, void *closure)
14515 {
14516         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(obj);
14517         PyObject *py_array;
14518         if (object->array == NULL) {
14519                 py_array = Py_None;
14520                 Py_INCREF(py_array);
14521         } else {
14522                 py_array = PyList_New(object->count);
14523                 if (py_array == NULL) {
14524                         return NULL;
14525                 }
14526                 {
14527                         int array_cntr_1;
14528                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
14529                                 PyObject *py_array_1;
14530                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, object->array, &object->array[array_cntr_1]);
14531                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
14532                         }
14533                 }
14534         }
14535         return py_array;
14536 }
14537
14538 static int py_srvsvc_NetTransportCtr0_set_array(PyObject *py_obj, PyObject *value, void *closure)
14539 {
14540         struct srvsvc_NetTransportCtr0 *object = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(py_obj);
14541         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
14542         if (value == Py_None) {
14543                 object->array = NULL;
14544         } else {
14545                 object->array = NULL;
14546                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14547                 {
14548                         int array_cntr_1;
14549                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
14550                         if (!object->array) { return -1;; }
14551                         talloc_set_name_const(object->array, "ARRAY: object->array");
14552                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
14553                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
14554                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
14555                                         PyErr_NoMemory();
14556                                         return -1;
14557                                 }
14558                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
14559                         }
14560                 }
14561         }
14562         return 0;
14563 }
14564
14565 static PyGetSetDef py_srvsvc_NetTransportCtr0_getsetters[] = {
14566         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr0_get_count, py_srvsvc_NetTransportCtr0_set_count },
14567         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr0_get_array, py_srvsvc_NetTransportCtr0_set_array },
14568         { NULL }
14569 };
14570
14571 static PyObject *py_srvsvc_NetTransportCtr0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14572 {
14573         return pytalloc_new(struct srvsvc_NetTransportCtr0, type);
14574 }
14575
14576
14577 static PyTypeObject srvsvc_NetTransportCtr0_Type = {
14578         PyObject_HEAD_INIT(NULL) 0,
14579         .tp_name = "srvsvc.NetTransportCtr0",
14580         .tp_getset = py_srvsvc_NetTransportCtr0_getsetters,
14581         .tp_methods = NULL,
14582         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14583         .tp_basicsize = sizeof(pytalloc_Object),
14584         .tp_new = py_srvsvc_NetTransportCtr0_new,
14585 };
14586
14587
14588 static PyObject *py_srvsvc_NetTransportInfo1_get_vcs(PyObject *obj, void *closure)
14589 {
14590         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14591         PyObject *py_vcs;
14592         py_vcs = PyInt_FromLong(object->vcs);
14593         return py_vcs;
14594 }
14595
14596 static int py_srvsvc_NetTransportInfo1_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14597 {
14598         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14599         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14600         object->vcs = PyInt_AsLong(value);
14601         return 0;
14602 }
14603
14604 static PyObject *py_srvsvc_NetTransportInfo1_get_name(PyObject *obj, void *closure)
14605 {
14606         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14607         PyObject *py_name;
14608         if (object->name == NULL) {
14609                 py_name = Py_None;
14610                 Py_INCREF(py_name);
14611         } else {
14612                 if (object->name == NULL) {
14613                         py_name = Py_None;
14614                         Py_INCREF(py_name);
14615                 } else {
14616                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14617                 }
14618         }
14619         return py_name;
14620 }
14621
14622 static int py_srvsvc_NetTransportInfo1_set_name(PyObject *py_obj, PyObject *value, void *closure)
14623 {
14624         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14625         if (value == Py_None) {
14626                 object->name = NULL;
14627         } else {
14628                 object->name = NULL;
14629                 if (PyUnicode_Check(value)) {
14630                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14631                 } else if (PyString_Check(value)) {
14632                         object->name = PyString_AS_STRING(value);
14633                 } else {
14634                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14635                         return -1;
14636                 }
14637         }
14638         return 0;
14639 }
14640
14641 static PyObject *py_srvsvc_NetTransportInfo1_get_addr(PyObject *obj, void *closure)
14642 {
14643         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14644         PyObject *py_addr;
14645         if (object->addr == NULL) {
14646                 py_addr = Py_None;
14647                 Py_INCREF(py_addr);
14648         } else {
14649                 py_addr = PyList_New(object->addr_len);
14650                 if (py_addr == NULL) {
14651                         return NULL;
14652                 }
14653                 {
14654                         int addr_cntr_1;
14655                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14656                                 PyObject *py_addr_1;
14657                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14658                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14659                         }
14660                 }
14661         }
14662         return py_addr;
14663 }
14664
14665 static int py_srvsvc_NetTransportInfo1_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14666 {
14667         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14668         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14669         if (value == Py_None) {
14670                 object->addr = NULL;
14671         } else {
14672                 object->addr = NULL;
14673                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14674                 {
14675                         int addr_cntr_1;
14676                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14677                         if (!object->addr) { return -1;; }
14678                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14679                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14680                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14681                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14682                         }
14683                 }
14684         }
14685         return 0;
14686 }
14687
14688 static PyObject *py_srvsvc_NetTransportInfo1_get_addr_len(PyObject *obj, void *closure)
14689 {
14690         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14691         PyObject *py_addr_len;
14692         py_addr_len = PyInt_FromLong(object->addr_len);
14693         return py_addr_len;
14694 }
14695
14696 static int py_srvsvc_NetTransportInfo1_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
14697 {
14698         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14699         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14700         object->addr_len = PyInt_AsLong(value);
14701         return 0;
14702 }
14703
14704 static PyObject *py_srvsvc_NetTransportInfo1_get_net_addr(PyObject *obj, void *closure)
14705 {
14706         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14707         PyObject *py_net_addr;
14708         if (object->net_addr == NULL) {
14709                 py_net_addr = Py_None;
14710                 Py_INCREF(py_net_addr);
14711         } else {
14712                 if (object->net_addr == NULL) {
14713                         py_net_addr = Py_None;
14714                         Py_INCREF(py_net_addr);
14715                 } else {
14716                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
14717                 }
14718         }
14719         return py_net_addr;
14720 }
14721
14722 static int py_srvsvc_NetTransportInfo1_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
14723 {
14724         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14725         if (value == Py_None) {
14726                 object->net_addr = NULL;
14727         } else {
14728                 object->net_addr = NULL;
14729                 if (PyUnicode_Check(value)) {
14730                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14731                 } else if (PyString_Check(value)) {
14732                         object->net_addr = PyString_AS_STRING(value);
14733                 } else {
14734                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14735                         return -1;
14736                 }
14737         }
14738         return 0;
14739 }
14740
14741 static PyObject *py_srvsvc_NetTransportInfo1_get_domain(PyObject *obj, void *closure)
14742 {
14743         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(obj);
14744         PyObject *py_domain;
14745         if (object->domain == NULL) {
14746                 py_domain = Py_None;
14747                 Py_INCREF(py_domain);
14748         } else {
14749                 if (object->domain == NULL) {
14750                         py_domain = Py_None;
14751                         Py_INCREF(py_domain);
14752                 } else {
14753                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
14754                 }
14755         }
14756         return py_domain;
14757 }
14758
14759 static int py_srvsvc_NetTransportInfo1_set_domain(PyObject *py_obj, PyObject *value, void *closure)
14760 {
14761         struct srvsvc_NetTransportInfo1 *object = (struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(py_obj);
14762         if (value == Py_None) {
14763                 object->domain = NULL;
14764         } else {
14765                 object->domain = NULL;
14766                 if (PyUnicode_Check(value)) {
14767                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14768                 } else if (PyString_Check(value)) {
14769                         object->domain = PyString_AS_STRING(value);
14770                 } else {
14771                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14772                         return -1;
14773                 }
14774         }
14775         return 0;
14776 }
14777
14778 static PyGetSetDef py_srvsvc_NetTransportInfo1_getsetters[] = {
14779         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo1_get_vcs, py_srvsvc_NetTransportInfo1_set_vcs },
14780         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo1_get_name, py_srvsvc_NetTransportInfo1_set_name },
14781         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo1_get_addr, py_srvsvc_NetTransportInfo1_set_addr },
14782         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo1_get_addr_len, py_srvsvc_NetTransportInfo1_set_addr_len },
14783         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo1_get_net_addr, py_srvsvc_NetTransportInfo1_set_net_addr },
14784         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo1_get_domain, py_srvsvc_NetTransportInfo1_set_domain },
14785         { NULL }
14786 };
14787
14788 static PyObject *py_srvsvc_NetTransportInfo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14789 {
14790         return pytalloc_new(struct srvsvc_NetTransportInfo1, type);
14791 }
14792
14793
14794 static PyTypeObject srvsvc_NetTransportInfo1_Type = {
14795         PyObject_HEAD_INIT(NULL) 0,
14796         .tp_name = "srvsvc.NetTransportInfo1",
14797         .tp_getset = py_srvsvc_NetTransportInfo1_getsetters,
14798         .tp_methods = NULL,
14799         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14800         .tp_basicsize = sizeof(pytalloc_Object),
14801         .tp_new = py_srvsvc_NetTransportInfo1_new,
14802 };
14803
14804
14805 static PyObject *py_srvsvc_NetTransportCtr1_get_count(PyObject *obj, void *closure)
14806 {
14807         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
14808         PyObject *py_count;
14809         py_count = PyInt_FromLong(object->count);
14810         return py_count;
14811 }
14812
14813 static int py_srvsvc_NetTransportCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
14814 {
14815         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(py_obj);
14816         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14817         object->count = PyInt_AsLong(value);
14818         return 0;
14819 }
14820
14821 static PyObject *py_srvsvc_NetTransportCtr1_get_array(PyObject *obj, void *closure)
14822 {
14823         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(obj);
14824         PyObject *py_array;
14825         if (object->array == NULL) {
14826                 py_array = Py_None;
14827                 Py_INCREF(py_array);
14828         } else {
14829                 py_array = PyList_New(object->count);
14830                 if (py_array == NULL) {
14831                         return NULL;
14832                 }
14833                 {
14834                         int array_cntr_1;
14835                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
14836                                 PyObject *py_array_1;
14837                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, object->array, &object->array[array_cntr_1]);
14838                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
14839                         }
14840                 }
14841         }
14842         return py_array;
14843 }
14844
14845 static int py_srvsvc_NetTransportCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
14846 {
14847         struct srvsvc_NetTransportCtr1 *object = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(py_obj);
14848         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
14849         if (value == Py_None) {
14850                 object->array = NULL;
14851         } else {
14852                 object->array = NULL;
14853                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14854                 {
14855                         int array_cntr_1;
14856                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
14857                         if (!object->array) { return -1;; }
14858                         talloc_set_name_const(object->array, "ARRAY: object->array");
14859                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
14860                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
14861                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
14862                                         PyErr_NoMemory();
14863                                         return -1;
14864                                 }
14865                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
14866                         }
14867                 }
14868         }
14869         return 0;
14870 }
14871
14872 static PyGetSetDef py_srvsvc_NetTransportCtr1_getsetters[] = {
14873         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr1_get_count, py_srvsvc_NetTransportCtr1_set_count },
14874         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr1_get_array, py_srvsvc_NetTransportCtr1_set_array },
14875         { NULL }
14876 };
14877
14878 static PyObject *py_srvsvc_NetTransportCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
14879 {
14880         return pytalloc_new(struct srvsvc_NetTransportCtr1, type);
14881 }
14882
14883
14884 static PyTypeObject srvsvc_NetTransportCtr1_Type = {
14885         PyObject_HEAD_INIT(NULL) 0,
14886         .tp_name = "srvsvc.NetTransportCtr1",
14887         .tp_getset = py_srvsvc_NetTransportCtr1_getsetters,
14888         .tp_methods = NULL,
14889         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
14890         .tp_basicsize = sizeof(pytalloc_Object),
14891         .tp_new = py_srvsvc_NetTransportCtr1_new,
14892 };
14893
14894
14895 static PyObject *py_srvsvc_NetTransportInfo2_get_vcs(PyObject *obj, void *closure)
14896 {
14897         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14898         PyObject *py_vcs;
14899         py_vcs = PyInt_FromLong(object->vcs);
14900         return py_vcs;
14901 }
14902
14903 static int py_srvsvc_NetTransportInfo2_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
14904 {
14905         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14906         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
14907         object->vcs = PyInt_AsLong(value);
14908         return 0;
14909 }
14910
14911 static PyObject *py_srvsvc_NetTransportInfo2_get_name(PyObject *obj, void *closure)
14912 {
14913         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14914         PyObject *py_name;
14915         if (object->name == NULL) {
14916                 py_name = Py_None;
14917                 Py_INCREF(py_name);
14918         } else {
14919                 if (object->name == NULL) {
14920                         py_name = Py_None;
14921                         Py_INCREF(py_name);
14922                 } else {
14923                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
14924                 }
14925         }
14926         return py_name;
14927 }
14928
14929 static int py_srvsvc_NetTransportInfo2_set_name(PyObject *py_obj, PyObject *value, void *closure)
14930 {
14931         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14932         if (value == Py_None) {
14933                 object->name = NULL;
14934         } else {
14935                 object->name = NULL;
14936                 if (PyUnicode_Check(value)) {
14937                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
14938                 } else if (PyString_Check(value)) {
14939                         object->name = PyString_AS_STRING(value);
14940                 } else {
14941                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
14942                         return -1;
14943                 }
14944         }
14945         return 0;
14946 }
14947
14948 static PyObject *py_srvsvc_NetTransportInfo2_get_addr(PyObject *obj, void *closure)
14949 {
14950         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14951         PyObject *py_addr;
14952         if (object->addr == NULL) {
14953                 py_addr = Py_None;
14954                 Py_INCREF(py_addr);
14955         } else {
14956                 py_addr = PyList_New(object->addr_len);
14957                 if (py_addr == NULL) {
14958                         return NULL;
14959                 }
14960                 {
14961                         int addr_cntr_1;
14962                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
14963                                 PyObject *py_addr_1;
14964                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
14965                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
14966                         }
14967                 }
14968         }
14969         return py_addr;
14970 }
14971
14972 static int py_srvsvc_NetTransportInfo2_set_addr(PyObject *py_obj, PyObject *value, void *closure)
14973 {
14974         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
14975         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
14976         if (value == Py_None) {
14977                 object->addr = NULL;
14978         } else {
14979                 object->addr = NULL;
14980                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
14981                 {
14982                         int addr_cntr_1;
14983                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
14984                         if (!object->addr) { return -1;; }
14985                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
14986                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
14987                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
14988                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
14989                         }
14990                 }
14991         }
14992         return 0;
14993 }
14994
14995 static PyObject *py_srvsvc_NetTransportInfo2_get_addr_len(PyObject *obj, void *closure)
14996 {
14997         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
14998         PyObject *py_addr_len;
14999         py_addr_len = PyInt_FromLong(object->addr_len);
15000         return py_addr_len;
15001 }
15002
15003 static int py_srvsvc_NetTransportInfo2_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
15004 {
15005         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15006         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15007         object->addr_len = PyInt_AsLong(value);
15008         return 0;
15009 }
15010
15011 static PyObject *py_srvsvc_NetTransportInfo2_get_net_addr(PyObject *obj, void *closure)
15012 {
15013         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15014         PyObject *py_net_addr;
15015         if (object->net_addr == NULL) {
15016                 py_net_addr = Py_None;
15017                 Py_INCREF(py_net_addr);
15018         } else {
15019                 if (object->net_addr == NULL) {
15020                         py_net_addr = Py_None;
15021                         Py_INCREF(py_net_addr);
15022                 } else {
15023                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
15024                 }
15025         }
15026         return py_net_addr;
15027 }
15028
15029 static int py_srvsvc_NetTransportInfo2_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
15030 {
15031         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15032         if (value == Py_None) {
15033                 object->net_addr = NULL;
15034         } else {
15035                 object->net_addr = NULL;
15036                 if (PyUnicode_Check(value)) {
15037                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15038                 } else if (PyString_Check(value)) {
15039                         object->net_addr = PyString_AS_STRING(value);
15040                 } else {
15041                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15042                         return -1;
15043                 }
15044         }
15045         return 0;
15046 }
15047
15048 static PyObject *py_srvsvc_NetTransportInfo2_get_domain(PyObject *obj, void *closure)
15049 {
15050         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15051         PyObject *py_domain;
15052         if (object->domain == NULL) {
15053                 py_domain = Py_None;
15054                 Py_INCREF(py_domain);
15055         } else {
15056                 if (object->domain == NULL) {
15057                         py_domain = Py_None;
15058                         Py_INCREF(py_domain);
15059                 } else {
15060                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
15061                 }
15062         }
15063         return py_domain;
15064 }
15065
15066 static int py_srvsvc_NetTransportInfo2_set_domain(PyObject *py_obj, PyObject *value, void *closure)
15067 {
15068         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15069         if (value == Py_None) {
15070                 object->domain = NULL;
15071         } else {
15072                 object->domain = NULL;
15073                 if (PyUnicode_Check(value)) {
15074                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15075                 } else if (PyString_Check(value)) {
15076                         object->domain = PyString_AS_STRING(value);
15077                 } else {
15078                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15079                         return -1;
15080                 }
15081         }
15082         return 0;
15083 }
15084
15085 static PyObject *py_srvsvc_NetTransportInfo2_get_unknown(PyObject *obj, void *closure)
15086 {
15087         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(obj);
15088         PyObject *py_unknown;
15089         py_unknown = PyInt_FromLong(object->unknown);
15090         return py_unknown;
15091 }
15092
15093 static int py_srvsvc_NetTransportInfo2_set_unknown(PyObject *py_obj, PyObject *value, void *closure)
15094 {
15095         struct srvsvc_NetTransportInfo2 *object = (struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(py_obj);
15096         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15097         object->unknown = PyInt_AsLong(value);
15098         return 0;
15099 }
15100
15101 static PyGetSetDef py_srvsvc_NetTransportInfo2_getsetters[] = {
15102         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo2_get_vcs, py_srvsvc_NetTransportInfo2_set_vcs },
15103         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo2_get_name, py_srvsvc_NetTransportInfo2_set_name },
15104         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo2_get_addr, py_srvsvc_NetTransportInfo2_set_addr },
15105         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo2_get_addr_len, py_srvsvc_NetTransportInfo2_set_addr_len },
15106         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo2_get_net_addr, py_srvsvc_NetTransportInfo2_set_net_addr },
15107         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo2_get_domain, py_srvsvc_NetTransportInfo2_set_domain },
15108         { discard_const_p(char, "unknown"), py_srvsvc_NetTransportInfo2_get_unknown, py_srvsvc_NetTransportInfo2_set_unknown },
15109         { NULL }
15110 };
15111
15112 static PyObject *py_srvsvc_NetTransportInfo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15113 {
15114         return pytalloc_new(struct srvsvc_NetTransportInfo2, type);
15115 }
15116
15117
15118 static PyTypeObject srvsvc_NetTransportInfo2_Type = {
15119         PyObject_HEAD_INIT(NULL) 0,
15120         .tp_name = "srvsvc.NetTransportInfo2",
15121         .tp_getset = py_srvsvc_NetTransportInfo2_getsetters,
15122         .tp_methods = NULL,
15123         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15124         .tp_basicsize = sizeof(pytalloc_Object),
15125         .tp_new = py_srvsvc_NetTransportInfo2_new,
15126 };
15127
15128
15129 static PyObject *py_srvsvc_NetTransportCtr2_get_count(PyObject *obj, void *closure)
15130 {
15131         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
15132         PyObject *py_count;
15133         py_count = PyInt_FromLong(object->count);
15134         return py_count;
15135 }
15136
15137 static int py_srvsvc_NetTransportCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
15138 {
15139         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(py_obj);
15140         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15141         object->count = PyInt_AsLong(value);
15142         return 0;
15143 }
15144
15145 static PyObject *py_srvsvc_NetTransportCtr2_get_array(PyObject *obj, void *closure)
15146 {
15147         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(obj);
15148         PyObject *py_array;
15149         if (object->array == NULL) {
15150                 py_array = Py_None;
15151                 Py_INCREF(py_array);
15152         } else {
15153                 py_array = PyList_New(object->count);
15154                 if (py_array == NULL) {
15155                         return NULL;
15156                 }
15157                 {
15158                         int array_cntr_1;
15159                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
15160                                 PyObject *py_array_1;
15161                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, object->array, &object->array[array_cntr_1]);
15162                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
15163                         }
15164                 }
15165         }
15166         return py_array;
15167 }
15168
15169 static int py_srvsvc_NetTransportCtr2_set_array(PyObject *py_obj, PyObject *value, void *closure)
15170 {
15171         struct srvsvc_NetTransportCtr2 *object = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(py_obj);
15172         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
15173         if (value == Py_None) {
15174                 object->array = NULL;
15175         } else {
15176                 object->array = NULL;
15177                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15178                 {
15179                         int array_cntr_1;
15180                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
15181                         if (!object->array) { return -1;; }
15182                         talloc_set_name_const(object->array, "ARRAY: object->array");
15183                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
15184                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
15185                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
15186                                         PyErr_NoMemory();
15187                                         return -1;
15188                                 }
15189                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
15190                         }
15191                 }
15192         }
15193         return 0;
15194 }
15195
15196 static PyGetSetDef py_srvsvc_NetTransportCtr2_getsetters[] = {
15197         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr2_get_count, py_srvsvc_NetTransportCtr2_set_count },
15198         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr2_get_array, py_srvsvc_NetTransportCtr2_set_array },
15199         { NULL }
15200 };
15201
15202 static PyObject *py_srvsvc_NetTransportCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15203 {
15204         return pytalloc_new(struct srvsvc_NetTransportCtr2, type);
15205 }
15206
15207
15208 static PyTypeObject srvsvc_NetTransportCtr2_Type = {
15209         PyObject_HEAD_INIT(NULL) 0,
15210         .tp_name = "srvsvc.NetTransportCtr2",
15211         .tp_getset = py_srvsvc_NetTransportCtr2_getsetters,
15212         .tp_methods = NULL,
15213         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15214         .tp_basicsize = sizeof(pytalloc_Object),
15215         .tp_new = py_srvsvc_NetTransportCtr2_new,
15216 };
15217
15218
15219 static PyObject *py_srvsvc_NetTransportInfo3_get_vcs(PyObject *obj, void *closure)
15220 {
15221         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15222         PyObject *py_vcs;
15223         py_vcs = PyInt_FromLong(object->vcs);
15224         return py_vcs;
15225 }
15226
15227 static int py_srvsvc_NetTransportInfo3_set_vcs(PyObject *py_obj, PyObject *value, void *closure)
15228 {
15229         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15230         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15231         object->vcs = PyInt_AsLong(value);
15232         return 0;
15233 }
15234
15235 static PyObject *py_srvsvc_NetTransportInfo3_get_name(PyObject *obj, void *closure)
15236 {
15237         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15238         PyObject *py_name;
15239         if (object->name == NULL) {
15240                 py_name = Py_None;
15241                 Py_INCREF(py_name);
15242         } else {
15243                 if (object->name == NULL) {
15244                         py_name = Py_None;
15245                         Py_INCREF(py_name);
15246                 } else {
15247                         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
15248                 }
15249         }
15250         return py_name;
15251 }
15252
15253 static int py_srvsvc_NetTransportInfo3_set_name(PyObject *py_obj, PyObject *value, void *closure)
15254 {
15255         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15256         if (value == Py_None) {
15257                 object->name = NULL;
15258         } else {
15259                 object->name = NULL;
15260                 if (PyUnicode_Check(value)) {
15261                         object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15262                 } else if (PyString_Check(value)) {
15263                         object->name = PyString_AS_STRING(value);
15264                 } else {
15265                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15266                         return -1;
15267                 }
15268         }
15269         return 0;
15270 }
15271
15272 static PyObject *py_srvsvc_NetTransportInfo3_get_addr(PyObject *obj, void *closure)
15273 {
15274         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15275         PyObject *py_addr;
15276         if (object->addr == NULL) {
15277                 py_addr = Py_None;
15278                 Py_INCREF(py_addr);
15279         } else {
15280                 py_addr = PyList_New(object->addr_len);
15281                 if (py_addr == NULL) {
15282                         return NULL;
15283                 }
15284                 {
15285                         int addr_cntr_1;
15286                         for (addr_cntr_1 = 0; addr_cntr_1 < object->addr_len; addr_cntr_1++) {
15287                                 PyObject *py_addr_1;
15288                                 py_addr_1 = PyInt_FromLong(object->addr[addr_cntr_1]);
15289                                 PyList_SetItem(py_addr, addr_cntr_1, py_addr_1);
15290                         }
15291                 }
15292         }
15293         return py_addr;
15294 }
15295
15296 static int py_srvsvc_NetTransportInfo3_set_addr(PyObject *py_obj, PyObject *value, void *closure)
15297 {
15298         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15299         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->addr);
15300         if (value == Py_None) {
15301                 object->addr = NULL;
15302         } else {
15303                 object->addr = NULL;
15304                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15305                 {
15306                         int addr_cntr_1;
15307                         object->addr = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addr, PyList_GET_SIZE(value));
15308                         if (!object->addr) { return -1;; }
15309                         talloc_set_name_const(object->addr, "ARRAY: object->addr");
15310                         for (addr_cntr_1 = 0; addr_cntr_1 < PyList_GET_SIZE(value); addr_cntr_1++) {
15311                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, addr_cntr_1), return -1;);
15312                                 object->addr[addr_cntr_1] = PyInt_AsLong(PyList_GET_ITEM(value, addr_cntr_1));
15313                         }
15314                 }
15315         }
15316         return 0;
15317 }
15318
15319 static PyObject *py_srvsvc_NetTransportInfo3_get_addr_len(PyObject *obj, void *closure)
15320 {
15321         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15322         PyObject *py_addr_len;
15323         py_addr_len = PyInt_FromLong(object->addr_len);
15324         return py_addr_len;
15325 }
15326
15327 static int py_srvsvc_NetTransportInfo3_set_addr_len(PyObject *py_obj, PyObject *value, void *closure)
15328 {
15329         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15330         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15331         object->addr_len = PyInt_AsLong(value);
15332         return 0;
15333 }
15334
15335 static PyObject *py_srvsvc_NetTransportInfo3_get_net_addr(PyObject *obj, void *closure)
15336 {
15337         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15338         PyObject *py_net_addr;
15339         if (object->net_addr == NULL) {
15340                 py_net_addr = Py_None;
15341                 Py_INCREF(py_net_addr);
15342         } else {
15343                 if (object->net_addr == NULL) {
15344                         py_net_addr = Py_None;
15345                         Py_INCREF(py_net_addr);
15346                 } else {
15347                         py_net_addr = PyUnicode_Decode(object->net_addr, strlen(object->net_addr), "utf-8", "ignore");
15348                 }
15349         }
15350         return py_net_addr;
15351 }
15352
15353 static int py_srvsvc_NetTransportInfo3_set_net_addr(PyObject *py_obj, PyObject *value, void *closure)
15354 {
15355         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15356         if (value == Py_None) {
15357                 object->net_addr = NULL;
15358         } else {
15359                 object->net_addr = NULL;
15360                 if (PyUnicode_Check(value)) {
15361                         object->net_addr = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15362                 } else if (PyString_Check(value)) {
15363                         object->net_addr = PyString_AS_STRING(value);
15364                 } else {
15365                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15366                         return -1;
15367                 }
15368         }
15369         return 0;
15370 }
15371
15372 static PyObject *py_srvsvc_NetTransportInfo3_get_domain(PyObject *obj, void *closure)
15373 {
15374         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15375         PyObject *py_domain;
15376         if (object->domain == NULL) {
15377                 py_domain = Py_None;
15378                 Py_INCREF(py_domain);
15379         } else {
15380                 if (object->domain == NULL) {
15381                         py_domain = Py_None;
15382                         Py_INCREF(py_domain);
15383                 } else {
15384                         py_domain = PyUnicode_Decode(object->domain, strlen(object->domain), "utf-8", "ignore");
15385                 }
15386         }
15387         return py_domain;
15388 }
15389
15390 static int py_srvsvc_NetTransportInfo3_set_domain(PyObject *py_obj, PyObject *value, void *closure)
15391 {
15392         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15393         if (value == Py_None) {
15394                 object->domain = NULL;
15395         } else {
15396                 object->domain = NULL;
15397                 if (PyUnicode_Check(value)) {
15398                         object->domain = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
15399                 } else if (PyString_Check(value)) {
15400                         object->domain = PyString_AS_STRING(value);
15401                 } else {
15402                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
15403                         return -1;
15404                 }
15405         }
15406         return 0;
15407 }
15408
15409 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown1(PyObject *obj, void *closure)
15410 {
15411         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15412         PyObject *py_unknown1;
15413         py_unknown1 = PyInt_FromLong(object->unknown1);
15414         return py_unknown1;
15415 }
15416
15417 static int py_srvsvc_NetTransportInfo3_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
15418 {
15419         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15420         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15421         object->unknown1 = PyInt_AsLong(value);
15422         return 0;
15423 }
15424
15425 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown2(PyObject *obj, void *closure)
15426 {
15427         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15428         PyObject *py_unknown2;
15429         py_unknown2 = PyInt_FromLong(object->unknown2);
15430         return py_unknown2;
15431 }
15432
15433 static int py_srvsvc_NetTransportInfo3_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
15434 {
15435         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15436         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15437         object->unknown2 = PyInt_AsLong(value);
15438         return 0;
15439 }
15440
15441 static PyObject *py_srvsvc_NetTransportInfo3_get_unknown3(PyObject *obj, void *closure)
15442 {
15443         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(obj);
15444         PyObject *py_unknown3;
15445         py_unknown3 = PyList_New(256);
15446         if (py_unknown3 == NULL) {
15447                 return NULL;
15448         }
15449         {
15450                 int unknown3_cntr_0;
15451                 for (unknown3_cntr_0 = 0; unknown3_cntr_0 < 256; unknown3_cntr_0++) {
15452                         PyObject *py_unknown3_0;
15453                         py_unknown3_0 = PyInt_FromLong(object->unknown3[unknown3_cntr_0]);
15454                         PyList_SetItem(py_unknown3, unknown3_cntr_0, py_unknown3_0);
15455                 }
15456         }
15457         return py_unknown3;
15458 }
15459
15460 static int py_srvsvc_NetTransportInfo3_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
15461 {
15462         struct srvsvc_NetTransportInfo3 *object = (struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(py_obj);
15463         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15464         {
15465                 int unknown3_cntr_0;
15466                 for (unknown3_cntr_0 = 0; unknown3_cntr_0 < PyList_GET_SIZE(value); unknown3_cntr_0++) {
15467                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, unknown3_cntr_0), return -1;);
15468                         object->unknown3[unknown3_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, unknown3_cntr_0));
15469                 }
15470         }
15471         return 0;
15472 }
15473
15474 static PyGetSetDef py_srvsvc_NetTransportInfo3_getsetters[] = {
15475         { discard_const_p(char, "vcs"), py_srvsvc_NetTransportInfo3_get_vcs, py_srvsvc_NetTransportInfo3_set_vcs },
15476         { discard_const_p(char, "name"), py_srvsvc_NetTransportInfo3_get_name, py_srvsvc_NetTransportInfo3_set_name },
15477         { discard_const_p(char, "addr"), py_srvsvc_NetTransportInfo3_get_addr, py_srvsvc_NetTransportInfo3_set_addr },
15478         { discard_const_p(char, "addr_len"), py_srvsvc_NetTransportInfo3_get_addr_len, py_srvsvc_NetTransportInfo3_set_addr_len },
15479         { discard_const_p(char, "net_addr"), py_srvsvc_NetTransportInfo3_get_net_addr, py_srvsvc_NetTransportInfo3_set_net_addr },
15480         { discard_const_p(char, "domain"), py_srvsvc_NetTransportInfo3_get_domain, py_srvsvc_NetTransportInfo3_set_domain },
15481         { discard_const_p(char, "unknown1"), py_srvsvc_NetTransportInfo3_get_unknown1, py_srvsvc_NetTransportInfo3_set_unknown1 },
15482         { discard_const_p(char, "unknown2"), py_srvsvc_NetTransportInfo3_get_unknown2, py_srvsvc_NetTransportInfo3_set_unknown2 },
15483         { discard_const_p(char, "unknown3"), py_srvsvc_NetTransportInfo3_get_unknown3, py_srvsvc_NetTransportInfo3_set_unknown3 },
15484         { NULL }
15485 };
15486
15487 static PyObject *py_srvsvc_NetTransportInfo3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15488 {
15489         return pytalloc_new(struct srvsvc_NetTransportInfo3, type);
15490 }
15491
15492
15493 static PyTypeObject srvsvc_NetTransportInfo3_Type = {
15494         PyObject_HEAD_INIT(NULL) 0,
15495         .tp_name = "srvsvc.NetTransportInfo3",
15496         .tp_getset = py_srvsvc_NetTransportInfo3_getsetters,
15497         .tp_methods = NULL,
15498         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15499         .tp_basicsize = sizeof(pytalloc_Object),
15500         .tp_new = py_srvsvc_NetTransportInfo3_new,
15501 };
15502
15503
15504 static PyObject *py_srvsvc_NetTransportCtr3_get_count(PyObject *obj, void *closure)
15505 {
15506         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
15507         PyObject *py_count;
15508         py_count = PyInt_FromLong(object->count);
15509         return py_count;
15510 }
15511
15512 static int py_srvsvc_NetTransportCtr3_set_count(PyObject *py_obj, PyObject *value, void *closure)
15513 {
15514         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(py_obj);
15515         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15516         object->count = PyInt_AsLong(value);
15517         return 0;
15518 }
15519
15520 static PyObject *py_srvsvc_NetTransportCtr3_get_array(PyObject *obj, void *closure)
15521 {
15522         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(obj);
15523         PyObject *py_array;
15524         if (object->array == NULL) {
15525                 py_array = Py_None;
15526                 Py_INCREF(py_array);
15527         } else {
15528                 py_array = PyList_New(object->count);
15529                 if (py_array == NULL) {
15530                         return NULL;
15531                 }
15532                 {
15533                         int array_cntr_1;
15534                         for (array_cntr_1 = 0; array_cntr_1 < object->count; array_cntr_1++) {
15535                                 PyObject *py_array_1;
15536                                 py_array_1 = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, object->array, &object->array[array_cntr_1]);
15537                                 PyList_SetItem(py_array, array_cntr_1, py_array_1);
15538                         }
15539                 }
15540         }
15541         return py_array;
15542 }
15543
15544 static int py_srvsvc_NetTransportCtr3_set_array(PyObject *py_obj, PyObject *value, void *closure)
15545 {
15546         struct srvsvc_NetTransportCtr3 *object = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(py_obj);
15547         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->array);
15548         if (value == Py_None) {
15549                 object->array = NULL;
15550         } else {
15551                 object->array = NULL;
15552                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
15553                 {
15554                         int array_cntr_1;
15555                         object->array = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->array, PyList_GET_SIZE(value));
15556                         if (!object->array) { return -1;; }
15557                         talloc_set_name_const(object->array, "ARRAY: object->array");
15558                         for (array_cntr_1 = 0; array_cntr_1 < PyList_GET_SIZE(value); array_cntr_1++) {
15559                                 PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, PyList_GET_ITEM(value, array_cntr_1), return -1;);
15560                                 if (talloc_reference(object->array, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, array_cntr_1))) == NULL) {
15561                                         PyErr_NoMemory();
15562                                         return -1;
15563                                 }
15564                                 object->array[array_cntr_1] = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(PyList_GET_ITEM(value, array_cntr_1));
15565                         }
15566                 }
15567         }
15568         return 0;
15569 }
15570
15571 static PyGetSetDef py_srvsvc_NetTransportCtr3_getsetters[] = {
15572         { discard_const_p(char, "count"), py_srvsvc_NetTransportCtr3_get_count, py_srvsvc_NetTransportCtr3_set_count },
15573         { discard_const_p(char, "array"), py_srvsvc_NetTransportCtr3_get_array, py_srvsvc_NetTransportCtr3_set_array },
15574         { NULL }
15575 };
15576
15577 static PyObject *py_srvsvc_NetTransportCtr3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15578 {
15579         return pytalloc_new(struct srvsvc_NetTransportCtr3, type);
15580 }
15581
15582
15583 static PyTypeObject srvsvc_NetTransportCtr3_Type = {
15584         PyObject_HEAD_INIT(NULL) 0,
15585         .tp_name = "srvsvc.NetTransportCtr3",
15586         .tp_getset = py_srvsvc_NetTransportCtr3_getsetters,
15587         .tp_methods = NULL,
15588         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15589         .tp_basicsize = sizeof(pytalloc_Object),
15590         .tp_new = py_srvsvc_NetTransportCtr3_new,
15591 };
15592
15593 PyObject *py_import_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportCtr *in)
15594 {
15595         PyObject *ret;
15596
15597         switch (level) {
15598                 case 0:
15599                         if (in->ctr0 == NULL) {
15600                                 ret = Py_None;
15601                                 Py_INCREF(ret);
15602                         } else {
15603                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr0_Type, in->ctr0, in->ctr0);
15604                         }
15605                         return ret;
15606
15607                 case 1:
15608                         if (in->ctr1 == NULL) {
15609                                 ret = Py_None;
15610                                 Py_INCREF(ret);
15611                         } else {
15612                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr1_Type, in->ctr1, in->ctr1);
15613                         }
15614                         return ret;
15615
15616                 case 2:
15617                         if (in->ctr2 == NULL) {
15618                                 ret = Py_None;
15619                                 Py_INCREF(ret);
15620                         } else {
15621                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr2_Type, in->ctr2, in->ctr2);
15622                         }
15623                         return ret;
15624
15625                 case 3:
15626                         if (in->ctr3 == NULL) {
15627                                 ret = Py_None;
15628                                 Py_INCREF(ret);
15629                         } else {
15630                                 ret = pytalloc_reference_ex(&srvsvc_NetTransportCtr3_Type, in->ctr3, in->ctr3);
15631                         }
15632                         return ret;
15633
15634                 default:
15635                         ret = Py_None;
15636                         Py_INCREF(ret);
15637                         return ret;
15638
15639         }
15640         PyErr_SetString(PyExc_TypeError, "unknown union level");
15641         return NULL;
15642 }
15643
15644 union srvsvc_NetTransportCtr *py_export_srvsvc_NetTransportCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
15645 {
15646         union srvsvc_NetTransportCtr *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportCtr);
15647         switch (level) {
15648                 case 0:
15649                         if (in == Py_None) {
15650                                 ret->ctr0 = NULL;
15651                         } else {
15652                                 ret->ctr0 = NULL;
15653                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr0_Type, in, talloc_free(ret); return NULL;);
15654                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15655                                         PyErr_NoMemory();
15656                                         talloc_free(ret); return NULL;
15657                                 }
15658                                 ret->ctr0 = (struct srvsvc_NetTransportCtr0 *)pytalloc_get_ptr(in);
15659                         }
15660                         break;
15661
15662                 case 1:
15663                         if (in == Py_None) {
15664                                 ret->ctr1 = NULL;
15665                         } else {
15666                                 ret->ctr1 = NULL;
15667                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr1_Type, in, talloc_free(ret); return NULL;);
15668                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15669                                         PyErr_NoMemory();
15670                                         talloc_free(ret); return NULL;
15671                                 }
15672                                 ret->ctr1 = (struct srvsvc_NetTransportCtr1 *)pytalloc_get_ptr(in);
15673                         }
15674                         break;
15675
15676                 case 2:
15677                         if (in == Py_None) {
15678                                 ret->ctr2 = NULL;
15679                         } else {
15680                                 ret->ctr2 = NULL;
15681                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr2_Type, in, talloc_free(ret); return NULL;);
15682                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15683                                         PyErr_NoMemory();
15684                                         talloc_free(ret); return NULL;
15685                                 }
15686                                 ret->ctr2 = (struct srvsvc_NetTransportCtr2 *)pytalloc_get_ptr(in);
15687                         }
15688                         break;
15689
15690                 case 3:
15691                         if (in == Py_None) {
15692                                 ret->ctr3 = NULL;
15693                         } else {
15694                                 ret->ctr3 = NULL;
15695                                 PY_CHECK_TYPE(&srvsvc_NetTransportCtr3_Type, in, talloc_free(ret); return NULL;);
15696                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
15697                                         PyErr_NoMemory();
15698                                         talloc_free(ret); return NULL;
15699                                 }
15700                                 ret->ctr3 = (struct srvsvc_NetTransportCtr3 *)pytalloc_get_ptr(in);
15701                         }
15702                         break;
15703
15704                 default:
15705                         break;
15706
15707         }
15708
15709         return ret;
15710 }
15711
15712
15713 static PyObject *py_srvsvc_NetTransportInfoCtr_get_level(PyObject *obj, void *closure)
15714 {
15715         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
15716         PyObject *py_level;
15717         py_level = PyInt_FromLong(object->level);
15718         return py_level;
15719 }
15720
15721 static int py_srvsvc_NetTransportInfoCtr_set_level(PyObject *py_obj, PyObject *value, void *closure)
15722 {
15723         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_obj);
15724         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15725         object->level = PyInt_AsLong(value);
15726         return 0;
15727 }
15728
15729 static PyObject *py_srvsvc_NetTransportInfoCtr_get_ctr(PyObject *obj, void *closure)
15730 {
15731         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(obj);
15732         PyObject *py_ctr;
15733         py_ctr = py_import_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(obj), object->level, &object->ctr);
15734         if (py_ctr == NULL) {
15735                 return NULL;
15736         }
15737         return py_ctr;
15738 }
15739
15740 static int py_srvsvc_NetTransportInfoCtr_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
15741 {
15742         struct srvsvc_NetTransportInfoCtr *object = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_obj);
15743         {
15744                 union srvsvc_NetTransportCtr *ctr_switch_0;
15745                 ctr_switch_0 = py_export_srvsvc_NetTransportCtr(pytalloc_get_mem_ctx(py_obj), object->level, value);
15746                 if (ctr_switch_0 == NULL) {
15747                         return -1;
15748                 }
15749                 object->ctr = *ctr_switch_0;
15750         }
15751         return 0;
15752 }
15753
15754 static PyGetSetDef py_srvsvc_NetTransportInfoCtr_getsetters[] = {
15755         { discard_const_p(char, "level"), py_srvsvc_NetTransportInfoCtr_get_level, py_srvsvc_NetTransportInfoCtr_set_level },
15756         { discard_const_p(char, "ctr"), py_srvsvc_NetTransportInfoCtr_get_ctr, py_srvsvc_NetTransportInfoCtr_set_ctr },
15757         { NULL }
15758 };
15759
15760 static PyObject *py_srvsvc_NetTransportInfoCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15761 {
15762         return pytalloc_new(struct srvsvc_NetTransportInfoCtr, type);
15763 }
15764
15765
15766 static PyTypeObject srvsvc_NetTransportInfoCtr_Type = {
15767         PyObject_HEAD_INIT(NULL) 0,
15768         .tp_name = "srvsvc.NetTransportInfoCtr",
15769         .tp_getset = py_srvsvc_NetTransportInfoCtr_getsetters,
15770         .tp_methods = NULL,
15771         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15772         .tp_basicsize = sizeof(pytalloc_Object),
15773         .tp_new = py_srvsvc_NetTransportInfoCtr_new,
15774 };
15775
15776
15777 static PyObject *py_srvsvc_NetRemoteTODInfo_get_elapsed(PyObject *obj, void *closure)
15778 {
15779         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15780         PyObject *py_elapsed;
15781         py_elapsed = PyInt_FromLong(object->elapsed);
15782         return py_elapsed;
15783 }
15784
15785 static int py_srvsvc_NetRemoteTODInfo_set_elapsed(PyObject *py_obj, PyObject *value, void *closure)
15786 {
15787         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15788         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15789         object->elapsed = PyInt_AsLong(value);
15790         return 0;
15791 }
15792
15793 static PyObject *py_srvsvc_NetRemoteTODInfo_get_msecs(PyObject *obj, void *closure)
15794 {
15795         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15796         PyObject *py_msecs;
15797         py_msecs = PyInt_FromLong(object->msecs);
15798         return py_msecs;
15799 }
15800
15801 static int py_srvsvc_NetRemoteTODInfo_set_msecs(PyObject *py_obj, PyObject *value, void *closure)
15802 {
15803         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15804         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15805         object->msecs = PyInt_AsLong(value);
15806         return 0;
15807 }
15808
15809 static PyObject *py_srvsvc_NetRemoteTODInfo_get_hours(PyObject *obj, void *closure)
15810 {
15811         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15812         PyObject *py_hours;
15813         py_hours = PyInt_FromLong(object->hours);
15814         return py_hours;
15815 }
15816
15817 static int py_srvsvc_NetRemoteTODInfo_set_hours(PyObject *py_obj, PyObject *value, void *closure)
15818 {
15819         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15820         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15821         object->hours = PyInt_AsLong(value);
15822         return 0;
15823 }
15824
15825 static PyObject *py_srvsvc_NetRemoteTODInfo_get_mins(PyObject *obj, void *closure)
15826 {
15827         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15828         PyObject *py_mins;
15829         py_mins = PyInt_FromLong(object->mins);
15830         return py_mins;
15831 }
15832
15833 static int py_srvsvc_NetRemoteTODInfo_set_mins(PyObject *py_obj, PyObject *value, void *closure)
15834 {
15835         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15836         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15837         object->mins = PyInt_AsLong(value);
15838         return 0;
15839 }
15840
15841 static PyObject *py_srvsvc_NetRemoteTODInfo_get_secs(PyObject *obj, void *closure)
15842 {
15843         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15844         PyObject *py_secs;
15845         py_secs = PyInt_FromLong(object->secs);
15846         return py_secs;
15847 }
15848
15849 static int py_srvsvc_NetRemoteTODInfo_set_secs(PyObject *py_obj, PyObject *value, void *closure)
15850 {
15851         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15852         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15853         object->secs = PyInt_AsLong(value);
15854         return 0;
15855 }
15856
15857 static PyObject *py_srvsvc_NetRemoteTODInfo_get_hunds(PyObject *obj, void *closure)
15858 {
15859         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15860         PyObject *py_hunds;
15861         py_hunds = PyInt_FromLong(object->hunds);
15862         return py_hunds;
15863 }
15864
15865 static int py_srvsvc_NetRemoteTODInfo_set_hunds(PyObject *py_obj, PyObject *value, void *closure)
15866 {
15867         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15868         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15869         object->hunds = PyInt_AsLong(value);
15870         return 0;
15871 }
15872
15873 static PyObject *py_srvsvc_NetRemoteTODInfo_get_timezone(PyObject *obj, void *closure)
15874 {
15875         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15876         PyObject *py_timezone;
15877         py_timezone = PyInt_FromLong(object->timezone);
15878         return py_timezone;
15879 }
15880
15881 static int py_srvsvc_NetRemoteTODInfo_set_timezone(PyObject *py_obj, PyObject *value, void *closure)
15882 {
15883         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15884         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15885         object->timezone = PyInt_AsLong(value);
15886         return 0;
15887 }
15888
15889 static PyObject *py_srvsvc_NetRemoteTODInfo_get_tinterval(PyObject *obj, void *closure)
15890 {
15891         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15892         PyObject *py_tinterval;
15893         py_tinterval = PyInt_FromLong(object->tinterval);
15894         return py_tinterval;
15895 }
15896
15897 static int py_srvsvc_NetRemoteTODInfo_set_tinterval(PyObject *py_obj, PyObject *value, void *closure)
15898 {
15899         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15900         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15901         object->tinterval = PyInt_AsLong(value);
15902         return 0;
15903 }
15904
15905 static PyObject *py_srvsvc_NetRemoteTODInfo_get_day(PyObject *obj, void *closure)
15906 {
15907         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15908         PyObject *py_day;
15909         py_day = PyInt_FromLong(object->day);
15910         return py_day;
15911 }
15912
15913 static int py_srvsvc_NetRemoteTODInfo_set_day(PyObject *py_obj, PyObject *value, void *closure)
15914 {
15915         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15916         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15917         object->day = PyInt_AsLong(value);
15918         return 0;
15919 }
15920
15921 static PyObject *py_srvsvc_NetRemoteTODInfo_get_month(PyObject *obj, void *closure)
15922 {
15923         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15924         PyObject *py_month;
15925         py_month = PyInt_FromLong(object->month);
15926         return py_month;
15927 }
15928
15929 static int py_srvsvc_NetRemoteTODInfo_set_month(PyObject *py_obj, PyObject *value, void *closure)
15930 {
15931         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15933         object->month = PyInt_AsLong(value);
15934         return 0;
15935 }
15936
15937 static PyObject *py_srvsvc_NetRemoteTODInfo_get_year(PyObject *obj, void *closure)
15938 {
15939         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15940         PyObject *py_year;
15941         py_year = PyInt_FromLong(object->year);
15942         return py_year;
15943 }
15944
15945 static int py_srvsvc_NetRemoteTODInfo_set_year(PyObject *py_obj, PyObject *value, void *closure)
15946 {
15947         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15948         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15949         object->year = PyInt_AsLong(value);
15950         return 0;
15951 }
15952
15953 static PyObject *py_srvsvc_NetRemoteTODInfo_get_weekday(PyObject *obj, void *closure)
15954 {
15955         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(obj);
15956         PyObject *py_weekday;
15957         py_weekday = PyInt_FromLong(object->weekday);
15958         return py_weekday;
15959 }
15960
15961 static int py_srvsvc_NetRemoteTODInfo_set_weekday(PyObject *py_obj, PyObject *value, void *closure)
15962 {
15963         struct srvsvc_NetRemoteTODInfo *object = (struct srvsvc_NetRemoteTODInfo *)pytalloc_get_ptr(py_obj);
15964         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
15965         object->weekday = PyInt_AsLong(value);
15966         return 0;
15967 }
15968
15969 static PyGetSetDef py_srvsvc_NetRemoteTODInfo_getsetters[] = {
15970         { discard_const_p(char, "elapsed"), py_srvsvc_NetRemoteTODInfo_get_elapsed, py_srvsvc_NetRemoteTODInfo_set_elapsed },
15971         { discard_const_p(char, "msecs"), py_srvsvc_NetRemoteTODInfo_get_msecs, py_srvsvc_NetRemoteTODInfo_set_msecs },
15972         { discard_const_p(char, "hours"), py_srvsvc_NetRemoteTODInfo_get_hours, py_srvsvc_NetRemoteTODInfo_set_hours },
15973         { discard_const_p(char, "mins"), py_srvsvc_NetRemoteTODInfo_get_mins, py_srvsvc_NetRemoteTODInfo_set_mins },
15974         { discard_const_p(char, "secs"), py_srvsvc_NetRemoteTODInfo_get_secs, py_srvsvc_NetRemoteTODInfo_set_secs },
15975         { discard_const_p(char, "hunds"), py_srvsvc_NetRemoteTODInfo_get_hunds, py_srvsvc_NetRemoteTODInfo_set_hunds },
15976         { discard_const_p(char, "timezone"), py_srvsvc_NetRemoteTODInfo_get_timezone, py_srvsvc_NetRemoteTODInfo_set_timezone },
15977         { discard_const_p(char, "tinterval"), py_srvsvc_NetRemoteTODInfo_get_tinterval, py_srvsvc_NetRemoteTODInfo_set_tinterval },
15978         { discard_const_p(char, "day"), py_srvsvc_NetRemoteTODInfo_get_day, py_srvsvc_NetRemoteTODInfo_set_day },
15979         { discard_const_p(char, "month"), py_srvsvc_NetRemoteTODInfo_get_month, py_srvsvc_NetRemoteTODInfo_set_month },
15980         { discard_const_p(char, "year"), py_srvsvc_NetRemoteTODInfo_get_year, py_srvsvc_NetRemoteTODInfo_set_year },
15981         { discard_const_p(char, "weekday"), py_srvsvc_NetRemoteTODInfo_get_weekday, py_srvsvc_NetRemoteTODInfo_set_weekday },
15982         { NULL }
15983 };
15984
15985 static PyObject *py_srvsvc_NetRemoteTODInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
15986 {
15987         return pytalloc_new(struct srvsvc_NetRemoteTODInfo, type);
15988 }
15989
15990
15991 static PyTypeObject srvsvc_NetRemoteTODInfo_Type = {
15992         PyObject_HEAD_INIT(NULL) 0,
15993         .tp_name = "srvsvc.NetRemoteTODInfo",
15994         .tp_getset = py_srvsvc_NetRemoteTODInfo_getsetters,
15995         .tp_methods = NULL,
15996         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
15997         .tp_basicsize = sizeof(pytalloc_Object),
15998         .tp_new = py_srvsvc_NetRemoteTODInfo_new,
15999 };
16000
16001 PyObject *py_import_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, union srvsvc_NetTransportInfo *in)
16002 {
16003         PyObject *ret;
16004
16005         switch (level) {
16006                 case 0:
16007                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo0_Type, mem_ctx, &in->info0);
16008                         return ret;
16009
16010                 case 1:
16011                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo1_Type, mem_ctx, &in->info1);
16012                         return ret;
16013
16014                 case 2:
16015                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo2_Type, mem_ctx, &in->info2);
16016                         return ret;
16017
16018                 case 3:
16019                         ret = pytalloc_reference_ex(&srvsvc_NetTransportInfo3_Type, mem_ctx, &in->info3);
16020                         return ret;
16021
16022         }
16023         PyErr_SetString(PyExc_TypeError, "unknown union level");
16024         return NULL;
16025 }
16026
16027 union srvsvc_NetTransportInfo *py_export_srvsvc_NetTransportInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
16028 {
16029         union srvsvc_NetTransportInfo *ret = talloc_zero(mem_ctx, union srvsvc_NetTransportInfo);
16030         switch (level) {
16031                 case 0:
16032                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, in, talloc_free(ret); return NULL;);
16033                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16034                                 PyErr_NoMemory();
16035                                 talloc_free(ret); return NULL;
16036                         }
16037                         ret->info0 = *(struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(in);
16038                         break;
16039
16040                 case 1:
16041                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo1_Type, in, talloc_free(ret); return NULL;);
16042                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16043                                 PyErr_NoMemory();
16044                                 talloc_free(ret); return NULL;
16045                         }
16046                         ret->info1 = *(struct srvsvc_NetTransportInfo1 *)pytalloc_get_ptr(in);
16047                         break;
16048
16049                 case 2:
16050                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo2_Type, in, talloc_free(ret); return NULL;);
16051                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16052                                 PyErr_NoMemory();
16053                                 talloc_free(ret); return NULL;
16054                         }
16055                         ret->info2 = *(struct srvsvc_NetTransportInfo2 *)pytalloc_get_ptr(in);
16056                         break;
16057
16058                 case 3:
16059                         PY_CHECK_TYPE(&srvsvc_NetTransportInfo3_Type, in, talloc_free(ret); return NULL;);
16060                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
16061                                 PyErr_NoMemory();
16062                                 talloc_free(ret); return NULL;
16063                         }
16064                         ret->info3 = *(struct srvsvc_NetTransportInfo3 *)pytalloc_get_ptr(in);
16065                         break;
16066
16067                 default:
16068                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
16069                         talloc_free(ret);
16070                         ret = NULL;
16071         }
16072
16073         return ret;
16074 }
16075
16076
16077 static bool pack_py_srvsvc_NetCharDevEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevEnum *r)
16078 {
16079         PyObject *py_server_unc;
16080         PyObject *py_info_ctr;
16081         PyObject *py_max_buffer;
16082         PyObject *py_resume_handle;
16083         const char *kwnames[] = {
16084                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
16085         };
16086
16087         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)) {
16088                 return false;
16089         }
16090
16091         if (py_server_unc == Py_None) {
16092                 r->in.server_unc = NULL;
16093         } else {
16094                 r->in.server_unc = NULL;
16095                 if (PyUnicode_Check(py_server_unc)) {
16096                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16097                 } else if (PyString_Check(py_server_unc)) {
16098                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16099                 } else {
16100                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16101                         return false;
16102                 }
16103         }
16104         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16105         PY_CHECK_TYPE(&srvsvc_NetCharDevInfoCtr_Type, py_info_ctr, return false;);
16106         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16107                 PyErr_NoMemory();
16108                 return false;
16109         }
16110         r->in.info_ctr = (struct srvsvc_NetCharDevInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16111         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16112         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16113         if (py_resume_handle == Py_None) {
16114                 r->in.resume_handle = NULL;
16115         } else {
16116                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16117                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16118                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16119         }
16120         return true;
16121 }
16122
16123 static PyObject *unpack_py_srvsvc_NetCharDevEnum_args_out(struct srvsvc_NetCharDevEnum *r)
16124 {
16125         PyObject *result;
16126         PyObject *py_info_ctr;
16127         PyObject *py_totalentries;
16128         PyObject *py_resume_handle;
16129         result = PyTuple_New(3);
16130         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16131         PyTuple_SetItem(result, 0, py_info_ctr);
16132         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16133         PyTuple_SetItem(result, 1, py_totalentries);
16134         if (r->out.resume_handle == NULL) {
16135                 py_resume_handle = Py_None;
16136                 Py_INCREF(py_resume_handle);
16137         } else {
16138                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16139         }
16140         PyTuple_SetItem(result, 2, py_resume_handle);
16141         if (!W_ERROR_IS_OK(r->out.result)) {
16142                 PyErr_SetWERROR(r->out.result);
16143                 return NULL;
16144         }
16145
16146         return result;
16147 }
16148
16149 static bool pack_py_srvsvc_NetCharDevGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevGetInfo *r)
16150 {
16151         PyObject *py_server_unc;
16152         PyObject *py_device_name;
16153         PyObject *py_level;
16154         const char *kwnames[] = {
16155                 "server_unc", "device_name", "level", NULL
16156         };
16157
16158         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_level)) {
16159                 return false;
16160         }
16161
16162         if (py_server_unc == Py_None) {
16163                 r->in.server_unc = NULL;
16164         } else {
16165                 r->in.server_unc = NULL;
16166                 if (PyUnicode_Check(py_server_unc)) {
16167                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16168                 } else if (PyString_Check(py_server_unc)) {
16169                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16170                 } else {
16171                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16172                         return false;
16173                 }
16174         }
16175         if (PyUnicode_Check(py_device_name)) {
16176                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
16177         } else if (PyString_Check(py_device_name)) {
16178                 r->in.device_name = PyString_AS_STRING(py_device_name);
16179         } else {
16180                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
16181                 return false;
16182         }
16183         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16184         r->in.level = PyInt_AsLong(py_level);
16185         return true;
16186 }
16187
16188 static PyObject *unpack_py_srvsvc_NetCharDevGetInfo_args_out(struct srvsvc_NetCharDevGetInfo *r)
16189 {
16190         PyObject *result;
16191         PyObject *py_info;
16192         py_info = py_import_srvsvc_NetCharDevInfo(r->out.info, r->in.level, r->out.info);
16193         if (py_info == NULL) {
16194                 return NULL;
16195         }
16196         result = py_info;
16197         if (!W_ERROR_IS_OK(r->out.result)) {
16198                 PyErr_SetWERROR(r->out.result);
16199                 return NULL;
16200         }
16201
16202         return result;
16203 }
16204
16205 static bool pack_py_srvsvc_NetCharDevControl_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevControl *r)
16206 {
16207         PyObject *py_server_unc;
16208         PyObject *py_device_name;
16209         PyObject *py_opcode;
16210         const char *kwnames[] = {
16211                 "server_unc", "device_name", "opcode", NULL
16212         };
16213
16214         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevControl", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name, &py_opcode)) {
16215                 return false;
16216         }
16217
16218         if (py_server_unc == Py_None) {
16219                 r->in.server_unc = NULL;
16220         } else {
16221                 r->in.server_unc = NULL;
16222                 if (PyUnicode_Check(py_server_unc)) {
16223                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16224                 } else if (PyString_Check(py_server_unc)) {
16225                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16226                 } else {
16227                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16228                         return false;
16229                 }
16230         }
16231         if (PyUnicode_Check(py_device_name)) {
16232                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
16233         } else if (PyString_Check(py_device_name)) {
16234                 r->in.device_name = PyString_AS_STRING(py_device_name);
16235         } else {
16236                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
16237                 return false;
16238         }
16239         PY_CHECK_TYPE(&PyInt_Type, py_opcode, return false;);
16240         r->in.opcode = PyInt_AsLong(py_opcode);
16241         return true;
16242 }
16243
16244 static PyObject *unpack_py_srvsvc_NetCharDevControl_args_out(struct srvsvc_NetCharDevControl *r)
16245 {
16246         PyObject *result;
16247         result = Py_None;
16248         Py_INCREF(result);
16249         if (!W_ERROR_IS_OK(r->out.result)) {
16250                 PyErr_SetWERROR(r->out.result);
16251                 return NULL;
16252         }
16253
16254         return result;
16255 }
16256
16257 static bool pack_py_srvsvc_NetCharDevQEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQEnum *r)
16258 {
16259         PyObject *py_server_unc;
16260         PyObject *py_user;
16261         PyObject *py_info_ctr;
16262         PyObject *py_max_buffer;
16263         PyObject *py_resume_handle;
16264         const char *kwnames[] = {
16265                 "server_unc", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16266         };
16267
16268         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)) {
16269                 return false;
16270         }
16271
16272         if (py_server_unc == Py_None) {
16273                 r->in.server_unc = NULL;
16274         } else {
16275                 r->in.server_unc = NULL;
16276                 if (PyUnicode_Check(py_server_unc)) {
16277                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16278                 } else if (PyString_Check(py_server_unc)) {
16279                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16280                 } else {
16281                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16282                         return false;
16283                 }
16284         }
16285         if (py_user == Py_None) {
16286                 r->in.user = NULL;
16287         } else {
16288                 r->in.user = NULL;
16289                 if (PyUnicode_Check(py_user)) {
16290                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16291                 } else if (PyString_Check(py_user)) {
16292                         r->in.user = PyString_AS_STRING(py_user);
16293                 } else {
16294                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16295                         return false;
16296                 }
16297         }
16298         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16299         PY_CHECK_TYPE(&srvsvc_NetCharDevQInfoCtr_Type, py_info_ctr, return false;);
16300         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16301                 PyErr_NoMemory();
16302                 return false;
16303         }
16304         r->in.info_ctr = (struct srvsvc_NetCharDevQInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16305         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16306         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16307         if (py_resume_handle == Py_None) {
16308                 r->in.resume_handle = NULL;
16309         } else {
16310                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16311                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16312                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16313         }
16314         return true;
16315 }
16316
16317 static PyObject *unpack_py_srvsvc_NetCharDevQEnum_args_out(struct srvsvc_NetCharDevQEnum *r)
16318 {
16319         PyObject *result;
16320         PyObject *py_info_ctr;
16321         PyObject *py_totalentries;
16322         PyObject *py_resume_handle;
16323         result = PyTuple_New(3);
16324         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetCharDevQInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16325         PyTuple_SetItem(result, 0, py_info_ctr);
16326         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16327         PyTuple_SetItem(result, 1, py_totalentries);
16328         if (r->out.resume_handle == NULL) {
16329                 py_resume_handle = Py_None;
16330                 Py_INCREF(py_resume_handle);
16331         } else {
16332                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16333         }
16334         PyTuple_SetItem(result, 2, py_resume_handle);
16335         if (!W_ERROR_IS_OK(r->out.result)) {
16336                 PyErr_SetWERROR(r->out.result);
16337                 return NULL;
16338         }
16339
16340         return result;
16341 }
16342
16343 static bool pack_py_srvsvc_NetCharDevQGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQGetInfo *r)
16344 {
16345         PyObject *py_server_unc;
16346         PyObject *py_queue_name;
16347         PyObject *py_user;
16348         PyObject *py_level;
16349         const char *kwnames[] = {
16350                 "server_unc", "queue_name", "user", "level", NULL
16351         };
16352
16353         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetCharDevQGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_user, &py_level)) {
16354                 return false;
16355         }
16356
16357         if (py_server_unc == Py_None) {
16358                 r->in.server_unc = NULL;
16359         } else {
16360                 r->in.server_unc = NULL;
16361                 if (PyUnicode_Check(py_server_unc)) {
16362                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16363                 } else if (PyString_Check(py_server_unc)) {
16364                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16365                 } else {
16366                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16367                         return false;
16368                 }
16369         }
16370         if (PyUnicode_Check(py_queue_name)) {
16371                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16372         } else if (PyString_Check(py_queue_name)) {
16373                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16374         } else {
16375                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16376                 return false;
16377         }
16378         if (PyUnicode_Check(py_user)) {
16379                 r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16380         } else if (PyString_Check(py_user)) {
16381                 r->in.user = PyString_AS_STRING(py_user);
16382         } else {
16383                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16384                 return false;
16385         }
16386         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16387         r->in.level = PyInt_AsLong(py_level);
16388         return true;
16389 }
16390
16391 static PyObject *unpack_py_srvsvc_NetCharDevQGetInfo_args_out(struct srvsvc_NetCharDevQGetInfo *r)
16392 {
16393         PyObject *result;
16394         PyObject *py_info;
16395         py_info = py_import_srvsvc_NetCharDevQInfo(r->out.info, r->in.level, r->out.info);
16396         if (py_info == NULL) {
16397                 return NULL;
16398         }
16399         result = py_info;
16400         if (!W_ERROR_IS_OK(r->out.result)) {
16401                 PyErr_SetWERROR(r->out.result);
16402                 return NULL;
16403         }
16404
16405         return result;
16406 }
16407
16408 static bool pack_py_srvsvc_NetCharDevQSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQSetInfo *r)
16409 {
16410         PyObject *py_server_unc;
16411         PyObject *py_queue_name;
16412         PyObject *py_level;
16413         PyObject *py_info;
16414         PyObject *py_parm_error;
16415         const char *kwnames[] = {
16416                 "server_unc", "queue_name", "level", "info", "parm_error", NULL
16417         };
16418
16419         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)) {
16420                 return false;
16421         }
16422
16423         if (py_server_unc == Py_None) {
16424                 r->in.server_unc = NULL;
16425         } else {
16426                 r->in.server_unc = NULL;
16427                 if (PyUnicode_Check(py_server_unc)) {
16428                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16429                 } else if (PyString_Check(py_server_unc)) {
16430                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16431                 } else {
16432                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16433                         return false;
16434                 }
16435         }
16436         if (PyUnicode_Check(py_queue_name)) {
16437                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16438         } else if (PyString_Check(py_queue_name)) {
16439                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16440         } else {
16441                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16442                 return false;
16443         }
16444         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16445         r->in.level = PyInt_AsLong(py_level);
16446         {
16447                 union srvsvc_NetCharDevQInfo *info_switch_0;
16448                 info_switch_0 = py_export_srvsvc_NetCharDevQInfo(r, r->in.level, py_info);
16449                 if (info_switch_0 == NULL) {
16450                         return false;
16451                 }
16452                 r->in.info = *info_switch_0;
16453         }
16454         if (py_parm_error == Py_None) {
16455                 r->in.parm_error = NULL;
16456         } else {
16457                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
16458                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
16459                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
16460         }
16461         return true;
16462 }
16463
16464 static PyObject *unpack_py_srvsvc_NetCharDevQSetInfo_args_out(struct srvsvc_NetCharDevQSetInfo *r)
16465 {
16466         PyObject *result;
16467         PyObject *py_parm_error;
16468         if (r->out.parm_error == NULL) {
16469                 py_parm_error = Py_None;
16470                 Py_INCREF(py_parm_error);
16471         } else {
16472                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
16473         }
16474         result = py_parm_error;
16475         if (!W_ERROR_IS_OK(r->out.result)) {
16476                 PyErr_SetWERROR(r->out.result);
16477                 return NULL;
16478         }
16479
16480         return result;
16481 }
16482
16483 static bool pack_py_srvsvc_NetCharDevQPurge_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurge *r)
16484 {
16485         PyObject *py_server_unc;
16486         PyObject *py_queue_name;
16487         const char *kwnames[] = {
16488                 "server_unc", "queue_name", NULL
16489         };
16490
16491         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetCharDevQPurge", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name)) {
16492                 return false;
16493         }
16494
16495         if (py_server_unc == Py_None) {
16496                 r->in.server_unc = NULL;
16497         } else {
16498                 r->in.server_unc = NULL;
16499                 if (PyUnicode_Check(py_server_unc)) {
16500                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16501                 } else if (PyString_Check(py_server_unc)) {
16502                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16503                 } else {
16504                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16505                         return false;
16506                 }
16507         }
16508         if (PyUnicode_Check(py_queue_name)) {
16509                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16510         } else if (PyString_Check(py_queue_name)) {
16511                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16512         } else {
16513                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16514                 return false;
16515         }
16516         return true;
16517 }
16518
16519 static PyObject *unpack_py_srvsvc_NetCharDevQPurge_args_out(struct srvsvc_NetCharDevQPurge *r)
16520 {
16521         PyObject *result;
16522         result = Py_None;
16523         Py_INCREF(result);
16524         if (!W_ERROR_IS_OK(r->out.result)) {
16525                 PyErr_SetWERROR(r->out.result);
16526                 return NULL;
16527         }
16528
16529         return result;
16530 }
16531
16532 static bool pack_py_srvsvc_NetCharDevQPurgeSelf_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetCharDevQPurgeSelf *r)
16533 {
16534         PyObject *py_server_unc;
16535         PyObject *py_queue_name;
16536         PyObject *py_computer_name;
16537         const char *kwnames[] = {
16538                 "server_unc", "queue_name", "computer_name", NULL
16539         };
16540
16541         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetCharDevQPurgeSelf", discard_const_p(char *, kwnames), &py_server_unc, &py_queue_name, &py_computer_name)) {
16542                 return false;
16543         }
16544
16545         if (py_server_unc == Py_None) {
16546                 r->in.server_unc = NULL;
16547         } else {
16548                 r->in.server_unc = NULL;
16549                 if (PyUnicode_Check(py_server_unc)) {
16550                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16551                 } else if (PyString_Check(py_server_unc)) {
16552                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16553                 } else {
16554                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16555                         return false;
16556                 }
16557         }
16558         if (PyUnicode_Check(py_queue_name)) {
16559                 r->in.queue_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_queue_name, "utf-8", "ignore"));
16560         } else if (PyString_Check(py_queue_name)) {
16561                 r->in.queue_name = PyString_AS_STRING(py_queue_name);
16562         } else {
16563                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_queue_name)->tp_name);
16564                 return false;
16565         }
16566         if (PyUnicode_Check(py_computer_name)) {
16567                 r->in.computer_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_computer_name, "utf-8", "ignore"));
16568         } else if (PyString_Check(py_computer_name)) {
16569                 r->in.computer_name = PyString_AS_STRING(py_computer_name);
16570         } else {
16571                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_computer_name)->tp_name);
16572                 return false;
16573         }
16574         return true;
16575 }
16576
16577 static PyObject *unpack_py_srvsvc_NetCharDevQPurgeSelf_args_out(struct srvsvc_NetCharDevQPurgeSelf *r)
16578 {
16579         PyObject *result;
16580         result = Py_None;
16581         Py_INCREF(result);
16582         if (!W_ERROR_IS_OK(r->out.result)) {
16583                 PyErr_SetWERROR(r->out.result);
16584                 return NULL;
16585         }
16586
16587         return result;
16588 }
16589
16590 static bool pack_py_srvsvc_NetConnEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetConnEnum *r)
16591 {
16592         PyObject *py_server_unc;
16593         PyObject *py_path;
16594         PyObject *py_info_ctr;
16595         PyObject *py_max_buffer;
16596         PyObject *py_resume_handle;
16597         const char *kwnames[] = {
16598                 "server_unc", "path", "info_ctr", "max_buffer", "resume_handle", NULL
16599         };
16600
16601         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)) {
16602                 return false;
16603         }
16604
16605         if (py_server_unc == Py_None) {
16606                 r->in.server_unc = NULL;
16607         } else {
16608                 r->in.server_unc = NULL;
16609                 if (PyUnicode_Check(py_server_unc)) {
16610                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16611                 } else if (PyString_Check(py_server_unc)) {
16612                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16613                 } else {
16614                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16615                         return false;
16616                 }
16617         }
16618         if (py_path == Py_None) {
16619                 r->in.path = NULL;
16620         } else {
16621                 r->in.path = NULL;
16622                 if (PyUnicode_Check(py_path)) {
16623                         r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
16624                 } else if (PyString_Check(py_path)) {
16625                         r->in.path = PyString_AS_STRING(py_path);
16626                 } else {
16627                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
16628                         return false;
16629                 }
16630         }
16631         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16632         PY_CHECK_TYPE(&srvsvc_NetConnInfoCtr_Type, py_info_ctr, return false;);
16633         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16634                 PyErr_NoMemory();
16635                 return false;
16636         }
16637         r->in.info_ctr = (struct srvsvc_NetConnInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16638         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16639         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16640         if (py_resume_handle == Py_None) {
16641                 r->in.resume_handle = NULL;
16642         } else {
16643                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16644                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16645                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16646         }
16647         return true;
16648 }
16649
16650 static PyObject *unpack_py_srvsvc_NetConnEnum_args_out(struct srvsvc_NetConnEnum *r)
16651 {
16652         PyObject *result;
16653         PyObject *py_info_ctr;
16654         PyObject *py_totalentries;
16655         PyObject *py_resume_handle;
16656         result = PyTuple_New(3);
16657         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetConnInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16658         PyTuple_SetItem(result, 0, py_info_ctr);
16659         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16660         PyTuple_SetItem(result, 1, py_totalentries);
16661         if (r->out.resume_handle == NULL) {
16662                 py_resume_handle = Py_None;
16663                 Py_INCREF(py_resume_handle);
16664         } else {
16665                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16666         }
16667         PyTuple_SetItem(result, 2, py_resume_handle);
16668         if (!W_ERROR_IS_OK(r->out.result)) {
16669                 PyErr_SetWERROR(r->out.result);
16670                 return NULL;
16671         }
16672
16673         return result;
16674 }
16675
16676 static bool pack_py_srvsvc_NetFileEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileEnum *r)
16677 {
16678         PyObject *py_server_unc;
16679         PyObject *py_path;
16680         PyObject *py_user;
16681         PyObject *py_info_ctr;
16682         PyObject *py_max_buffer;
16683         PyObject *py_resume_handle;
16684         const char *kwnames[] = {
16685                 "server_unc", "path", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16686         };
16687
16688         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)) {
16689                 return false;
16690         }
16691
16692         if (py_server_unc == Py_None) {
16693                 r->in.server_unc = NULL;
16694         } else {
16695                 r->in.server_unc = NULL;
16696                 if (PyUnicode_Check(py_server_unc)) {
16697                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16698                 } else if (PyString_Check(py_server_unc)) {
16699                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16700                 } else {
16701                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16702                         return false;
16703                 }
16704         }
16705         if (py_path == Py_None) {
16706                 r->in.path = NULL;
16707         } else {
16708                 r->in.path = NULL;
16709                 if (PyUnicode_Check(py_path)) {
16710                         r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
16711                 } else if (PyString_Check(py_path)) {
16712                         r->in.path = PyString_AS_STRING(py_path);
16713                 } else {
16714                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
16715                         return false;
16716                 }
16717         }
16718         if (py_user == Py_None) {
16719                 r->in.user = NULL;
16720         } else {
16721                 r->in.user = NULL;
16722                 if (PyUnicode_Check(py_user)) {
16723                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16724                 } else if (PyString_Check(py_user)) {
16725                         r->in.user = PyString_AS_STRING(py_user);
16726                 } else {
16727                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16728                         return false;
16729                 }
16730         }
16731         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16732         PY_CHECK_TYPE(&srvsvc_NetFileInfoCtr_Type, py_info_ctr, return false;);
16733         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16734                 PyErr_NoMemory();
16735                 return false;
16736         }
16737         r->in.info_ctr = (struct srvsvc_NetFileInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16738         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16739         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16740         if (py_resume_handle == Py_None) {
16741                 r->in.resume_handle = NULL;
16742         } else {
16743                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16744                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16745                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16746         }
16747         return true;
16748 }
16749
16750 static PyObject *unpack_py_srvsvc_NetFileEnum_args_out(struct srvsvc_NetFileEnum *r)
16751 {
16752         PyObject *result;
16753         PyObject *py_info_ctr;
16754         PyObject *py_totalentries;
16755         PyObject *py_resume_handle;
16756         result = PyTuple_New(3);
16757         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetFileInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16758         PyTuple_SetItem(result, 0, py_info_ctr);
16759         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16760         PyTuple_SetItem(result, 1, py_totalentries);
16761         if (r->out.resume_handle == NULL) {
16762                 py_resume_handle = Py_None;
16763                 Py_INCREF(py_resume_handle);
16764         } else {
16765                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16766         }
16767         PyTuple_SetItem(result, 2, py_resume_handle);
16768         if (!W_ERROR_IS_OK(r->out.result)) {
16769                 PyErr_SetWERROR(r->out.result);
16770                 return NULL;
16771         }
16772
16773         return result;
16774 }
16775
16776 static bool pack_py_srvsvc_NetFileGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileGetInfo *r)
16777 {
16778         PyObject *py_server_unc;
16779         PyObject *py_fid;
16780         PyObject *py_level;
16781         const char *kwnames[] = {
16782                 "server_unc", "fid", "level", NULL
16783         };
16784
16785         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetFileGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_fid, &py_level)) {
16786                 return false;
16787         }
16788
16789         if (py_server_unc == Py_None) {
16790                 r->in.server_unc = NULL;
16791         } else {
16792                 r->in.server_unc = NULL;
16793                 if (PyUnicode_Check(py_server_unc)) {
16794                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16795                 } else if (PyString_Check(py_server_unc)) {
16796                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16797                 } else {
16798                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16799                         return false;
16800                 }
16801         }
16802         PY_CHECK_TYPE(&PyInt_Type, py_fid, return false;);
16803         r->in.fid = PyInt_AsLong(py_fid);
16804         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
16805         r->in.level = PyInt_AsLong(py_level);
16806         return true;
16807 }
16808
16809 static PyObject *unpack_py_srvsvc_NetFileGetInfo_args_out(struct srvsvc_NetFileGetInfo *r)
16810 {
16811         PyObject *result;
16812         PyObject *py_info;
16813         py_info = py_import_srvsvc_NetFileInfo(r->out.info, r->in.level, r->out.info);
16814         if (py_info == NULL) {
16815                 return NULL;
16816         }
16817         result = py_info;
16818         if (!W_ERROR_IS_OK(r->out.result)) {
16819                 PyErr_SetWERROR(r->out.result);
16820                 return NULL;
16821         }
16822
16823         return result;
16824 }
16825
16826 static bool pack_py_srvsvc_NetFileClose_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetFileClose *r)
16827 {
16828         PyObject *py_server_unc;
16829         PyObject *py_fid;
16830         const char *kwnames[] = {
16831                 "server_unc", "fid", NULL
16832         };
16833
16834         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetFileClose", discard_const_p(char *, kwnames), &py_server_unc, &py_fid)) {
16835                 return false;
16836         }
16837
16838         if (py_server_unc == Py_None) {
16839                 r->in.server_unc = NULL;
16840         } else {
16841                 r->in.server_unc = NULL;
16842                 if (PyUnicode_Check(py_server_unc)) {
16843                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16844                 } else if (PyString_Check(py_server_unc)) {
16845                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16846                 } else {
16847                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16848                         return false;
16849                 }
16850         }
16851         PY_CHECK_TYPE(&PyInt_Type, py_fid, return false;);
16852         r->in.fid = PyInt_AsLong(py_fid);
16853         return true;
16854 }
16855
16856 static PyObject *unpack_py_srvsvc_NetFileClose_args_out(struct srvsvc_NetFileClose *r)
16857 {
16858         PyObject *result;
16859         result = Py_None;
16860         Py_INCREF(result);
16861         if (!W_ERROR_IS_OK(r->out.result)) {
16862                 PyErr_SetWERROR(r->out.result);
16863                 return NULL;
16864         }
16865
16866         return result;
16867 }
16868
16869 static bool pack_py_srvsvc_NetSessEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessEnum *r)
16870 {
16871         PyObject *py_server_unc;
16872         PyObject *py_client;
16873         PyObject *py_user;
16874         PyObject *py_info_ctr;
16875         PyObject *py_max_buffer;
16876         PyObject *py_resume_handle;
16877         const char *kwnames[] = {
16878                 "server_unc", "client", "user", "info_ctr", "max_buffer", "resume_handle", NULL
16879         };
16880
16881         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)) {
16882                 return false;
16883         }
16884
16885         if (py_server_unc == Py_None) {
16886                 r->in.server_unc = NULL;
16887         } else {
16888                 r->in.server_unc = NULL;
16889                 if (PyUnicode_Check(py_server_unc)) {
16890                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16891                 } else if (PyString_Check(py_server_unc)) {
16892                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16893                 } else {
16894                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16895                         return false;
16896                 }
16897         }
16898         if (py_client == Py_None) {
16899                 r->in.client = NULL;
16900         } else {
16901                 r->in.client = NULL;
16902                 if (PyUnicode_Check(py_client)) {
16903                         r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
16904                 } else if (PyString_Check(py_client)) {
16905                         r->in.client = PyString_AS_STRING(py_client);
16906                 } else {
16907                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
16908                         return false;
16909                 }
16910         }
16911         if (py_user == Py_None) {
16912                 r->in.user = NULL;
16913         } else {
16914                 r->in.user = NULL;
16915                 if (PyUnicode_Check(py_user)) {
16916                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
16917                 } else if (PyString_Check(py_user)) {
16918                         r->in.user = PyString_AS_STRING(py_user);
16919                 } else {
16920                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
16921                         return false;
16922                 }
16923         }
16924         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
16925         PY_CHECK_TYPE(&srvsvc_NetSessInfoCtr_Type, py_info_ctr, return false;);
16926         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
16927                 PyErr_NoMemory();
16928                 return false;
16929         }
16930         r->in.info_ctr = (struct srvsvc_NetSessInfoCtr *)pytalloc_get_ptr(py_info_ctr);
16931         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
16932         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
16933         if (py_resume_handle == Py_None) {
16934                 r->in.resume_handle = NULL;
16935         } else {
16936                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
16937                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
16938                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
16939         }
16940         return true;
16941 }
16942
16943 static PyObject *unpack_py_srvsvc_NetSessEnum_args_out(struct srvsvc_NetSessEnum *r)
16944 {
16945         PyObject *result;
16946         PyObject *py_info_ctr;
16947         PyObject *py_totalentries;
16948         PyObject *py_resume_handle;
16949         result = PyTuple_New(3);
16950         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetSessInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
16951         PyTuple_SetItem(result, 0, py_info_ctr);
16952         py_totalentries = PyInt_FromLong(*r->out.totalentries);
16953         PyTuple_SetItem(result, 1, py_totalentries);
16954         if (r->out.resume_handle == NULL) {
16955                 py_resume_handle = Py_None;
16956                 Py_INCREF(py_resume_handle);
16957         } else {
16958                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
16959         }
16960         PyTuple_SetItem(result, 2, py_resume_handle);
16961         if (!W_ERROR_IS_OK(r->out.result)) {
16962                 PyErr_SetWERROR(r->out.result);
16963                 return NULL;
16964         }
16965
16966         return result;
16967 }
16968
16969 static bool pack_py_srvsvc_NetSessDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSessDel *r)
16970 {
16971         PyObject *py_server_unc;
16972         PyObject *py_client;
16973         PyObject *py_user;
16974         const char *kwnames[] = {
16975                 "server_unc", "client", "user", NULL
16976         };
16977
16978         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetSessDel", discard_const_p(char *, kwnames), &py_server_unc, &py_client, &py_user)) {
16979                 return false;
16980         }
16981
16982         if (py_server_unc == Py_None) {
16983                 r->in.server_unc = NULL;
16984         } else {
16985                 r->in.server_unc = NULL;
16986                 if (PyUnicode_Check(py_server_unc)) {
16987                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
16988                 } else if (PyString_Check(py_server_unc)) {
16989                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
16990                 } else {
16991                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
16992                         return false;
16993                 }
16994         }
16995         if (py_client == Py_None) {
16996                 r->in.client = NULL;
16997         } else {
16998                 r->in.client = NULL;
16999                 if (PyUnicode_Check(py_client)) {
17000                         r->in.client = PyString_AS_STRING(PyUnicode_AsEncodedString(py_client, "utf-8", "ignore"));
17001                 } else if (PyString_Check(py_client)) {
17002                         r->in.client = PyString_AS_STRING(py_client);
17003                 } else {
17004                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_client)->tp_name);
17005                         return false;
17006                 }
17007         }
17008         if (py_user == Py_None) {
17009                 r->in.user = NULL;
17010         } else {
17011                 r->in.user = NULL;
17012                 if (PyUnicode_Check(py_user)) {
17013                         r->in.user = PyString_AS_STRING(PyUnicode_AsEncodedString(py_user, "utf-8", "ignore"));
17014                 } else if (PyString_Check(py_user)) {
17015                         r->in.user = PyString_AS_STRING(py_user);
17016                 } else {
17017                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user)->tp_name);
17018                         return false;
17019                 }
17020         }
17021         return true;
17022 }
17023
17024 static PyObject *unpack_py_srvsvc_NetSessDel_args_out(struct srvsvc_NetSessDel *r)
17025 {
17026         PyObject *result;
17027         result = Py_None;
17028         Py_INCREF(result);
17029         if (!W_ERROR_IS_OK(r->out.result)) {
17030                 PyErr_SetWERROR(r->out.result);
17031                 return NULL;
17032         }
17033
17034         return result;
17035 }
17036
17037 static bool pack_py_srvsvc_NetShareAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareAdd *r)
17038 {
17039         PyObject *py_server_unc;
17040         PyObject *py_level;
17041         PyObject *py_info;
17042         PyObject *py_parm_error;
17043         const char *kwnames[] = {
17044                 "server_unc", "level", "info", "parm_error", NULL
17045         };
17046
17047         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetShareAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
17048                 return false;
17049         }
17050
17051         if (py_server_unc == Py_None) {
17052                 r->in.server_unc = NULL;
17053         } else {
17054                 r->in.server_unc = NULL;
17055                 if (PyUnicode_Check(py_server_unc)) {
17056                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17057                 } else if (PyString_Check(py_server_unc)) {
17058                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17059                 } else {
17060                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17061                         return false;
17062                 }
17063         }
17064         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17065         r->in.level = PyInt_AsLong(py_level);
17066         r->in.info = talloc_ptrtype(r, r->in.info);
17067         {
17068                 union srvsvc_NetShareInfo *info_switch_1;
17069                 info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
17070                 if (info_switch_1 == NULL) {
17071                         return false;
17072                 }
17073                 r->in.info = info_switch_1;
17074         }
17075         if (py_parm_error == Py_None) {
17076                 r->in.parm_error = NULL;
17077         } else {
17078                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17079                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17080                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17081         }
17082         return true;
17083 }
17084
17085 static PyObject *unpack_py_srvsvc_NetShareAdd_args_out(struct srvsvc_NetShareAdd *r)
17086 {
17087         PyObject *result;
17088         PyObject *py_parm_error;
17089         if (r->out.parm_error == NULL) {
17090                 py_parm_error = Py_None;
17091                 Py_INCREF(py_parm_error);
17092         } else {
17093                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17094         }
17095         result = py_parm_error;
17096         if (!W_ERROR_IS_OK(r->out.result)) {
17097                 PyErr_SetWERROR(r->out.result);
17098                 return NULL;
17099         }
17100
17101         return result;
17102 }
17103
17104 static bool pack_py_srvsvc_NetShareEnumAll_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnumAll *r)
17105 {
17106         PyObject *py_server_unc;
17107         PyObject *py_info_ctr;
17108         PyObject *py_max_buffer;
17109         PyObject *py_resume_handle;
17110         const char *kwnames[] = {
17111                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
17112         };
17113
17114         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)) {
17115                 return false;
17116         }
17117
17118         if (py_server_unc == Py_None) {
17119                 r->in.server_unc = NULL;
17120         } else {
17121                 r->in.server_unc = NULL;
17122                 if (PyUnicode_Check(py_server_unc)) {
17123                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17124                 } else if (PyString_Check(py_server_unc)) {
17125                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17126                 } else {
17127                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17128                         return false;
17129                 }
17130         }
17131         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
17132         PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
17133         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
17134                 PyErr_NoMemory();
17135                 return false;
17136         }
17137         r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
17138         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
17139         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
17140         if (py_resume_handle == Py_None) {
17141                 r->in.resume_handle = NULL;
17142         } else {
17143                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17144                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17145                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17146         }
17147         return true;
17148 }
17149
17150 static PyObject *unpack_py_srvsvc_NetShareEnumAll_args_out(struct srvsvc_NetShareEnumAll *r)
17151 {
17152         PyObject *result;
17153         PyObject *py_info_ctr;
17154         PyObject *py_totalentries;
17155         PyObject *py_resume_handle;
17156         result = PyTuple_New(3);
17157         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
17158         PyTuple_SetItem(result, 0, py_info_ctr);
17159         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17160         PyTuple_SetItem(result, 1, py_totalentries);
17161         if (r->out.resume_handle == NULL) {
17162                 py_resume_handle = Py_None;
17163                 Py_INCREF(py_resume_handle);
17164         } else {
17165                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17166         }
17167         PyTuple_SetItem(result, 2, py_resume_handle);
17168         if (!W_ERROR_IS_OK(r->out.result)) {
17169                 PyErr_SetWERROR(r->out.result);
17170                 return NULL;
17171         }
17172
17173         return result;
17174 }
17175
17176 static bool pack_py_srvsvc_NetShareGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareGetInfo *r)
17177 {
17178         PyObject *py_server_unc;
17179         PyObject *py_share_name;
17180         PyObject *py_level;
17181         const char *kwnames[] = {
17182                 "server_unc", "share_name", "level", NULL
17183         };
17184
17185         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_level)) {
17186                 return false;
17187         }
17188
17189         if (py_server_unc == Py_None) {
17190                 r->in.server_unc = NULL;
17191         } else {
17192                 r->in.server_unc = NULL;
17193                 if (PyUnicode_Check(py_server_unc)) {
17194                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17195                 } else if (PyString_Check(py_server_unc)) {
17196                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17197                 } else {
17198                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17199                         return false;
17200                 }
17201         }
17202         if (PyUnicode_Check(py_share_name)) {
17203                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17204         } else if (PyString_Check(py_share_name)) {
17205                 r->in.share_name = PyString_AS_STRING(py_share_name);
17206         } else {
17207                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17208                 return false;
17209         }
17210         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17211         r->in.level = PyInt_AsLong(py_level);
17212         return true;
17213 }
17214
17215 static PyObject *unpack_py_srvsvc_NetShareGetInfo_args_out(struct srvsvc_NetShareGetInfo *r)
17216 {
17217         PyObject *result;
17218         PyObject *py_info;
17219         py_info = py_import_srvsvc_NetShareInfo(r->out.info, r->in.level, r->out.info);
17220         if (py_info == NULL) {
17221                 return NULL;
17222         }
17223         result = py_info;
17224         if (!W_ERROR_IS_OK(r->out.result)) {
17225                 PyErr_SetWERROR(r->out.result);
17226                 return NULL;
17227         }
17228
17229         return result;
17230 }
17231
17232 static bool pack_py_srvsvc_NetShareSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareSetInfo *r)
17233 {
17234         PyObject *py_server_unc;
17235         PyObject *py_share_name;
17236         PyObject *py_level;
17237         PyObject *py_info;
17238         PyObject *py_parm_error;
17239         const char *kwnames[] = {
17240                 "server_unc", "share_name", "level", "info", "parm_error", NULL
17241         };
17242
17243         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)) {
17244                 return false;
17245         }
17246
17247         if (py_server_unc == Py_None) {
17248                 r->in.server_unc = NULL;
17249         } else {
17250                 r->in.server_unc = NULL;
17251                 if (PyUnicode_Check(py_server_unc)) {
17252                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17253                 } else if (PyString_Check(py_server_unc)) {
17254                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17255                 } else {
17256                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17257                         return false;
17258                 }
17259         }
17260         if (PyUnicode_Check(py_share_name)) {
17261                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17262         } else if (PyString_Check(py_share_name)) {
17263                 r->in.share_name = PyString_AS_STRING(py_share_name);
17264         } else {
17265                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17266                 return false;
17267         }
17268         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17269         r->in.level = PyInt_AsLong(py_level);
17270         r->in.info = talloc_ptrtype(r, r->in.info);
17271         {
17272                 union srvsvc_NetShareInfo *info_switch_1;
17273                 info_switch_1 = py_export_srvsvc_NetShareInfo(r, r->in.level, py_info);
17274                 if (info_switch_1 == NULL) {
17275                         return false;
17276                 }
17277                 r->in.info = info_switch_1;
17278         }
17279         if (py_parm_error == Py_None) {
17280                 r->in.parm_error = NULL;
17281         } else {
17282                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17283                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17284                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17285         }
17286         return true;
17287 }
17288
17289 static PyObject *unpack_py_srvsvc_NetShareSetInfo_args_out(struct srvsvc_NetShareSetInfo *r)
17290 {
17291         PyObject *result;
17292         PyObject *py_parm_error;
17293         if (r->out.parm_error == NULL) {
17294                 py_parm_error = Py_None;
17295                 Py_INCREF(py_parm_error);
17296         } else {
17297                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17298         }
17299         result = py_parm_error;
17300         if (!W_ERROR_IS_OK(r->out.result)) {
17301                 PyErr_SetWERROR(r->out.result);
17302                 return NULL;
17303         }
17304
17305         return result;
17306 }
17307
17308 static bool pack_py_srvsvc_NetShareDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDel *r)
17309 {
17310         PyObject *py_server_unc;
17311         PyObject *py_share_name;
17312         PyObject *py_reserved;
17313         const char *kwnames[] = {
17314                 "server_unc", "share_name", "reserved", NULL
17315         };
17316
17317         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDel", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
17318                 return false;
17319         }
17320
17321         if (py_server_unc == Py_None) {
17322                 r->in.server_unc = NULL;
17323         } else {
17324                 r->in.server_unc = NULL;
17325                 if (PyUnicode_Check(py_server_unc)) {
17326                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17327                 } else if (PyString_Check(py_server_unc)) {
17328                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17329                 } else {
17330                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17331                         return false;
17332                 }
17333         }
17334         if (PyUnicode_Check(py_share_name)) {
17335                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17336         } else if (PyString_Check(py_share_name)) {
17337                 r->in.share_name = PyString_AS_STRING(py_share_name);
17338         } else {
17339                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17340                 return false;
17341         }
17342         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
17343         r->in.reserved = PyInt_AsLong(py_reserved);
17344         return true;
17345 }
17346
17347 static PyObject *unpack_py_srvsvc_NetShareDel_args_out(struct srvsvc_NetShareDel *r)
17348 {
17349         PyObject *result;
17350         result = Py_None;
17351         Py_INCREF(result);
17352         if (!W_ERROR_IS_OK(r->out.result)) {
17353                 PyErr_SetWERROR(r->out.result);
17354                 return NULL;
17355         }
17356
17357         return result;
17358 }
17359
17360 static bool pack_py_srvsvc_NetShareDelSticky_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelSticky *r)
17361 {
17362         PyObject *py_server_unc;
17363         PyObject *py_share_name;
17364         PyObject *py_reserved;
17365         const char *kwnames[] = {
17366                 "server_unc", "share_name", "reserved", NULL
17367         };
17368
17369         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelSticky", discard_const_p(char *, kwnames), &py_server_unc, &py_share_name, &py_reserved)) {
17370                 return false;
17371         }
17372
17373         if (py_server_unc == Py_None) {
17374                 r->in.server_unc = NULL;
17375         } else {
17376                 r->in.server_unc = NULL;
17377                 if (PyUnicode_Check(py_server_unc)) {
17378                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17379                 } else if (PyString_Check(py_server_unc)) {
17380                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17381                 } else {
17382                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17383                         return false;
17384                 }
17385         }
17386         if (PyUnicode_Check(py_share_name)) {
17387                 r->in.share_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share_name, "utf-8", "ignore"));
17388         } else if (PyString_Check(py_share_name)) {
17389                 r->in.share_name = PyString_AS_STRING(py_share_name);
17390         } else {
17391                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share_name)->tp_name);
17392                 return false;
17393         }
17394         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
17395         r->in.reserved = PyInt_AsLong(py_reserved);
17396         return true;
17397 }
17398
17399 static PyObject *unpack_py_srvsvc_NetShareDelSticky_args_out(struct srvsvc_NetShareDelSticky *r)
17400 {
17401         PyObject *result;
17402         result = Py_None;
17403         Py_INCREF(result);
17404         if (!W_ERROR_IS_OK(r->out.result)) {
17405                 PyErr_SetWERROR(r->out.result);
17406                 return NULL;
17407         }
17408
17409         return result;
17410 }
17411
17412 static bool pack_py_srvsvc_NetShareCheck_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareCheck *r)
17413 {
17414         PyObject *py_server_unc;
17415         PyObject *py_device_name;
17416         const char *kwnames[] = {
17417                 "server_unc", "device_name", NULL
17418         };
17419
17420         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetShareCheck", discard_const_p(char *, kwnames), &py_server_unc, &py_device_name)) {
17421                 return false;
17422         }
17423
17424         if (py_server_unc == Py_None) {
17425                 r->in.server_unc = NULL;
17426         } else {
17427                 r->in.server_unc = NULL;
17428                 if (PyUnicode_Check(py_server_unc)) {
17429                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17430                 } else if (PyString_Check(py_server_unc)) {
17431                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17432                 } else {
17433                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17434                         return false;
17435                 }
17436         }
17437         if (PyUnicode_Check(py_device_name)) {
17438                 r->in.device_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_device_name, "utf-8", "ignore"));
17439         } else if (PyString_Check(py_device_name)) {
17440                 r->in.device_name = PyString_AS_STRING(py_device_name);
17441         } else {
17442                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_device_name)->tp_name);
17443                 return false;
17444         }
17445         return true;
17446 }
17447
17448 static PyObject *unpack_py_srvsvc_NetShareCheck_args_out(struct srvsvc_NetShareCheck *r)
17449 {
17450         PyObject *result;
17451         PyObject *py_type;
17452         py_type = PyInt_FromLong(*r->out.type);
17453         result = py_type;
17454         if (!W_ERROR_IS_OK(r->out.result)) {
17455                 PyErr_SetWERROR(r->out.result);
17456                 return NULL;
17457         }
17458
17459         return result;
17460 }
17461
17462 static bool pack_py_srvsvc_NetSrvGetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvGetInfo *r)
17463 {
17464         PyObject *py_server_unc;
17465         PyObject *py_level;
17466         const char *kwnames[] = {
17467                 "server_unc", "level", NULL
17468         };
17469
17470         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:srvsvc_NetSrvGetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level)) {
17471                 return false;
17472         }
17473
17474         if (py_server_unc == Py_None) {
17475                 r->in.server_unc = NULL;
17476         } else {
17477                 r->in.server_unc = NULL;
17478                 if (PyUnicode_Check(py_server_unc)) {
17479                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17480                 } else if (PyString_Check(py_server_unc)) {
17481                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17482                 } else {
17483                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17484                         return false;
17485                 }
17486         }
17487         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17488         r->in.level = PyInt_AsLong(py_level);
17489         return true;
17490 }
17491
17492 static PyObject *unpack_py_srvsvc_NetSrvGetInfo_args_out(struct srvsvc_NetSrvGetInfo *r)
17493 {
17494         PyObject *result;
17495         PyObject *py_info;
17496         py_info = py_import_srvsvc_NetSrvInfo(r->out.info, r->in.level, r->out.info);
17497         if (py_info == NULL) {
17498                 return NULL;
17499         }
17500         result = py_info;
17501         if (!W_ERROR_IS_OK(r->out.result)) {
17502                 PyErr_SetWERROR(r->out.result);
17503                 return NULL;
17504         }
17505
17506         return result;
17507 }
17508
17509 static bool pack_py_srvsvc_NetSrvSetInfo_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSrvSetInfo *r)
17510 {
17511         PyObject *py_server_unc;
17512         PyObject *py_level;
17513         PyObject *py_info;
17514         PyObject *py_parm_error;
17515         const char *kwnames[] = {
17516                 "server_unc", "level", "info", "parm_error", NULL
17517         };
17518
17519         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSrvSetInfo", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info, &py_parm_error)) {
17520                 return false;
17521         }
17522
17523         if (py_server_unc == Py_None) {
17524                 r->in.server_unc = NULL;
17525         } else {
17526                 r->in.server_unc = NULL;
17527                 if (PyUnicode_Check(py_server_unc)) {
17528                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17529                 } else if (PyString_Check(py_server_unc)) {
17530                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17531                 } else {
17532                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17533                         return false;
17534                 }
17535         }
17536         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17537         r->in.level = PyInt_AsLong(py_level);
17538         r->in.info = talloc_ptrtype(r, r->in.info);
17539         {
17540                 union srvsvc_NetSrvInfo *info_switch_1;
17541                 info_switch_1 = py_export_srvsvc_NetSrvInfo(r, r->in.level, py_info);
17542                 if (info_switch_1 == NULL) {
17543                         return false;
17544                 }
17545                 r->in.info = info_switch_1;
17546         }
17547         if (py_parm_error == Py_None) {
17548                 r->in.parm_error = NULL;
17549         } else {
17550                 r->in.parm_error = talloc_ptrtype(r, r->in.parm_error);
17551                 PY_CHECK_TYPE(&PyInt_Type, py_parm_error, return false;);
17552                 *r->in.parm_error = PyInt_AsLong(py_parm_error);
17553         }
17554         return true;
17555 }
17556
17557 static PyObject *unpack_py_srvsvc_NetSrvSetInfo_args_out(struct srvsvc_NetSrvSetInfo *r)
17558 {
17559         PyObject *result;
17560         PyObject *py_parm_error;
17561         if (r->out.parm_error == NULL) {
17562                 py_parm_error = Py_None;
17563                 Py_INCREF(py_parm_error);
17564         } else {
17565                 py_parm_error = PyInt_FromLong(*r->out.parm_error);
17566         }
17567         result = py_parm_error;
17568         if (!W_ERROR_IS_OK(r->out.result)) {
17569                 PyErr_SetWERROR(r->out.result);
17570                 return NULL;
17571         }
17572
17573         return result;
17574 }
17575
17576 static bool pack_py_srvsvc_NetDiskEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetDiskEnum *r)
17577 {
17578         PyObject *py_server_unc;
17579         PyObject *py_level;
17580         PyObject *py_info;
17581         PyObject *py_maxlen;
17582         PyObject *py_resume_handle;
17583         const char *kwnames[] = {
17584                 "server_unc", "level", "info", "maxlen", "resume_handle", NULL
17585         };
17586
17587         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)) {
17588                 return false;
17589         }
17590
17591         if (py_server_unc == Py_None) {
17592                 r->in.server_unc = NULL;
17593         } else {
17594                 r->in.server_unc = NULL;
17595                 if (PyUnicode_Check(py_server_unc)) {
17596                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17597                 } else if (PyString_Check(py_server_unc)) {
17598                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17599                 } else {
17600                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17601                         return false;
17602                 }
17603         }
17604         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17605         r->in.level = PyInt_AsLong(py_level);
17606         r->in.info = talloc_ptrtype(r, r->in.info);
17607         PY_CHECK_TYPE(&srvsvc_NetDiskInfo_Type, py_info, return false;);
17608         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
17609                 PyErr_NoMemory();
17610                 return false;
17611         }
17612         r->in.info = (struct srvsvc_NetDiskInfo *)pytalloc_get_ptr(py_info);
17613         PY_CHECK_TYPE(&PyInt_Type, py_maxlen, return false;);
17614         r->in.maxlen = PyInt_AsLong(py_maxlen);
17615         if (py_resume_handle == Py_None) {
17616                 r->in.resume_handle = NULL;
17617         } else {
17618                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17619                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17620                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17621         }
17622         return true;
17623 }
17624
17625 static PyObject *unpack_py_srvsvc_NetDiskEnum_args_out(struct srvsvc_NetDiskEnum *r)
17626 {
17627         PyObject *result;
17628         PyObject *py_info;
17629         PyObject *py_totalentries;
17630         PyObject *py_resume_handle;
17631         result = PyTuple_New(3);
17632         py_info = pytalloc_reference_ex(&srvsvc_NetDiskInfo_Type, r->out.info, r->out.info);
17633         PyTuple_SetItem(result, 0, py_info);
17634         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17635         PyTuple_SetItem(result, 1, py_totalentries);
17636         if (r->out.resume_handle == NULL) {
17637                 py_resume_handle = Py_None;
17638                 Py_INCREF(py_resume_handle);
17639         } else {
17640                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17641         }
17642         PyTuple_SetItem(result, 2, py_resume_handle);
17643         if (!W_ERROR_IS_OK(r->out.result)) {
17644                 PyErr_SetWERROR(r->out.result);
17645                 return NULL;
17646         }
17647
17648         return result;
17649 }
17650
17651 static bool pack_py_srvsvc_NetServerStatisticsGet_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerStatisticsGet *r)
17652 {
17653         PyObject *py_server_unc;
17654         PyObject *py_service;
17655         PyObject *py_level;
17656         PyObject *py_options;
17657         const char *kwnames[] = {
17658                 "server_unc", "service", "level", "options", NULL
17659         };
17660
17661         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetServerStatisticsGet", discard_const_p(char *, kwnames), &py_server_unc, &py_service, &py_level, &py_options)) {
17662                 return false;
17663         }
17664
17665         if (py_server_unc == Py_None) {
17666                 r->in.server_unc = NULL;
17667         } else {
17668                 r->in.server_unc = NULL;
17669                 if (PyUnicode_Check(py_server_unc)) {
17670                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17671                 } else if (PyString_Check(py_server_unc)) {
17672                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17673                 } else {
17674                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17675                         return false;
17676                 }
17677         }
17678         if (py_service == Py_None) {
17679                 r->in.service = NULL;
17680         } else {
17681                 r->in.service = NULL;
17682                 if (PyUnicode_Check(py_service)) {
17683                         r->in.service = PyString_AS_STRING(PyUnicode_AsEncodedString(py_service, "utf-8", "ignore"));
17684                 } else if (PyString_Check(py_service)) {
17685                         r->in.service = PyString_AS_STRING(py_service);
17686                 } else {
17687                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_service)->tp_name);
17688                         return false;
17689                 }
17690         }
17691         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17692         r->in.level = PyInt_AsLong(py_level);
17693         PY_CHECK_TYPE(&PyInt_Type, py_options, return false;);
17694         r->in.options = PyInt_AsLong(py_options);
17695         return true;
17696 }
17697
17698 static PyObject *unpack_py_srvsvc_NetServerStatisticsGet_args_out(struct srvsvc_NetServerStatisticsGet *r)
17699 {
17700         PyObject *result;
17701         PyObject *py_stats;
17702         if (*r->out.stats == NULL) {
17703                 py_stats = Py_None;
17704                 Py_INCREF(py_stats);
17705         } else {
17706                 py_stats = pytalloc_reference_ex(&srvsvc_Statistics_Type, *r->out.stats, *r->out.stats);
17707         }
17708         result = py_stats;
17709         if (!W_ERROR_IS_OK(r->out.result)) {
17710                 PyErr_SetWERROR(r->out.result);
17711                 return NULL;
17712         }
17713
17714         return result;
17715 }
17716
17717 static bool pack_py_srvsvc_NetTransportAdd_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportAdd *r)
17718 {
17719         PyObject *py_server_unc;
17720         PyObject *py_level;
17721         PyObject *py_info;
17722         const char *kwnames[] = {
17723                 "server_unc", "level", "info", NULL
17724         };
17725
17726         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportAdd", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
17727                 return false;
17728         }
17729
17730         if (py_server_unc == Py_None) {
17731                 r->in.server_unc = NULL;
17732         } else {
17733                 r->in.server_unc = NULL;
17734                 if (PyUnicode_Check(py_server_unc)) {
17735                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17736                 } else if (PyString_Check(py_server_unc)) {
17737                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17738                 } else {
17739                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17740                         return false;
17741                 }
17742         }
17743         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17744         r->in.level = PyInt_AsLong(py_level);
17745         {
17746                 union srvsvc_NetTransportInfo *info_switch_0;
17747                 info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
17748                 if (info_switch_0 == NULL) {
17749                         return false;
17750                 }
17751                 r->in.info = *info_switch_0;
17752         }
17753         return true;
17754 }
17755
17756 static PyObject *unpack_py_srvsvc_NetTransportAdd_args_out(struct srvsvc_NetTransportAdd *r)
17757 {
17758         PyObject *result;
17759         result = Py_None;
17760         Py_INCREF(result);
17761         if (!W_ERROR_IS_OK(r->out.result)) {
17762                 PyErr_SetWERROR(r->out.result);
17763                 return NULL;
17764         }
17765
17766         return result;
17767 }
17768
17769 static bool pack_py_srvsvc_NetTransportEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportEnum *r)
17770 {
17771         PyObject *py_server_unc;
17772         PyObject *py_transports;
17773         PyObject *py_max_buffer;
17774         PyObject *py_resume_handle;
17775         const char *kwnames[] = {
17776                 "server_unc", "transports", "max_buffer", "resume_handle", NULL
17777         };
17778
17779         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetTransportEnum", discard_const_p(char *, kwnames), &py_server_unc, &py_transports, &py_max_buffer, &py_resume_handle)) {
17780                 return false;
17781         }
17782
17783         if (py_server_unc == Py_None) {
17784                 r->in.server_unc = NULL;
17785         } else {
17786                 r->in.server_unc = NULL;
17787                 if (PyUnicode_Check(py_server_unc)) {
17788                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17789                 } else if (PyString_Check(py_server_unc)) {
17790                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17791                 } else {
17792                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17793                         return false;
17794                 }
17795         }
17796         r->in.transports = talloc_ptrtype(r, r->in.transports);
17797         PY_CHECK_TYPE(&srvsvc_NetTransportInfoCtr_Type, py_transports, return false;);
17798         if (talloc_reference(r, pytalloc_get_mem_ctx(py_transports)) == NULL) {
17799                 PyErr_NoMemory();
17800                 return false;
17801         }
17802         r->in.transports = (struct srvsvc_NetTransportInfoCtr *)pytalloc_get_ptr(py_transports);
17803         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
17804         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
17805         if (py_resume_handle == Py_None) {
17806                 r->in.resume_handle = NULL;
17807         } else {
17808                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
17809                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
17810                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
17811         }
17812         return true;
17813 }
17814
17815 static PyObject *unpack_py_srvsvc_NetTransportEnum_args_out(struct srvsvc_NetTransportEnum *r)
17816 {
17817         PyObject *result;
17818         PyObject *py_transports;
17819         PyObject *py_totalentries;
17820         PyObject *py_resume_handle;
17821         result = PyTuple_New(3);
17822         py_transports = pytalloc_reference_ex(&srvsvc_NetTransportInfoCtr_Type, r->out.transports, r->out.transports);
17823         PyTuple_SetItem(result, 0, py_transports);
17824         py_totalentries = PyInt_FromLong(*r->out.totalentries);
17825         PyTuple_SetItem(result, 1, py_totalentries);
17826         if (r->out.resume_handle == NULL) {
17827                 py_resume_handle = Py_None;
17828                 Py_INCREF(py_resume_handle);
17829         } else {
17830                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
17831         }
17832         PyTuple_SetItem(result, 2, py_resume_handle);
17833         if (!W_ERROR_IS_OK(r->out.result)) {
17834                 PyErr_SetWERROR(r->out.result);
17835                 return NULL;
17836         }
17837
17838         return result;
17839 }
17840
17841 static bool pack_py_srvsvc_NetTransportDel_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetTransportDel *r)
17842 {
17843         PyObject *py_server_unc;
17844         PyObject *py_level;
17845         PyObject *py_info0;
17846         const char *kwnames[] = {
17847                 "server_unc", "level", "info0", NULL
17848         };
17849
17850         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetTransportDel", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info0)) {
17851                 return false;
17852         }
17853
17854         if (py_server_unc == Py_None) {
17855                 r->in.server_unc = NULL;
17856         } else {
17857                 r->in.server_unc = NULL;
17858                 if (PyUnicode_Check(py_server_unc)) {
17859                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17860                 } else if (PyString_Check(py_server_unc)) {
17861                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17862                 } else {
17863                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17864                         return false;
17865                 }
17866         }
17867         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
17868         r->in.level = PyInt_AsLong(py_level);
17869         r->in.info0 = talloc_ptrtype(r, r->in.info0);
17870         PY_CHECK_TYPE(&srvsvc_NetTransportInfo0_Type, py_info0, return false;);
17871         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info0)) == NULL) {
17872                 PyErr_NoMemory();
17873                 return false;
17874         }
17875         r->in.info0 = (struct srvsvc_NetTransportInfo0 *)pytalloc_get_ptr(py_info0);
17876         return true;
17877 }
17878
17879 static PyObject *unpack_py_srvsvc_NetTransportDel_args_out(struct srvsvc_NetTransportDel *r)
17880 {
17881         PyObject *result;
17882         result = Py_None;
17883         Py_INCREF(result);
17884         if (!W_ERROR_IS_OK(r->out.result)) {
17885                 PyErr_SetWERROR(r->out.result);
17886                 return NULL;
17887         }
17888
17889         return result;
17890 }
17891
17892 static bool pack_py_srvsvc_NetRemoteTOD_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetRemoteTOD *r)
17893 {
17894         PyObject *py_server_unc;
17895         const char *kwnames[] = {
17896                 "server_unc", NULL
17897         };
17898
17899         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetRemoteTOD", discard_const_p(char *, kwnames), &py_server_unc)) {
17900                 return false;
17901         }
17902
17903         if (py_server_unc == Py_None) {
17904                 r->in.server_unc = NULL;
17905         } else {
17906                 r->in.server_unc = NULL;
17907                 if (PyUnicode_Check(py_server_unc)) {
17908                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17909                 } else if (PyString_Check(py_server_unc)) {
17910                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17911                 } else {
17912                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17913                         return false;
17914                 }
17915         }
17916         return true;
17917 }
17918
17919 static PyObject *unpack_py_srvsvc_NetRemoteTOD_args_out(struct srvsvc_NetRemoteTOD *r)
17920 {
17921         PyObject *result;
17922         PyObject *py_info;
17923         if (*r->out.info == NULL) {
17924                 py_info = Py_None;
17925                 Py_INCREF(py_info);
17926         } else {
17927                 py_info = pytalloc_reference_ex(&srvsvc_NetRemoteTODInfo_Type, *r->out.info, *r->out.info);
17928         }
17929         result = py_info;
17930         if (!W_ERROR_IS_OK(r->out.result)) {
17931                 PyErr_SetWERROR(r->out.result);
17932                 return NULL;
17933         }
17934
17935         return result;
17936 }
17937
17938 static bool pack_py_srvsvc_NetSetServiceBits_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetServiceBits *r)
17939 {
17940         PyObject *py_server_unc;
17941         PyObject *py_transport;
17942         PyObject *py_servicebits;
17943         PyObject *py_updateimmediately;
17944         const char *kwnames[] = {
17945                 "server_unc", "transport", "servicebits", "updateimmediately", NULL
17946         };
17947
17948         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetSetServiceBits", discard_const_p(char *, kwnames), &py_server_unc, &py_transport, &py_servicebits, &py_updateimmediately)) {
17949                 return false;
17950         }
17951
17952         if (py_server_unc == Py_None) {
17953                 r->in.server_unc = NULL;
17954         } else {
17955                 r->in.server_unc = NULL;
17956                 if (PyUnicode_Check(py_server_unc)) {
17957                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
17958                 } else if (PyString_Check(py_server_unc)) {
17959                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
17960                 } else {
17961                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
17962                         return false;
17963                 }
17964         }
17965         if (py_transport == Py_None) {
17966                 r->in.transport = NULL;
17967         } else {
17968                 r->in.transport = NULL;
17969                 if (PyUnicode_Check(py_transport)) {
17970                         r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
17971                 } else if (PyString_Check(py_transport)) {
17972                         r->in.transport = PyString_AS_STRING(py_transport);
17973                 } else {
17974                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
17975                         return false;
17976                 }
17977         }
17978         PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
17979         r->in.servicebits = PyInt_AsLong(py_servicebits);
17980         PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
17981         r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
17982         return true;
17983 }
17984
17985 static PyObject *unpack_py_srvsvc_NetSetServiceBits_args_out(struct srvsvc_NetSetServiceBits *r)
17986 {
17987         PyObject *result;
17988         result = Py_None;
17989         Py_INCREF(result);
17990         if (!W_ERROR_IS_OK(r->out.result)) {
17991                 PyErr_SetWERROR(r->out.result);
17992                 return NULL;
17993         }
17994
17995         return result;
17996 }
17997
17998 static bool pack_py_srvsvc_NetPathType_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathType *r)
17999 {
18000         PyObject *py_server_unc;
18001         PyObject *py_path;
18002         PyObject *py_pathflags;
18003         const char *kwnames[] = {
18004                 "server_unc", "path", "pathflags", NULL
18005         };
18006
18007         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetPathType", discard_const_p(char *, kwnames), &py_server_unc, &py_path, &py_pathflags)) {
18008                 return false;
18009         }
18010
18011         if (py_server_unc == Py_None) {
18012                 r->in.server_unc = NULL;
18013         } else {
18014                 r->in.server_unc = NULL;
18015                 if (PyUnicode_Check(py_server_unc)) {
18016                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18017                 } else if (PyString_Check(py_server_unc)) {
18018                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18019                 } else {
18020                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18021                         return false;
18022                 }
18023         }
18024         if (PyUnicode_Check(py_path)) {
18025                 r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
18026         } else if (PyString_Check(py_path)) {
18027                 r->in.path = PyString_AS_STRING(py_path);
18028         } else {
18029                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
18030                 return false;
18031         }
18032         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18033         r->in.pathflags = PyInt_AsLong(py_pathflags);
18034         return true;
18035 }
18036
18037 static PyObject *unpack_py_srvsvc_NetPathType_args_out(struct srvsvc_NetPathType *r)
18038 {
18039         PyObject *result;
18040         PyObject *py_pathtype;
18041         py_pathtype = PyInt_FromLong(*r->out.pathtype);
18042         result = py_pathtype;
18043         if (!W_ERROR_IS_OK(r->out.result)) {
18044                 PyErr_SetWERROR(r->out.result);
18045                 return NULL;
18046         }
18047
18048         return result;
18049 }
18050
18051 static bool pack_py_srvsvc_NetPathCanonicalize_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCanonicalize *r)
18052 {
18053         PyObject *py_server_unc;
18054         PyObject *py_path;
18055         PyObject *py_maxbuf;
18056         PyObject *py_prefix;
18057         PyObject *py_pathtype;
18058         PyObject *py_pathflags;
18059         const char *kwnames[] = {
18060                 "server_unc", "path", "maxbuf", "prefix", "pathtype", "pathflags", NULL
18061         };
18062
18063         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)) {
18064                 return false;
18065         }
18066
18067         if (py_server_unc == Py_None) {
18068                 r->in.server_unc = NULL;
18069         } else {
18070                 r->in.server_unc = NULL;
18071                 if (PyUnicode_Check(py_server_unc)) {
18072                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18073                 } else if (PyString_Check(py_server_unc)) {
18074                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18075                 } else {
18076                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18077                         return false;
18078                 }
18079         }
18080         if (PyUnicode_Check(py_path)) {
18081                 r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
18082         } else if (PyString_Check(py_path)) {
18083                 r->in.path = PyString_AS_STRING(py_path);
18084         } else {
18085                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
18086                 return false;
18087         }
18088         PY_CHECK_TYPE(&PyInt_Type, py_maxbuf, return false;);
18089         r->in.maxbuf = PyInt_AsLong(py_maxbuf);
18090         if (PyUnicode_Check(py_prefix)) {
18091                 r->in.prefix = PyString_AS_STRING(PyUnicode_AsEncodedString(py_prefix, "utf-8", "ignore"));
18092         } else if (PyString_Check(py_prefix)) {
18093                 r->in.prefix = PyString_AS_STRING(py_prefix);
18094         } else {
18095                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_prefix)->tp_name);
18096                 return false;
18097         }
18098         r->in.pathtype = talloc_ptrtype(r, r->in.pathtype);
18099         PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
18100         *r->in.pathtype = PyInt_AsLong(py_pathtype);
18101         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18102         r->in.pathflags = PyInt_AsLong(py_pathflags);
18103         return true;
18104 }
18105
18106 static PyObject *unpack_py_srvsvc_NetPathCanonicalize_args_out(struct srvsvc_NetPathCanonicalize *r)
18107 {
18108         PyObject *result;
18109         PyObject *py_can_path;
18110         PyObject *py_pathtype;
18111         result = PyTuple_New(2);
18112         py_can_path = PyList_New(r->in.maxbuf);
18113         if (py_can_path == NULL) {
18114                 return NULL;
18115         }
18116         {
18117                 int can_path_cntr_0;
18118                 for (can_path_cntr_0 = 0; can_path_cntr_0 < r->in.maxbuf; can_path_cntr_0++) {
18119                         PyObject *py_can_path_0;
18120                         py_can_path_0 = PyInt_FromLong(r->out.can_path[can_path_cntr_0]);
18121                         PyList_SetItem(py_can_path, can_path_cntr_0, py_can_path_0);
18122                 }
18123         }
18124         PyTuple_SetItem(result, 0, py_can_path);
18125         py_pathtype = PyInt_FromLong(*r->out.pathtype);
18126         PyTuple_SetItem(result, 1, py_pathtype);
18127         if (!W_ERROR_IS_OK(r->out.result)) {
18128                 PyErr_SetWERROR(r->out.result);
18129                 return NULL;
18130         }
18131
18132         return result;
18133 }
18134
18135 static bool pack_py_srvsvc_NetPathCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPathCompare *r)
18136 {
18137         PyObject *py_server_unc;
18138         PyObject *py_path1;
18139         PyObject *py_path2;
18140         PyObject *py_pathtype;
18141         PyObject *py_pathflags;
18142         const char *kwnames[] = {
18143                 "server_unc", "path1", "path2", "pathtype", "pathflags", NULL
18144         };
18145
18146         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:srvsvc_NetPathCompare", discard_const_p(char *, kwnames), &py_server_unc, &py_path1, &py_path2, &py_pathtype, &py_pathflags)) {
18147                 return false;
18148         }
18149
18150         if (py_server_unc == Py_None) {
18151                 r->in.server_unc = NULL;
18152         } else {
18153                 r->in.server_unc = NULL;
18154                 if (PyUnicode_Check(py_server_unc)) {
18155                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18156                 } else if (PyString_Check(py_server_unc)) {
18157                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18158                 } else {
18159                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18160                         return false;
18161                 }
18162         }
18163         if (PyUnicode_Check(py_path1)) {
18164                 r->in.path1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path1, "utf-8", "ignore"));
18165         } else if (PyString_Check(py_path1)) {
18166                 r->in.path1 = PyString_AS_STRING(py_path1);
18167         } else {
18168                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path1)->tp_name);
18169                 return false;
18170         }
18171         if (PyUnicode_Check(py_path2)) {
18172                 r->in.path2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path2, "utf-8", "ignore"));
18173         } else if (PyString_Check(py_path2)) {
18174                 r->in.path2 = PyString_AS_STRING(py_path2);
18175         } else {
18176                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path2)->tp_name);
18177                 return false;
18178         }
18179         PY_CHECK_TYPE(&PyInt_Type, py_pathtype, return false;);
18180         r->in.pathtype = PyInt_AsLong(py_pathtype);
18181         PY_CHECK_TYPE(&PyInt_Type, py_pathflags, return false;);
18182         r->in.pathflags = PyInt_AsLong(py_pathflags);
18183         return true;
18184 }
18185
18186 static PyObject *unpack_py_srvsvc_NetPathCompare_args_out(struct srvsvc_NetPathCompare *r)
18187 {
18188         PyObject *result;
18189         result = Py_None;
18190         Py_INCREF(result);
18191         if (!W_ERROR_IS_OK(r->out.result)) {
18192                 PyErr_SetWERROR(r->out.result);
18193                 return NULL;
18194         }
18195
18196         return result;
18197 }
18198
18199 static bool pack_py_srvsvc_NetNameValidate_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetNameValidate *r)
18200 {
18201         PyObject *py_server_unc;
18202         PyObject *py_name;
18203         PyObject *py_name_type;
18204         PyObject *py_flags;
18205         const char *kwnames[] = {
18206                 "server_unc", "name", "name_type", "flags", NULL
18207         };
18208
18209         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetNameValidate", discard_const_p(char *, kwnames), &py_server_unc, &py_name, &py_name_type, &py_flags)) {
18210                 return false;
18211         }
18212
18213         if (py_server_unc == Py_None) {
18214                 r->in.server_unc = NULL;
18215         } else {
18216                 r->in.server_unc = NULL;
18217                 if (PyUnicode_Check(py_server_unc)) {
18218                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18219                 } else if (PyString_Check(py_server_unc)) {
18220                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18221                 } else {
18222                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18223                         return false;
18224                 }
18225         }
18226         if (PyUnicode_Check(py_name)) {
18227                 r->in.name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name, "utf-8", "ignore"));
18228         } else if (PyString_Check(py_name)) {
18229                 r->in.name = PyString_AS_STRING(py_name);
18230         } else {
18231                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name)->tp_name);
18232                 return false;
18233         }
18234         PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
18235         r->in.name_type = PyInt_AsLong(py_name_type);
18236         PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
18237         r->in.flags = PyInt_AsLong(py_flags);
18238         return true;
18239 }
18240
18241 static PyObject *unpack_py_srvsvc_NetNameValidate_args_out(struct srvsvc_NetNameValidate *r)
18242 {
18243         PyObject *result;
18244         result = Py_None;
18245         Py_INCREF(result);
18246         if (!W_ERROR_IS_OK(r->out.result)) {
18247                 PyErr_SetWERROR(r->out.result);
18248                 return NULL;
18249         }
18250
18251         return result;
18252 }
18253
18254 static bool pack_py_srvsvc_NetPRNameCompare_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetPRNameCompare *r)
18255 {
18256         PyObject *py_server_unc;
18257         PyObject *py_name1;
18258         PyObject *py_name2;
18259         PyObject *py_name_type;
18260         PyObject *py_flags;
18261         const char *kwnames[] = {
18262                 "server_unc", "name1", "name2", "name_type", "flags", NULL
18263         };
18264
18265         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)) {
18266                 return false;
18267         }
18268
18269         if (py_server_unc == Py_None) {
18270                 r->in.server_unc = NULL;
18271         } else {
18272                 r->in.server_unc = NULL;
18273                 if (PyUnicode_Check(py_server_unc)) {
18274                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18275                 } else if (PyString_Check(py_server_unc)) {
18276                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18277                 } else {
18278                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18279                         return false;
18280                 }
18281         }
18282         if (PyUnicode_Check(py_name1)) {
18283                 r->in.name1 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name1, "utf-8", "ignore"));
18284         } else if (PyString_Check(py_name1)) {
18285                 r->in.name1 = PyString_AS_STRING(py_name1);
18286         } else {
18287                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name1)->tp_name);
18288                 return false;
18289         }
18290         if (PyUnicode_Check(py_name2)) {
18291                 r->in.name2 = PyString_AS_STRING(PyUnicode_AsEncodedString(py_name2, "utf-8", "ignore"));
18292         } else if (PyString_Check(py_name2)) {
18293                 r->in.name2 = PyString_AS_STRING(py_name2);
18294         } else {
18295                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_name2)->tp_name);
18296                 return false;
18297         }
18298         PY_CHECK_TYPE(&PyInt_Type, py_name_type, return false;);
18299         r->in.name_type = PyInt_AsLong(py_name_type);
18300         PY_CHECK_TYPE(&PyInt_Type, py_flags, return false;);
18301         r->in.flags = PyInt_AsLong(py_flags);
18302         return true;
18303 }
18304
18305 static PyObject *unpack_py_srvsvc_NetPRNameCompare_args_out(struct srvsvc_NetPRNameCompare *r)
18306 {
18307         PyObject *result;
18308         result = Py_None;
18309         Py_INCREF(result);
18310         if (!W_ERROR_IS_OK(r->out.result)) {
18311                 PyErr_SetWERROR(r->out.result);
18312                 return NULL;
18313         }
18314
18315         return result;
18316 }
18317
18318 static bool pack_py_srvsvc_NetShareEnum_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareEnum *r)
18319 {
18320         PyObject *py_server_unc;
18321         PyObject *py_info_ctr;
18322         PyObject *py_max_buffer;
18323         PyObject *py_resume_handle;
18324         const char *kwnames[] = {
18325                 "server_unc", "info_ctr", "max_buffer", "resume_handle", NULL
18326         };
18327
18328         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)) {
18329                 return false;
18330         }
18331
18332         if (py_server_unc == Py_None) {
18333                 r->in.server_unc = NULL;
18334         } else {
18335                 r->in.server_unc = NULL;
18336                 if (PyUnicode_Check(py_server_unc)) {
18337                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18338                 } else if (PyString_Check(py_server_unc)) {
18339                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18340                 } else {
18341                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18342                         return false;
18343                 }
18344         }
18345         r->in.info_ctr = talloc_ptrtype(r, r->in.info_ctr);
18346         PY_CHECK_TYPE(&srvsvc_NetShareInfoCtr_Type, py_info_ctr, return false;);
18347         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info_ctr)) == NULL) {
18348                 PyErr_NoMemory();
18349                 return false;
18350         }
18351         r->in.info_ctr = (struct srvsvc_NetShareInfoCtr *)pytalloc_get_ptr(py_info_ctr);
18352         PY_CHECK_TYPE(&PyInt_Type, py_max_buffer, return false;);
18353         r->in.max_buffer = PyInt_AsLong(py_max_buffer);
18354         if (py_resume_handle == Py_None) {
18355                 r->in.resume_handle = NULL;
18356         } else {
18357                 r->in.resume_handle = talloc_ptrtype(r, r->in.resume_handle);
18358                 PY_CHECK_TYPE(&PyInt_Type, py_resume_handle, return false;);
18359                 *r->in.resume_handle = PyInt_AsLong(py_resume_handle);
18360         }
18361         return true;
18362 }
18363
18364 static PyObject *unpack_py_srvsvc_NetShareEnum_args_out(struct srvsvc_NetShareEnum *r)
18365 {
18366         PyObject *result;
18367         PyObject *py_info_ctr;
18368         PyObject *py_totalentries;
18369         PyObject *py_resume_handle;
18370         result = PyTuple_New(3);
18371         py_info_ctr = pytalloc_reference_ex(&srvsvc_NetShareInfoCtr_Type, r->out.info_ctr, r->out.info_ctr);
18372         PyTuple_SetItem(result, 0, py_info_ctr);
18373         py_totalentries = PyInt_FromLong(*r->out.totalentries);
18374         PyTuple_SetItem(result, 1, py_totalentries);
18375         if (r->out.resume_handle == NULL) {
18376                 py_resume_handle = Py_None;
18377                 Py_INCREF(py_resume_handle);
18378         } else {
18379                 py_resume_handle = PyInt_FromLong(*r->out.resume_handle);
18380         }
18381         PyTuple_SetItem(result, 2, py_resume_handle);
18382         if (!W_ERROR_IS_OK(r->out.result)) {
18383                 PyErr_SetWERROR(r->out.result);
18384                 return NULL;
18385         }
18386
18387         return result;
18388 }
18389
18390 static bool pack_py_srvsvc_NetShareDelStart_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelStart *r)
18391 {
18392         PyObject *py_server_unc;
18393         PyObject *py_share;
18394         PyObject *py_reserved;
18395         const char *kwnames[] = {
18396                 "server_unc", "share", "reserved", NULL
18397         };
18398
18399         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetShareDelStart", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_reserved)) {
18400                 return false;
18401         }
18402
18403         if (py_server_unc == Py_None) {
18404                 r->in.server_unc = NULL;
18405         } else {
18406                 r->in.server_unc = NULL;
18407                 if (PyUnicode_Check(py_server_unc)) {
18408                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18409                 } else if (PyString_Check(py_server_unc)) {
18410                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18411                 } else {
18412                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18413                         return false;
18414                 }
18415         }
18416         if (PyUnicode_Check(py_share)) {
18417                 r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18418         } else if (PyString_Check(py_share)) {
18419                 r->in.share = PyString_AS_STRING(py_share);
18420         } else {
18421                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18422                 return false;
18423         }
18424         PY_CHECK_TYPE(&PyInt_Type, py_reserved, return false;);
18425         r->in.reserved = PyInt_AsLong(py_reserved);
18426         return true;
18427 }
18428
18429 static PyObject *unpack_py_srvsvc_NetShareDelStart_args_out(struct srvsvc_NetShareDelStart *r)
18430 {
18431         PyObject *result;
18432         PyObject *py_hnd;
18433         if (r->out.hnd == NULL) {
18434                 py_hnd = Py_None;
18435                 Py_INCREF(py_hnd);
18436         } else {
18437                 py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
18438         }
18439         result = py_hnd;
18440         if (!W_ERROR_IS_OK(r->out.result)) {
18441                 PyErr_SetWERROR(r->out.result);
18442                 return NULL;
18443         }
18444
18445         return result;
18446 }
18447
18448 static bool pack_py_srvsvc_NetShareDelCommit_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetShareDelCommit *r)
18449 {
18450         PyObject *py_hnd;
18451         const char *kwnames[] = {
18452                 "hnd", NULL
18453         };
18454
18455         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:srvsvc_NetShareDelCommit", discard_const_p(char *, kwnames), &py_hnd)) {
18456                 return false;
18457         }
18458
18459         if (py_hnd == Py_None) {
18460                 r->in.hnd = NULL;
18461         } else {
18462                 r->in.hnd = NULL;
18463                 PY_CHECK_TYPE(policy_handle_Type, py_hnd, return false;);
18464                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_hnd)) == NULL) {
18465                         PyErr_NoMemory();
18466                         return false;
18467                 }
18468                 r->in.hnd = (struct policy_handle *)pytalloc_get_ptr(py_hnd);
18469         }
18470         return true;
18471 }
18472
18473 static PyObject *unpack_py_srvsvc_NetShareDelCommit_args_out(struct srvsvc_NetShareDelCommit *r)
18474 {
18475         PyObject *result;
18476         PyObject *py_hnd;
18477         if (r->out.hnd == NULL) {
18478                 py_hnd = Py_None;
18479                 Py_INCREF(py_hnd);
18480         } else {
18481                 py_hnd = pytalloc_reference_ex(policy_handle_Type, r->out.hnd, r->out.hnd);
18482         }
18483         result = py_hnd;
18484         if (!W_ERROR_IS_OK(r->out.result)) {
18485                 PyErr_SetWERROR(r->out.result);
18486                 return NULL;
18487         }
18488
18489         return result;
18490 }
18491
18492 static bool pack_py_srvsvc_NetGetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetGetFileSecurity *r)
18493 {
18494         PyObject *py_server_unc;
18495         PyObject *py_share;
18496         PyObject *py_file;
18497         PyObject *py_securityinformation;
18498         const char *kwnames[] = {
18499                 "server_unc", "share", "file", "securityinformation", NULL
18500         };
18501
18502         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:srvsvc_NetGetFileSecurity", discard_const_p(char *, kwnames), &py_server_unc, &py_share, &py_file, &py_securityinformation)) {
18503                 return false;
18504         }
18505
18506         if (py_server_unc == Py_None) {
18507                 r->in.server_unc = NULL;
18508         } else {
18509                 r->in.server_unc = NULL;
18510                 if (PyUnicode_Check(py_server_unc)) {
18511                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18512                 } else if (PyString_Check(py_server_unc)) {
18513                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18514                 } else {
18515                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18516                         return false;
18517                 }
18518         }
18519         if (py_share == Py_None) {
18520                 r->in.share = NULL;
18521         } else {
18522                 r->in.share = NULL;
18523                 if (PyUnicode_Check(py_share)) {
18524                         r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18525                 } else if (PyString_Check(py_share)) {
18526                         r->in.share = PyString_AS_STRING(py_share);
18527                 } else {
18528                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18529                         return false;
18530                 }
18531         }
18532         if (PyUnicode_Check(py_file)) {
18533                 r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
18534         } else if (PyString_Check(py_file)) {
18535                 r->in.file = PyString_AS_STRING(py_file);
18536         } else {
18537                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
18538                 return false;
18539         }
18540         if (PyLong_Check(py_securityinformation)) {
18541                 r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
18542         } else if (PyInt_Check(py_securityinformation)) {
18543                 r->in.securityinformation = PyInt_AsLong(py_securityinformation);
18544         } else {
18545                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
18546                   PyInt_Type.tp_name, PyLong_Type.tp_name);
18547                 return false;
18548         }
18549         return true;
18550 }
18551
18552 static PyObject *unpack_py_srvsvc_NetGetFileSecurity_args_out(struct srvsvc_NetGetFileSecurity *r)
18553 {
18554         PyObject *result;
18555         PyObject *py_sd_buf;
18556         if (*r->out.sd_buf == NULL) {
18557                 py_sd_buf = Py_None;
18558                 Py_INCREF(py_sd_buf);
18559         } else {
18560                 py_sd_buf = pytalloc_reference_ex(sec_desc_buf_Type, *r->out.sd_buf, *r->out.sd_buf);
18561         }
18562         result = py_sd_buf;
18563         if (!W_ERROR_IS_OK(r->out.result)) {
18564                 PyErr_SetWERROR(r->out.result);
18565                 return NULL;
18566         }
18567
18568         return result;
18569 }
18570
18571 static bool pack_py_srvsvc_NetSetFileSecurity_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetSetFileSecurity *r)
18572 {
18573         PyObject *py_server_unc;
18574         PyObject *py_share;
18575         PyObject *py_file;
18576         PyObject *py_securityinformation;
18577         PyObject *py_sd_buf;
18578         const char *kwnames[] = {
18579                 "server_unc", "share", "file", "securityinformation", "sd_buf", NULL
18580         };
18581
18582         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)) {
18583                 return false;
18584         }
18585
18586         if (py_server_unc == Py_None) {
18587                 r->in.server_unc = NULL;
18588         } else {
18589                 r->in.server_unc = NULL;
18590                 if (PyUnicode_Check(py_server_unc)) {
18591                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18592                 } else if (PyString_Check(py_server_unc)) {
18593                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18594                 } else {
18595                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18596                         return false;
18597                 }
18598         }
18599         if (py_share == Py_None) {
18600                 r->in.share = NULL;
18601         } else {
18602                 r->in.share = NULL;
18603                 if (PyUnicode_Check(py_share)) {
18604                         r->in.share = PyString_AS_STRING(PyUnicode_AsEncodedString(py_share, "utf-8", "ignore"));
18605                 } else if (PyString_Check(py_share)) {
18606                         r->in.share = PyString_AS_STRING(py_share);
18607                 } else {
18608                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_share)->tp_name);
18609                         return false;
18610                 }
18611         }
18612         if (PyUnicode_Check(py_file)) {
18613                 r->in.file = PyString_AS_STRING(PyUnicode_AsEncodedString(py_file, "utf-8", "ignore"));
18614         } else if (PyString_Check(py_file)) {
18615                 r->in.file = PyString_AS_STRING(py_file);
18616         } else {
18617                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_file)->tp_name);
18618                 return false;
18619         }
18620         if (PyLong_Check(py_securityinformation)) {
18621                 r->in.securityinformation = PyLong_AsLongLong(py_securityinformation);
18622         } else if (PyInt_Check(py_securityinformation)) {
18623                 r->in.securityinformation = PyInt_AsLong(py_securityinformation);
18624         } else {
18625                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
18626                   PyInt_Type.tp_name, PyLong_Type.tp_name);
18627                 return false;
18628         }
18629         r->in.sd_buf = talloc_ptrtype(r, r->in.sd_buf);
18630         PY_CHECK_TYPE(sec_desc_buf_Type, py_sd_buf, return false;);
18631         if (talloc_reference(r, pytalloc_get_mem_ctx(py_sd_buf)) == NULL) {
18632                 PyErr_NoMemory();
18633                 return false;
18634         }
18635         r->in.sd_buf = (struct sec_desc_buf *)pytalloc_get_ptr(py_sd_buf);
18636         return true;
18637 }
18638
18639 static PyObject *unpack_py_srvsvc_NetSetFileSecurity_args_out(struct srvsvc_NetSetFileSecurity *r)
18640 {
18641         PyObject *result;
18642         result = Py_None;
18643         Py_INCREF(result);
18644         if (!W_ERROR_IS_OK(r->out.result)) {
18645                 PyErr_SetWERROR(r->out.result);
18646                 return NULL;
18647         }
18648
18649         return result;
18650 }
18651
18652 static bool pack_py_srvsvc_NetServerTransportAddEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerTransportAddEx *r)
18653 {
18654         PyObject *py_server_unc;
18655         PyObject *py_level;
18656         PyObject *py_info;
18657         const char *kwnames[] = {
18658                 "server_unc", "level", "info", NULL
18659         };
18660
18661         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:srvsvc_NetServerTransportAddEx", discard_const_p(char *, kwnames), &py_server_unc, &py_level, &py_info)) {
18662                 return false;
18663         }
18664
18665         if (py_server_unc == Py_None) {
18666                 r->in.server_unc = NULL;
18667         } else {
18668                 r->in.server_unc = NULL;
18669                 if (PyUnicode_Check(py_server_unc)) {
18670                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18671                 } else if (PyString_Check(py_server_unc)) {
18672                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18673                 } else {
18674                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18675                         return false;
18676                 }
18677         }
18678         PY_CHECK_TYPE(&PyInt_Type, py_level, return false;);
18679         r->in.level = PyInt_AsLong(py_level);
18680         {
18681                 union srvsvc_NetTransportInfo *info_switch_0;
18682                 info_switch_0 = py_export_srvsvc_NetTransportInfo(r, r->in.level, py_info);
18683                 if (info_switch_0 == NULL) {
18684                         return false;
18685                 }
18686                 r->in.info = *info_switch_0;
18687         }
18688         return true;
18689 }
18690
18691 static PyObject *unpack_py_srvsvc_NetServerTransportAddEx_args_out(struct srvsvc_NetServerTransportAddEx *r)
18692 {
18693         PyObject *result;
18694         result = Py_None;
18695         Py_INCREF(result);
18696         if (!W_ERROR_IS_OK(r->out.result)) {
18697                 PyErr_SetWERROR(r->out.result);
18698                 return NULL;
18699         }
18700
18701         return result;
18702 }
18703
18704 static bool pack_py_srvsvc_NetServerSetServiceBitsEx_args_in(PyObject *args, PyObject *kwargs, struct srvsvc_NetServerSetServiceBitsEx *r)
18705 {
18706         PyObject *py_server_unc;
18707         PyObject *py_emulated_server_unc;
18708         PyObject *py_transport;
18709         PyObject *py_servicebitsofinterest;
18710         PyObject *py_servicebits;
18711         PyObject *py_updateimmediately;
18712         const char *kwnames[] = {
18713                 "server_unc", "emulated_server_unc", "transport", "servicebitsofinterest", "servicebits", "updateimmediately", NULL
18714         };
18715
18716         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)) {
18717                 return false;
18718         }
18719
18720         if (py_server_unc == Py_None) {
18721                 r->in.server_unc = NULL;
18722         } else {
18723                 r->in.server_unc = NULL;
18724                 if (PyUnicode_Check(py_server_unc)) {
18725                         r->in.server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore"));
18726                 } else if (PyString_Check(py_server_unc)) {
18727                         r->in.server_unc = PyString_AS_STRING(py_server_unc);
18728                 } else {
18729                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
18730                         return false;
18731                 }
18732         }
18733         if (py_emulated_server_unc == Py_None) {
18734                 r->in.emulated_server_unc = NULL;
18735         } else {
18736                 r->in.emulated_server_unc = NULL;
18737                 if (PyUnicode_Check(py_emulated_server_unc)) {
18738                         r->in.emulated_server_unc = PyString_AS_STRING(PyUnicode_AsEncodedString(py_emulated_server_unc, "utf-8", "ignore"));
18739                 } else if (PyString_Check(py_emulated_server_unc)) {
18740                         r->in.emulated_server_unc = PyString_AS_STRING(py_emulated_server_unc);
18741                 } else {
18742                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_emulated_server_unc)->tp_name);
18743                         return false;
18744                 }
18745         }
18746         if (py_transport == Py_None) {
18747                 r->in.transport = NULL;
18748         } else {
18749                 r->in.transport = NULL;
18750                 if (PyUnicode_Check(py_transport)) {
18751                         r->in.transport = PyString_AS_STRING(PyUnicode_AsEncodedString(py_transport, "utf-8", "ignore"));
18752                 } else if (PyString_Check(py_transport)) {
18753                         r->in.transport = PyString_AS_STRING(py_transport);
18754                 } else {
18755                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_transport)->tp_name);
18756                         return false;
18757                 }
18758         }
18759         PY_CHECK_TYPE(&PyInt_Type, py_servicebitsofinterest, return false;);
18760         r->in.servicebitsofinterest = PyInt_AsLong(py_servicebitsofinterest);
18761         PY_CHECK_TYPE(&PyInt_Type, py_servicebits, return false;);
18762         r->in.servicebits = PyInt_AsLong(py_servicebits);
18763         PY_CHECK_TYPE(&PyInt_Type, py_updateimmediately, return false;);
18764         r->in.updateimmediately = PyInt_AsLong(py_updateimmediately);
18765         return true;
18766 }
18767
18768 static PyObject *unpack_py_srvsvc_NetServerSetServiceBitsEx_args_out(struct srvsvc_NetServerSetServiceBitsEx *r)
18769 {
18770         PyObject *result;
18771         result = Py_None;
18772         Py_INCREF(result);
18773         if (!W_ERROR_IS_OK(r->out.result)) {
18774                 PyErr_SetWERROR(r->out.result);
18775                 return NULL;
18776         }
18777
18778         return result;
18779 }
18780
18781 const struct PyNdrRpcMethodDef py_ndr_srvsvc_methods[] = {
18782         { "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 },
18783         { "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 },
18784         { "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 },
18785         { "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 },
18786         { "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 },
18787         { "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 },
18788         { "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 },
18789         { "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 },
18790         { "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 },
18791         { "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 },
18792         { "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 },
18793         { "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 },
18794         { "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 },
18795         { "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 },
18796         { "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 },
18797         { "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 },
18798         { "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 },
18799         { "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 },
18800         { "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 },
18801         { "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 },
18802         { "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 },
18803         { "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 },
18804         { "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 },
18805         { "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 },
18806         { "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 },
18807         { "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 },
18808         { "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 },
18809         { "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 },
18810         { "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 },
18811         { "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 },
18812         { "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 },
18813         { "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 },
18814         { "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 },
18815         { "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 },
18816         { "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 },
18817         { "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 },
18818         { "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 },
18819         { "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 },
18820         { "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 },
18821         { "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 },
18822         { "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 },
18823         { "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 },
18824         { NULL }
18825 };
18826
18827 static PyObject *interface_srvsvc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
18828 {
18829         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_srvsvc);
18830 }
18831
18832 #define PY_DOC_SRVSVC "Server Service"
18833 static PyTypeObject srvsvc_InterfaceType = {
18834         PyObject_HEAD_INIT(NULL) 0,
18835         .tp_name = "srvsvc.srvsvc",
18836         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
18837         .tp_doc = "srvsvc(binding, lp_ctx=None, credentials=None) -> connection\n"
18838 "\n"
18839 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
18840 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
18841 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_SRVSVC,
18842         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
18843         .tp_new = interface_srvsvc_new,
18844 };
18845
18846 static PyMethodDef srvsvc_methods[] = {
18847         { NULL, NULL, 0, NULL }
18848 };
18849
18850 void initsrvsvc(void)
18851 {
18852         PyObject *m;
18853         PyObject *dep_samba_dcerpc_security;
18854         PyObject *dep_talloc;
18855         PyObject *dep_samba_dcerpc_misc;
18856         PyObject *dep_samba_dcerpc_base;
18857         PyObject *dep_samba_dcerpc_svcctl;
18858
18859         dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
18860         if (dep_samba_dcerpc_security == NULL)
18861                 return;
18862
18863         dep_talloc = PyImport_ImportModule("talloc");
18864         if (dep_talloc == NULL)
18865                 return;
18866
18867         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
18868         if (dep_samba_dcerpc_misc == NULL)
18869                 return;
18870
18871         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
18872         if (dep_samba_dcerpc_base == NULL)
18873                 return;
18874
18875         dep_samba_dcerpc_svcctl = PyImport_ImportModule("samba.dcerpc.svcctl");
18876         if (dep_samba_dcerpc_svcctl == NULL)
18877                 return;
18878
18879         sec_desc_buf_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "sec_desc_buf");
18880         if (sec_desc_buf_Type == NULL)
18881                 return;
18882
18883         policy_handle_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "policy_handle");
18884         if (policy_handle_Type == NULL)
18885                 return;
18886
18887         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
18888         if (Object_Type == NULL)
18889                 return;
18890
18891         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
18892         if (ClientConnection_Type == NULL)
18893                 return;
18894
18895         srvsvc_NetCharDevInfo0_Type.tp_base = Object_Type;
18896
18897         srvsvc_NetCharDevCtr0_Type.tp_base = Object_Type;
18898
18899         srvsvc_NetCharDevInfo1_Type.tp_base = Object_Type;
18900
18901         srvsvc_NetCharDevCtr1_Type.tp_base = Object_Type;
18902
18903         srvsvc_NetCharDevInfoCtr_Type.tp_base = Object_Type;
18904
18905         srvsvc_NetCharDevQInfo0_Type.tp_base = Object_Type;
18906
18907         srvsvc_NetCharDevQCtr0_Type.tp_base = Object_Type;
18908
18909         srvsvc_NetCharDevQInfo1_Type.tp_base = Object_Type;
18910
18911         srvsvc_NetCharDevQCtr1_Type.tp_base = Object_Type;
18912
18913         srvsvc_NetCharDevQInfoCtr_Type.tp_base = Object_Type;
18914
18915         srvsvc_NetConnInfo0_Type.tp_base = Object_Type;
18916
18917         srvsvc_NetConnCtr0_Type.tp_base = Object_Type;
18918
18919         srvsvc_NetConnInfo1_Type.tp_base = Object_Type;
18920
18921         srvsvc_NetConnCtr1_Type.tp_base = Object_Type;
18922
18923         srvsvc_NetConnInfoCtr_Type.tp_base = Object_Type;
18924
18925         srvsvc_NetFileInfo2_Type.tp_base = Object_Type;
18926
18927         srvsvc_NetFileCtr2_Type.tp_base = Object_Type;
18928
18929         srvsvc_NetFileInfo3_Type.tp_base = Object_Type;
18930
18931         srvsvc_NetFileCtr3_Type.tp_base = Object_Type;
18932
18933         srvsvc_NetFileInfoCtr_Type.tp_base = Object_Type;
18934
18935         srvsvc_NetSessInfo0_Type.tp_base = Object_Type;
18936
18937         srvsvc_NetSessCtr0_Type.tp_base = Object_Type;
18938
18939         srvsvc_NetSessInfo1_Type.tp_base = Object_Type;
18940
18941         srvsvc_NetSessCtr1_Type.tp_base = Object_Type;
18942
18943         srvsvc_NetSessInfo2_Type.tp_base = Object_Type;
18944
18945         srvsvc_NetSessCtr2_Type.tp_base = Object_Type;
18946
18947         srvsvc_NetSessInfo10_Type.tp_base = Object_Type;
18948
18949         srvsvc_NetSessCtr10_Type.tp_base = Object_Type;
18950
18951         srvsvc_NetSessInfo502_Type.tp_base = Object_Type;
18952
18953         srvsvc_NetSessCtr502_Type.tp_base = Object_Type;
18954
18955         srvsvc_NetSessInfoCtr_Type.tp_base = Object_Type;
18956
18957         srvsvc_NetShareInfo0_Type.tp_base = Object_Type;
18958
18959         srvsvc_NetShareCtr0_Type.tp_base = Object_Type;
18960
18961         srvsvc_NetShareInfo1_Type.tp_base = Object_Type;
18962
18963         srvsvc_NetShareCtr1_Type.tp_base = Object_Type;
18964
18965         srvsvc_NetShareInfo2_Type.tp_base = Object_Type;
18966
18967         srvsvc_NetShareCtr2_Type.tp_base = Object_Type;
18968
18969         srvsvc_NetShareInfo501_Type.tp_base = Object_Type;
18970
18971         srvsvc_NetShareCtr501_Type.tp_base = Object_Type;
18972
18973         srvsvc_NetShareInfo502_Type.tp_base = Object_Type;
18974
18975         srvsvc_NetShareCtr502_Type.tp_base = Object_Type;
18976
18977         srvsvc_NetShareInfo1004_Type.tp_base = Object_Type;
18978
18979         srvsvc_NetShareCtr1004_Type.tp_base = Object_Type;
18980
18981         srvsvc_NetShareInfo1005_Type.tp_base = Object_Type;
18982
18983         srvsvc_NetShareCtr1005_Type.tp_base = Object_Type;
18984
18985         srvsvc_NetShareInfo1006_Type.tp_base = Object_Type;
18986
18987         srvsvc_NetShareCtr1006_Type.tp_base = Object_Type;
18988
18989         srvsvc_NetShareInfo1007_Type.tp_base = Object_Type;
18990
18991         srvsvc_NetShareCtr1007_Type.tp_base = Object_Type;
18992
18993         srvsvc_NetShareCtr1501_Type.tp_base = Object_Type;
18994
18995         srvsvc_NetShareInfoCtr_Type.tp_base = Object_Type;
18996
18997         srvsvc_NetSrvInfo100_Type.tp_base = Object_Type;
18998
18999         srvsvc_NetSrvInfo101_Type.tp_base = Object_Type;
19000
19001         srvsvc_NetSrvInfo102_Type.tp_base = Object_Type;
19002
19003         srvsvc_NetSrvInfo402_Type.tp_base = Object_Type;
19004
19005         srvsvc_NetSrvInfo403_Type.tp_base = Object_Type;
19006
19007         srvsvc_NetSrvInfo502_Type.tp_base = Object_Type;
19008
19009         srvsvc_NetSrvInfo503_Type.tp_base = Object_Type;
19010
19011         srvsvc_NetSrvInfo599_Type.tp_base = Object_Type;
19012
19013         srvsvc_NetSrvInfo1005_Type.tp_base = Object_Type;
19014
19015         srvsvc_NetSrvInfo1010_Type.tp_base = Object_Type;
19016
19017         srvsvc_NetSrvInfo1016_Type.tp_base = Object_Type;
19018
19019         srvsvc_NetSrvInfo1017_Type.tp_base = Object_Type;
19020
19021         srvsvc_NetSrvInfo1018_Type.tp_base = Object_Type;
19022
19023         srvsvc_NetSrvInfo1107_Type.tp_base = Object_Type;
19024
19025         srvsvc_NetSrvInfo1501_Type.tp_base = Object_Type;
19026
19027         srvsvc_NetSrvInfo1502_Type.tp_base = Object_Type;
19028
19029         srvsvc_NetSrvInfo1503_Type.tp_base = Object_Type;
19030
19031         srvsvc_NetSrvInfo1506_Type.tp_base = Object_Type;
19032
19033         srvsvc_NetSrvInfo1509_Type.tp_base = Object_Type;
19034
19035         srvsvc_NetSrvInfo1510_Type.tp_base = Object_Type;
19036
19037         srvsvc_NetSrvInfo1511_Type.tp_base = Object_Type;
19038
19039         srvsvc_NetSrvInfo1512_Type.tp_base = Object_Type;
19040
19041         srvsvc_NetSrvInfo1513_Type.tp_base = Object_Type;
19042
19043         srvsvc_NetSrvInfo1514_Type.tp_base = Object_Type;
19044
19045         srvsvc_NetSrvInfo1515_Type.tp_base = Object_Type;
19046
19047         srvsvc_NetSrvInfo1516_Type.tp_base = Object_Type;
19048
19049         srvsvc_NetSrvInfo1518_Type.tp_base = Object_Type;
19050
19051         srvsvc_NetSrvInfo1520_Type.tp_base = Object_Type;
19052
19053         srvsvc_NetSrvInfo1521_Type.tp_base = Object_Type;
19054
19055         srvsvc_NetSrvInfo1522_Type.tp_base = Object_Type;
19056
19057         srvsvc_NetSrvInfo1523_Type.tp_base = Object_Type;
19058
19059         srvsvc_NetSrvInfo1524_Type.tp_base = Object_Type;
19060
19061         srvsvc_NetSrvInfo1525_Type.tp_base = Object_Type;
19062
19063         srvsvc_NetSrvInfo1528_Type.tp_base = Object_Type;
19064
19065         srvsvc_NetSrvInfo1529_Type.tp_base = Object_Type;
19066
19067         srvsvc_NetSrvInfo1530_Type.tp_base = Object_Type;
19068
19069         srvsvc_NetSrvInfo1533_Type.tp_base = Object_Type;
19070
19071         srvsvc_NetSrvInfo1534_Type.tp_base = Object_Type;
19072
19073         srvsvc_NetSrvInfo1535_Type.tp_base = Object_Type;
19074
19075         srvsvc_NetSrvInfo1536_Type.tp_base = Object_Type;
19076
19077         srvsvc_NetSrvInfo1537_Type.tp_base = Object_Type;
19078
19079         srvsvc_NetSrvInfo1538_Type.tp_base = Object_Type;
19080
19081         srvsvc_NetSrvInfo1539_Type.tp_base = Object_Type;
19082
19083         srvsvc_NetSrvInfo1540_Type.tp_base = Object_Type;
19084
19085         srvsvc_NetSrvInfo1541_Type.tp_base = Object_Type;
19086
19087         srvsvc_NetSrvInfo1542_Type.tp_base = Object_Type;
19088
19089         srvsvc_NetSrvInfo1543_Type.tp_base = Object_Type;
19090
19091         srvsvc_NetSrvInfo1544_Type.tp_base = Object_Type;
19092
19093         srvsvc_NetSrvInfo1545_Type.tp_base = Object_Type;
19094
19095         srvsvc_NetSrvInfo1546_Type.tp_base = Object_Type;
19096
19097         srvsvc_NetSrvInfo1547_Type.tp_base = Object_Type;
19098
19099         srvsvc_NetSrvInfo1548_Type.tp_base = Object_Type;
19100
19101         srvsvc_NetSrvInfo1549_Type.tp_base = Object_Type;
19102
19103         srvsvc_NetSrvInfo1550_Type.tp_base = Object_Type;
19104
19105         srvsvc_NetSrvInfo1552_Type.tp_base = Object_Type;
19106
19107         srvsvc_NetSrvInfo1553_Type.tp_base = Object_Type;
19108
19109         srvsvc_NetSrvInfo1554_Type.tp_base = Object_Type;
19110
19111         srvsvc_NetSrvInfo1555_Type.tp_base = Object_Type;
19112
19113         srvsvc_NetSrvInfo1556_Type.tp_base = Object_Type;
19114
19115         srvsvc_NetDiskInfo0_Type.tp_base = Object_Type;
19116
19117         srvsvc_NetDiskInfo_Type.tp_base = Object_Type;
19118
19119         srvsvc_Statistics_Type.tp_base = Object_Type;
19120
19121         srvsvc_NetTransportInfo0_Type.tp_base = Object_Type;
19122
19123         srvsvc_NetTransportCtr0_Type.tp_base = Object_Type;
19124
19125         srvsvc_NetTransportInfo1_Type.tp_base = Object_Type;
19126
19127         srvsvc_NetTransportCtr1_Type.tp_base = Object_Type;
19128
19129         srvsvc_NetTransportInfo2_Type.tp_base = Object_Type;
19130
19131         srvsvc_NetTransportCtr2_Type.tp_base = Object_Type;
19132
19133         srvsvc_NetTransportInfo3_Type.tp_base = Object_Type;
19134
19135         srvsvc_NetTransportCtr3_Type.tp_base = Object_Type;
19136
19137         srvsvc_NetTransportInfoCtr_Type.tp_base = Object_Type;
19138
19139         srvsvc_NetRemoteTODInfo_Type.tp_base = Object_Type;
19140
19141         srvsvc_InterfaceType.tp_base = ClientConnection_Type;
19142
19143         if (PyType_Ready(&srvsvc_NetCharDevInfo0_Type) < 0)
19144                 return;
19145         if (PyType_Ready(&srvsvc_NetCharDevCtr0_Type) < 0)
19146                 return;
19147         if (PyType_Ready(&srvsvc_NetCharDevInfo1_Type) < 0)
19148                 return;
19149         if (PyType_Ready(&srvsvc_NetCharDevCtr1_Type) < 0)
19150                 return;
19151         if (PyType_Ready(&srvsvc_NetCharDevInfoCtr_Type) < 0)
19152                 return;
19153         if (PyType_Ready(&srvsvc_NetCharDevQInfo0_Type) < 0)
19154                 return;
19155         if (PyType_Ready(&srvsvc_NetCharDevQCtr0_Type) < 0)
19156                 return;
19157         if (PyType_Ready(&srvsvc_NetCharDevQInfo1_Type) < 0)
19158                 return;
19159         if (PyType_Ready(&srvsvc_NetCharDevQCtr1_Type) < 0)
19160                 return;
19161         if (PyType_Ready(&srvsvc_NetCharDevQInfoCtr_Type) < 0)
19162                 return;
19163         if (PyType_Ready(&srvsvc_NetConnInfo0_Type) < 0)
19164                 return;
19165         if (PyType_Ready(&srvsvc_NetConnCtr0_Type) < 0)
19166                 return;
19167         if (PyType_Ready(&srvsvc_NetConnInfo1_Type) < 0)
19168                 return;
19169         if (PyType_Ready(&srvsvc_NetConnCtr1_Type) < 0)
19170                 return;
19171         if (PyType_Ready(&srvsvc_NetConnInfoCtr_Type) < 0)
19172                 return;
19173         if (PyType_Ready(&srvsvc_NetFileInfo2_Type) < 0)
19174                 return;
19175         if (PyType_Ready(&srvsvc_NetFileCtr2_Type) < 0)
19176                 return;
19177         if (PyType_Ready(&srvsvc_NetFileInfo3_Type) < 0)
19178                 return;
19179         if (PyType_Ready(&srvsvc_NetFileCtr3_Type) < 0)
19180                 return;
19181         if (PyType_Ready(&srvsvc_NetFileInfoCtr_Type) < 0)
19182                 return;
19183         if (PyType_Ready(&srvsvc_NetSessInfo0_Type) < 0)
19184                 return;
19185         if (PyType_Ready(&srvsvc_NetSessCtr0_Type) < 0)
19186                 return;
19187         if (PyType_Ready(&srvsvc_NetSessInfo1_Type) < 0)
19188                 return;
19189         if (PyType_Ready(&srvsvc_NetSessCtr1_Type) < 0)
19190                 return;
19191         if (PyType_Ready(&srvsvc_NetSessInfo2_Type) < 0)
19192                 return;
19193         if (PyType_Ready(&srvsvc_NetSessCtr2_Type) < 0)
19194                 return;
19195         if (PyType_Ready(&srvsvc_NetSessInfo10_Type) < 0)
19196                 return;
19197         if (PyType_Ready(&srvsvc_NetSessCtr10_Type) < 0)
19198                 return;
19199         if (PyType_Ready(&srvsvc_NetSessInfo502_Type) < 0)
19200                 return;
19201         if (PyType_Ready(&srvsvc_NetSessCtr502_Type) < 0)
19202                 return;
19203         if (PyType_Ready(&srvsvc_NetSessInfoCtr_Type) < 0)
19204                 return;
19205         if (PyType_Ready(&srvsvc_NetShareInfo0_Type) < 0)
19206                 return;
19207         if (PyType_Ready(&srvsvc_NetShareCtr0_Type) < 0)
19208                 return;
19209         if (PyType_Ready(&srvsvc_NetShareInfo1_Type) < 0)
19210                 return;
19211         if (PyType_Ready(&srvsvc_NetShareCtr1_Type) < 0)
19212                 return;
19213         if (PyType_Ready(&srvsvc_NetShareInfo2_Type) < 0)
19214                 return;
19215         if (PyType_Ready(&srvsvc_NetShareCtr2_Type) < 0)
19216                 return;
19217         if (PyType_Ready(&srvsvc_NetShareInfo501_Type) < 0)
19218                 return;
19219         if (PyType_Ready(&srvsvc_NetShareCtr501_Type) < 0)
19220                 return;
19221         if (PyType_Ready(&srvsvc_NetShareInfo502_Type) < 0)
19222                 return;
19223         if (PyType_Ready(&srvsvc_NetShareCtr502_Type) < 0)
19224                 return;
19225         if (PyType_Ready(&srvsvc_NetShareInfo1004_Type) < 0)
19226                 return;
19227         if (PyType_Ready(&srvsvc_NetShareCtr1004_Type) < 0)
19228                 return;
19229         if (PyType_Ready(&srvsvc_NetShareInfo1005_Type) < 0)
19230                 return;
19231         if (PyType_Ready(&srvsvc_NetShareCtr1005_Type) < 0)
19232                 return;
19233         if (PyType_Ready(&srvsvc_NetShareInfo1006_Type) < 0)
19234                 return;
19235         if (PyType_Ready(&srvsvc_NetShareCtr1006_Type) < 0)
19236                 return;
19237         if (PyType_Ready(&srvsvc_NetShareInfo1007_Type) < 0)
19238                 return;
19239         if (PyType_Ready(&srvsvc_NetShareCtr1007_Type) < 0)
19240                 return;
19241         if (PyType_Ready(&srvsvc_NetShareCtr1501_Type) < 0)
19242                 return;
19243         if (PyType_Ready(&srvsvc_NetShareInfoCtr_Type) < 0)
19244                 return;
19245         if (PyType_Ready(&srvsvc_NetSrvInfo100_Type) < 0)
19246                 return;
19247         if (PyType_Ready(&srvsvc_NetSrvInfo101_Type) < 0)
19248                 return;
19249         if (PyType_Ready(&srvsvc_NetSrvInfo102_Type) < 0)
19250                 return;
19251         if (PyType_Ready(&srvsvc_NetSrvInfo402_Type) < 0)
19252                 return;
19253         if (PyType_Ready(&srvsvc_NetSrvInfo403_Type) < 0)
19254                 return;
19255         if (PyType_Ready(&srvsvc_NetSrvInfo502_Type) < 0)
19256                 return;
19257         if (PyType_Ready(&srvsvc_NetSrvInfo503_Type) < 0)
19258                 return;
19259         if (PyType_Ready(&srvsvc_NetSrvInfo599_Type) < 0)
19260                 return;
19261         if (PyType_Ready(&srvsvc_NetSrvInfo1005_Type) < 0)
19262                 return;
19263         if (PyType_Ready(&srvsvc_NetSrvInfo1010_Type) < 0)
19264                 return;
19265         if (PyType_Ready(&srvsvc_NetSrvInfo1016_Type) < 0)
19266                 return;
19267         if (PyType_Ready(&srvsvc_NetSrvInfo1017_Type) < 0)
19268                 return;
19269         if (PyType_Ready(&srvsvc_NetSrvInfo1018_Type) < 0)
19270                 return;
19271         if (PyType_Ready(&srvsvc_NetSrvInfo1107_Type) < 0)
19272                 return;
19273         if (PyType_Ready(&srvsvc_NetSrvInfo1501_Type) < 0)
19274                 return;
19275         if (PyType_Ready(&srvsvc_NetSrvInfo1502_Type) < 0)
19276                 return;
19277         if (PyType_Ready(&srvsvc_NetSrvInfo1503_Type) < 0)
19278                 return;
19279         if (PyType_Ready(&srvsvc_NetSrvInfo1506_Type) < 0)
19280                 return;
19281         if (PyType_Ready(&srvsvc_NetSrvInfo1509_Type) < 0)
19282                 return;
19283         if (PyType_Ready(&srvsvc_NetSrvInfo1510_Type) < 0)
19284                 return;
19285         if (PyType_Ready(&srvsvc_NetSrvInfo1511_Type) < 0)
19286                 return;
19287         if (PyType_Ready(&srvsvc_NetSrvInfo1512_Type) < 0)
19288                 return;
19289         if (PyType_Ready(&srvsvc_NetSrvInfo1513_Type) < 0)
19290                 return;
19291         if (PyType_Ready(&srvsvc_NetSrvInfo1514_Type) < 0)
19292                 return;
19293         if (PyType_Ready(&srvsvc_NetSrvInfo1515_Type) < 0)
19294                 return;
19295         if (PyType_Ready(&srvsvc_NetSrvInfo1516_Type) < 0)
19296                 return;
19297         if (PyType_Ready(&srvsvc_NetSrvInfo1518_Type) < 0)
19298                 return;
19299         if (PyType_Ready(&srvsvc_NetSrvInfo1520_Type) < 0)
19300                 return;
19301         if (PyType_Ready(&srvsvc_NetSrvInfo1521_Type) < 0)
19302                 return;
19303         if (PyType_Ready(&srvsvc_NetSrvInfo1522_Type) < 0)
19304                 return;
19305         if (PyType_Ready(&srvsvc_NetSrvInfo1523_Type) < 0)
19306                 return;
19307         if (PyType_Ready(&srvsvc_NetSrvInfo1524_Type) < 0)
19308                 return;
19309         if (PyType_Ready(&srvsvc_NetSrvInfo1525_Type) < 0)
19310                 return;
19311         if (PyType_Ready(&srvsvc_NetSrvInfo1528_Type) < 0)
19312                 return;
19313         if (PyType_Ready(&srvsvc_NetSrvInfo1529_Type) < 0)
19314                 return;
19315         if (PyType_Ready(&srvsvc_NetSrvInfo1530_Type) < 0)
19316                 return;
19317         if (PyType_Ready(&srvsvc_NetSrvInfo1533_Type) < 0)
19318                 return;
19319         if (PyType_Ready(&srvsvc_NetSrvInfo1534_Type) < 0)
19320                 return;
19321         if (PyType_Ready(&srvsvc_NetSrvInfo1535_Type) < 0)
19322                 return;
19323         if (PyType_Ready(&srvsvc_NetSrvInfo1536_Type) < 0)
19324                 return;
19325         if (PyType_Ready(&srvsvc_NetSrvInfo1537_Type) < 0)
19326                 return;
19327         if (PyType_Ready(&srvsvc_NetSrvInfo1538_Type) < 0)
19328                 return;
19329         if (PyType_Ready(&srvsvc_NetSrvInfo1539_Type) < 0)
19330                 return;
19331         if (PyType_Ready(&srvsvc_NetSrvInfo1540_Type) < 0)
19332                 return;
19333         if (PyType_Ready(&srvsvc_NetSrvInfo1541_Type) < 0)
19334                 return;
19335         if (PyType_Ready(&srvsvc_NetSrvInfo1542_Type) < 0)
19336                 return;
19337         if (PyType_Ready(&srvsvc_NetSrvInfo1543_Type) < 0)
19338                 return;
19339         if (PyType_Ready(&srvsvc_NetSrvInfo1544_Type) < 0)
19340                 return;
19341         if (PyType_Ready(&srvsvc_NetSrvInfo1545_Type) < 0)
19342                 return;
19343         if (PyType_Ready(&srvsvc_NetSrvInfo1546_Type) < 0)
19344                 return;
19345         if (PyType_Ready(&srvsvc_NetSrvInfo1547_Type) < 0)
19346                 return;
19347         if (PyType_Ready(&srvsvc_NetSrvInfo1548_Type) < 0)
19348                 return;
19349         if (PyType_Ready(&srvsvc_NetSrvInfo1549_Type) < 0)
19350                 return;
19351         if (PyType_Ready(&srvsvc_NetSrvInfo1550_Type) < 0)
19352                 return;
19353         if (PyType_Ready(&srvsvc_NetSrvInfo1552_Type) < 0)
19354                 return;
19355         if (PyType_Ready(&srvsvc_NetSrvInfo1553_Type) < 0)
19356                 return;
19357         if (PyType_Ready(&srvsvc_NetSrvInfo1554_Type) < 0)
19358                 return;
19359         if (PyType_Ready(&srvsvc_NetSrvInfo1555_Type) < 0)
19360                 return;
19361         if (PyType_Ready(&srvsvc_NetSrvInfo1556_Type) < 0)
19362                 return;
19363         if (PyType_Ready(&srvsvc_NetDiskInfo0_Type) < 0)
19364                 return;
19365         if (PyType_Ready(&srvsvc_NetDiskInfo_Type) < 0)
19366                 return;
19367         if (PyType_Ready(&srvsvc_Statistics_Type) < 0)
19368                 return;
19369         if (PyType_Ready(&srvsvc_NetTransportInfo0_Type) < 0)
19370                 return;
19371         if (PyType_Ready(&srvsvc_NetTransportCtr0_Type) < 0)
19372                 return;
19373         if (PyType_Ready(&srvsvc_NetTransportInfo1_Type) < 0)
19374                 return;
19375         if (PyType_Ready(&srvsvc_NetTransportCtr1_Type) < 0)
19376                 return;
19377         if (PyType_Ready(&srvsvc_NetTransportInfo2_Type) < 0)
19378                 return;
19379         if (PyType_Ready(&srvsvc_NetTransportCtr2_Type) < 0)
19380                 return;
19381         if (PyType_Ready(&srvsvc_NetTransportInfo3_Type) < 0)
19382                 return;
19383         if (PyType_Ready(&srvsvc_NetTransportCtr3_Type) < 0)
19384                 return;
19385         if (PyType_Ready(&srvsvc_NetTransportInfoCtr_Type) < 0)
19386                 return;
19387         if (PyType_Ready(&srvsvc_NetRemoteTODInfo_Type) < 0)
19388                 return;
19389         if (PyType_Ready(&srvsvc_InterfaceType) < 0)
19390                 return;
19391         if (!PyInterface_AddNdrRpcMethods(&srvsvc_InterfaceType, py_ndr_srvsvc_methods))
19392                 return;
19393
19394 #ifdef PY_NETCHARDEVINFO0_PATCH
19395         PY_NETCHARDEVINFO0_PATCH(&srvsvc_NetCharDevInfo0_Type);
19396 #endif
19397 #ifdef PY_NETCHARDEVCTR0_PATCH
19398         PY_NETCHARDEVCTR0_PATCH(&srvsvc_NetCharDevCtr0_Type);
19399 #endif
19400 #ifdef PY_NETCHARDEVINFO1_PATCH
19401         PY_NETCHARDEVINFO1_PATCH(&srvsvc_NetCharDevInfo1_Type);
19402 #endif
19403 #ifdef PY_NETCHARDEVCTR1_PATCH
19404         PY_NETCHARDEVCTR1_PATCH(&srvsvc_NetCharDevCtr1_Type);
19405 #endif
19406 #ifdef PY_NETCHARDEVINFOCTR_PATCH
19407         PY_NETCHARDEVINFOCTR_PATCH(&srvsvc_NetCharDevInfoCtr_Type);
19408 #endif
19409 #ifdef PY_NETCHARDEVQINFO0_PATCH
19410         PY_NETCHARDEVQINFO0_PATCH(&srvsvc_NetCharDevQInfo0_Type);
19411 #endif
19412 #ifdef PY_NETCHARDEVQCTR0_PATCH
19413         PY_NETCHARDEVQCTR0_PATCH(&srvsvc_NetCharDevQCtr0_Type);
19414 #endif
19415 #ifdef PY_NETCHARDEVQINFO1_PATCH
19416         PY_NETCHARDEVQINFO1_PATCH(&srvsvc_NetCharDevQInfo1_Type);
19417 #endif
19418 #ifdef PY_NETCHARDEVQCTR1_PATCH
19419         PY_NETCHARDEVQCTR1_PATCH(&srvsvc_NetCharDevQCtr1_Type);
19420 #endif
19421 #ifdef PY_NETCHARDEVQINFOCTR_PATCH
19422         PY_NETCHARDEVQINFOCTR_PATCH(&srvsvc_NetCharDevQInfoCtr_Type);
19423 #endif
19424 #ifdef PY_NETCONNINFO0_PATCH
19425         PY_NETCONNINFO0_PATCH(&srvsvc_NetConnInfo0_Type);
19426 #endif
19427 #ifdef PY_NETCONNCTR0_PATCH
19428         PY_NETCONNCTR0_PATCH(&srvsvc_NetConnCtr0_Type);
19429 #endif
19430 #ifdef PY_NETCONNINFO1_PATCH
19431         PY_NETCONNINFO1_PATCH(&srvsvc_NetConnInfo1_Type);
19432 #endif
19433 #ifdef PY_NETCONNCTR1_PATCH
19434         PY_NETCONNCTR1_PATCH(&srvsvc_NetConnCtr1_Type);
19435 #endif
19436 #ifdef PY_NETCONNINFOCTR_PATCH
19437         PY_NETCONNINFOCTR_PATCH(&srvsvc_NetConnInfoCtr_Type);
19438 #endif
19439 #ifdef PY_NETFILEINFO2_PATCH
19440         PY_NETFILEINFO2_PATCH(&srvsvc_NetFileInfo2_Type);
19441 #endif
19442 #ifdef PY_NETFILECTR2_PATCH
19443         PY_NETFILECTR2_PATCH(&srvsvc_NetFileCtr2_Type);
19444 #endif
19445 #ifdef PY_NETFILEINFO3_PATCH
19446         PY_NETFILEINFO3_PATCH(&srvsvc_NetFileInfo3_Type);
19447 #endif
19448 #ifdef PY_NETFILECTR3_PATCH
19449         PY_NETFILECTR3_PATCH(&srvsvc_NetFileCtr3_Type);
19450 #endif
19451 #ifdef PY_NETFILEINFOCTR_PATCH
19452         PY_NETFILEINFOCTR_PATCH(&srvsvc_NetFileInfoCtr_Type);
19453 #endif
19454 #ifdef PY_NETSESSINFO0_PATCH
19455         PY_NETSESSINFO0_PATCH(&srvsvc_NetSessInfo0_Type);
19456 #endif
19457 #ifdef PY_NETSESSCTR0_PATCH
19458         PY_NETSESSCTR0_PATCH(&srvsvc_NetSessCtr0_Type);
19459 #endif
19460 #ifdef PY_NETSESSINFO1_PATCH
19461         PY_NETSESSINFO1_PATCH(&srvsvc_NetSessInfo1_Type);
19462 #endif
19463 #ifdef PY_NETSESSCTR1_PATCH
19464         PY_NETSESSCTR1_PATCH(&srvsvc_NetSessCtr1_Type);
19465 #endif
19466 #ifdef PY_NETSESSINFO2_PATCH
19467         PY_NETSESSINFO2_PATCH(&srvsvc_NetSessInfo2_Type);
19468 #endif
19469 #ifdef PY_NETSESSCTR2_PATCH
19470         PY_NETSESSCTR2_PATCH(&srvsvc_NetSessCtr2_Type);
19471 #endif
19472 #ifdef PY_NETSESSINFO10_PATCH
19473         PY_NETSESSINFO10_PATCH(&srvsvc_NetSessInfo10_Type);
19474 #endif
19475 #ifdef PY_NETSESSCTR10_PATCH
19476         PY_NETSESSCTR10_PATCH(&srvsvc_NetSessCtr10_Type);
19477 #endif
19478 #ifdef PY_NETSESSINFO502_PATCH
19479         PY_NETSESSINFO502_PATCH(&srvsvc_NetSessInfo502_Type);
19480 #endif
19481 #ifdef PY_NETSESSCTR502_PATCH
19482         PY_NETSESSCTR502_PATCH(&srvsvc_NetSessCtr502_Type);
19483 #endif
19484 #ifdef PY_NETSESSINFOCTR_PATCH
19485         PY_NETSESSINFOCTR_PATCH(&srvsvc_NetSessInfoCtr_Type);
19486 #endif
19487 #ifdef PY_NETSHAREINFO0_PATCH
19488         PY_NETSHAREINFO0_PATCH(&srvsvc_NetShareInfo0_Type);
19489 #endif
19490 #ifdef PY_NETSHARECTR0_PATCH
19491         PY_NETSHARECTR0_PATCH(&srvsvc_NetShareCtr0_Type);
19492 #endif
19493 #ifdef PY_NETSHAREINFO1_PATCH
19494         PY_NETSHAREINFO1_PATCH(&srvsvc_NetShareInfo1_Type);
19495 #endif
19496 #ifdef PY_NETSHARECTR1_PATCH
19497         PY_NETSHARECTR1_PATCH(&srvsvc_NetShareCtr1_Type);
19498 #endif
19499 #ifdef PY_NETSHAREINFO2_PATCH
19500         PY_NETSHAREINFO2_PATCH(&srvsvc_NetShareInfo2_Type);
19501 #endif
19502 #ifdef PY_NETSHARECTR2_PATCH
19503         PY_NETSHARECTR2_PATCH(&srvsvc_NetShareCtr2_Type);
19504 #endif
19505 #ifdef PY_NETSHAREINFO501_PATCH
19506         PY_NETSHAREINFO501_PATCH(&srvsvc_NetShareInfo501_Type);
19507 #endif
19508 #ifdef PY_NETSHARECTR501_PATCH
19509         PY_NETSHARECTR501_PATCH(&srvsvc_NetShareCtr501_Type);
19510 #endif
19511 #ifdef PY_NETSHAREINFO502_PATCH
19512         PY_NETSHAREINFO502_PATCH(&srvsvc_NetShareInfo502_Type);
19513 #endif
19514 #ifdef PY_NETSHARECTR502_PATCH
19515         PY_NETSHARECTR502_PATCH(&srvsvc_NetShareCtr502_Type);
19516 #endif
19517 #ifdef PY_NETSHAREINFO1004_PATCH
19518         PY_NETSHAREINFO1004_PATCH(&srvsvc_NetShareInfo1004_Type);
19519 #endif
19520 #ifdef PY_NETSHARECTR1004_PATCH
19521         PY_NETSHARECTR1004_PATCH(&srvsvc_NetShareCtr1004_Type);
19522 #endif
19523 #ifdef PY_NETSHAREINFO1005_PATCH
19524         PY_NETSHAREINFO1005_PATCH(&srvsvc_NetShareInfo1005_Type);
19525 #endif
19526 #ifdef PY_NETSHARECTR1005_PATCH
19527         PY_NETSHARECTR1005_PATCH(&srvsvc_NetShareCtr1005_Type);
19528 #endif
19529 #ifdef PY_NETSHAREINFO1006_PATCH
19530         PY_NETSHAREINFO1006_PATCH(&srvsvc_NetShareInfo1006_Type);
19531 #endif
19532 #ifdef PY_NETSHARECTR1006_PATCH
19533         PY_NETSHARECTR1006_PATCH(&srvsvc_NetShareCtr1006_Type);
19534 #endif
19535 #ifdef PY_NETSHAREINFO1007_PATCH
19536         PY_NETSHAREINFO1007_PATCH(&srvsvc_NetShareInfo1007_Type);
19537 #endif
19538 #ifdef PY_NETSHARECTR1007_PATCH
19539         PY_NETSHARECTR1007_PATCH(&srvsvc_NetShareCtr1007_Type);
19540 #endif
19541 #ifdef PY_NETSHARECTR1501_PATCH
19542         PY_NETSHARECTR1501_PATCH(&srvsvc_NetShareCtr1501_Type);
19543 #endif
19544 #ifdef PY_NETSHAREINFOCTR_PATCH
19545         PY_NETSHAREINFOCTR_PATCH(&srvsvc_NetShareInfoCtr_Type);
19546 #endif
19547 #ifdef PY_NETSRVINFO100_PATCH
19548         PY_NETSRVINFO100_PATCH(&srvsvc_NetSrvInfo100_Type);
19549 #endif
19550 #ifdef PY_NETSRVINFO101_PATCH
19551         PY_NETSRVINFO101_PATCH(&srvsvc_NetSrvInfo101_Type);
19552 #endif
19553 #ifdef PY_NETSRVINFO102_PATCH
19554         PY_NETSRVINFO102_PATCH(&srvsvc_NetSrvInfo102_Type);
19555 #endif
19556 #ifdef PY_NETSRVINFO402_PATCH
19557         PY_NETSRVINFO402_PATCH(&srvsvc_NetSrvInfo402_Type);
19558 #endif
19559 #ifdef PY_NETSRVINFO403_PATCH
19560         PY_NETSRVINFO403_PATCH(&srvsvc_NetSrvInfo403_Type);
19561 #endif
19562 #ifdef PY_NETSRVINFO502_PATCH
19563         PY_NETSRVINFO502_PATCH(&srvsvc_NetSrvInfo502_Type);
19564 #endif
19565 #ifdef PY_NETSRVINFO503_PATCH
19566         PY_NETSRVINFO503_PATCH(&srvsvc_NetSrvInfo503_Type);
19567 #endif
19568 #ifdef PY_NETSRVINFO599_PATCH
19569         PY_NETSRVINFO599_PATCH(&srvsvc_NetSrvInfo599_Type);
19570 #endif
19571 #ifdef PY_NETSRVINFO1005_PATCH
19572         PY_NETSRVINFO1005_PATCH(&srvsvc_NetSrvInfo1005_Type);
19573 #endif
19574 #ifdef PY_NETSRVINFO1010_PATCH
19575         PY_NETSRVINFO1010_PATCH(&srvsvc_NetSrvInfo1010_Type);
19576 #endif
19577 #ifdef PY_NETSRVINFO1016_PATCH
19578         PY_NETSRVINFO1016_PATCH(&srvsvc_NetSrvInfo1016_Type);
19579 #endif
19580 #ifdef PY_NETSRVINFO1017_PATCH
19581         PY_NETSRVINFO1017_PATCH(&srvsvc_NetSrvInfo1017_Type);
19582 #endif
19583 #ifdef PY_NETSRVINFO1018_PATCH
19584         PY_NETSRVINFO1018_PATCH(&srvsvc_NetSrvInfo1018_Type);
19585 #endif
19586 #ifdef PY_NETSRVINFO1107_PATCH
19587         PY_NETSRVINFO1107_PATCH(&srvsvc_NetSrvInfo1107_Type);
19588 #endif
19589 #ifdef PY_NETSRVINFO1501_PATCH
19590         PY_NETSRVINFO1501_PATCH(&srvsvc_NetSrvInfo1501_Type);
19591 #endif
19592 #ifdef PY_NETSRVINFO1502_PATCH
19593         PY_NETSRVINFO1502_PATCH(&srvsvc_NetSrvInfo1502_Type);
19594 #endif
19595 #ifdef PY_NETSRVINFO1503_PATCH
19596         PY_NETSRVINFO1503_PATCH(&srvsvc_NetSrvInfo1503_Type);
19597 #endif
19598 #ifdef PY_NETSRVINFO1506_PATCH
19599         PY_NETSRVINFO1506_PATCH(&srvsvc_NetSrvInfo1506_Type);
19600 #endif
19601 #ifdef PY_NETSRVINFO1509_PATCH
19602         PY_NETSRVINFO1509_PATCH(&srvsvc_NetSrvInfo1509_Type);
19603 #endif
19604 #ifdef PY_NETSRVINFO1510_PATCH
19605         PY_NETSRVINFO1510_PATCH(&srvsvc_NetSrvInfo1510_Type);
19606 #endif
19607 #ifdef PY_NETSRVINFO1511_PATCH
19608         PY_NETSRVINFO1511_PATCH(&srvsvc_NetSrvInfo1511_Type);
19609 #endif
19610 #ifdef PY_NETSRVINFO1512_PATCH
19611         PY_NETSRVINFO1512_PATCH(&srvsvc_NetSrvInfo1512_Type);
19612 #endif
19613 #ifdef PY_NETSRVINFO1513_PATCH
19614         PY_NETSRVINFO1513_PATCH(&srvsvc_NetSrvInfo1513_Type);
19615 #endif
19616 #ifdef PY_NETSRVINFO1514_PATCH
19617         PY_NETSRVINFO1514_PATCH(&srvsvc_NetSrvInfo1514_Type);
19618 #endif
19619 #ifdef PY_NETSRVINFO1515_PATCH
19620         PY_NETSRVINFO1515_PATCH(&srvsvc_NetSrvInfo1515_Type);
19621 #endif
19622 #ifdef PY_NETSRVINFO1516_PATCH
19623         PY_NETSRVINFO1516_PATCH(&srvsvc_NetSrvInfo1516_Type);
19624 #endif
19625 #ifdef PY_NETSRVINFO1518_PATCH
19626         PY_NETSRVINFO1518_PATCH(&srvsvc_NetSrvInfo1518_Type);
19627 #endif
19628 #ifdef PY_NETSRVINFO1520_PATCH
19629         PY_NETSRVINFO1520_PATCH(&srvsvc_NetSrvInfo1520_Type);
19630 #endif
19631 #ifdef PY_NETSRVINFO1521_PATCH
19632         PY_NETSRVINFO1521_PATCH(&srvsvc_NetSrvInfo1521_Type);
19633 #endif
19634 #ifdef PY_NETSRVINFO1522_PATCH
19635         PY_NETSRVINFO1522_PATCH(&srvsvc_NetSrvInfo1522_Type);
19636 #endif
19637 #ifdef PY_NETSRVINFO1523_PATCH
19638         PY_NETSRVINFO1523_PATCH(&srvsvc_NetSrvInfo1523_Type);
19639 #endif
19640 #ifdef PY_NETSRVINFO1524_PATCH
19641         PY_NETSRVINFO1524_PATCH(&srvsvc_NetSrvInfo1524_Type);
19642 #endif
19643 #ifdef PY_NETSRVINFO1525_PATCH
19644         PY_NETSRVINFO1525_PATCH(&srvsvc_NetSrvInfo1525_Type);
19645 #endif
19646 #ifdef PY_NETSRVINFO1528_PATCH
19647         PY_NETSRVINFO1528_PATCH(&srvsvc_NetSrvInfo1528_Type);
19648 #endif
19649 #ifdef PY_NETSRVINFO1529_PATCH
19650         PY_NETSRVINFO1529_PATCH(&srvsvc_NetSrvInfo1529_Type);
19651 #endif
19652 #ifdef PY_NETSRVINFO1530_PATCH
19653         PY_NETSRVINFO1530_PATCH(&srvsvc_NetSrvInfo1530_Type);
19654 #endif
19655 #ifdef PY_NETSRVINFO1533_PATCH
19656         PY_NETSRVINFO1533_PATCH(&srvsvc_NetSrvInfo1533_Type);
19657 #endif
19658 #ifdef PY_NETSRVINFO1534_PATCH
19659         PY_NETSRVINFO1534_PATCH(&srvsvc_NetSrvInfo1534_Type);
19660 #endif
19661 #ifdef PY_NETSRVINFO1535_PATCH
19662         PY_NETSRVINFO1535_PATCH(&srvsvc_NetSrvInfo1535_Type);
19663 #endif
19664 #ifdef PY_NETSRVINFO1536_PATCH
19665         PY_NETSRVINFO1536_PATCH(&srvsvc_NetSrvInfo1536_Type);
19666 #endif
19667 #ifdef PY_NETSRVINFO1537_PATCH
19668         PY_NETSRVINFO1537_PATCH(&srvsvc_NetSrvInfo1537_Type);
19669 #endif
19670 #ifdef PY_NETSRVINFO1538_PATCH
19671         PY_NETSRVINFO1538_PATCH(&srvsvc_NetSrvInfo1538_Type);
19672 #endif
19673 #ifdef PY_NETSRVINFO1539_PATCH
19674         PY_NETSRVINFO1539_PATCH(&srvsvc_NetSrvInfo1539_Type);
19675 #endif
19676 #ifdef PY_NETSRVINFO1540_PATCH
19677         PY_NETSRVINFO1540_PATCH(&srvsvc_NetSrvInfo1540_Type);
19678 #endif
19679 #ifdef PY_NETSRVINFO1541_PATCH
19680         PY_NETSRVINFO1541_PATCH(&srvsvc_NetSrvInfo1541_Type);
19681 #endif
19682 #ifdef PY_NETSRVINFO1542_PATCH
19683         PY_NETSRVINFO1542_PATCH(&srvsvc_NetSrvInfo1542_Type);
19684 #endif
19685 #ifdef PY_NETSRVINFO1543_PATCH
19686         PY_NETSRVINFO1543_PATCH(&srvsvc_NetSrvInfo1543_Type);
19687 #endif
19688 #ifdef PY_NETSRVINFO1544_PATCH
19689         PY_NETSRVINFO1544_PATCH(&srvsvc_NetSrvInfo1544_Type);
19690 #endif
19691 #ifdef PY_NETSRVINFO1545_PATCH
19692         PY_NETSRVINFO1545_PATCH(&srvsvc_NetSrvInfo1545_Type);
19693 #endif
19694 #ifdef PY_NETSRVINFO1546_PATCH
19695         PY_NETSRVINFO1546_PATCH(&srvsvc_NetSrvInfo1546_Type);
19696 #endif
19697 #ifdef PY_NETSRVINFO1547_PATCH
19698         PY_NETSRVINFO1547_PATCH(&srvsvc_NetSrvInfo1547_Type);
19699 #endif
19700 #ifdef PY_NETSRVINFO1548_PATCH
19701         PY_NETSRVINFO1548_PATCH(&srvsvc_NetSrvInfo1548_Type);
19702 #endif
19703 #ifdef PY_NETSRVINFO1549_PATCH
19704         PY_NETSRVINFO1549_PATCH(&srvsvc_NetSrvInfo1549_Type);
19705 #endif
19706 #ifdef PY_NETSRVINFO1550_PATCH
19707         PY_NETSRVINFO1550_PATCH(&srvsvc_NetSrvInfo1550_Type);
19708 #endif
19709 #ifdef PY_NETSRVINFO1552_PATCH
19710         PY_NETSRVINFO1552_PATCH(&srvsvc_NetSrvInfo1552_Type);
19711 #endif
19712 #ifdef PY_NETSRVINFO1553_PATCH
19713         PY_NETSRVINFO1553_PATCH(&srvsvc_NetSrvInfo1553_Type);
19714 #endif
19715 #ifdef PY_NETSRVINFO1554_PATCH
19716         PY_NETSRVINFO1554_PATCH(&srvsvc_NetSrvInfo1554_Type);
19717 #endif
19718 #ifdef PY_NETSRVINFO1555_PATCH
19719         PY_NETSRVINFO1555_PATCH(&srvsvc_NetSrvInfo1555_Type);
19720 #endif
19721 #ifdef PY_NETSRVINFO1556_PATCH
19722         PY_NETSRVINFO1556_PATCH(&srvsvc_NetSrvInfo1556_Type);
19723 #endif
19724 #ifdef PY_NETDISKINFO0_PATCH
19725         PY_NETDISKINFO0_PATCH(&srvsvc_NetDiskInfo0_Type);
19726 #endif
19727 #ifdef PY_NETDISKINFO_PATCH
19728         PY_NETDISKINFO_PATCH(&srvsvc_NetDiskInfo_Type);
19729 #endif
19730 #ifdef PY_STATISTICS_PATCH
19731         PY_STATISTICS_PATCH(&srvsvc_Statistics_Type);
19732 #endif
19733 #ifdef PY_NETTRANSPORTINFO0_PATCH
19734         PY_NETTRANSPORTINFO0_PATCH(&srvsvc_NetTransportInfo0_Type);
19735 #endif
19736 #ifdef PY_NETTRANSPORTCTR0_PATCH
19737         PY_NETTRANSPORTCTR0_PATCH(&srvsvc_NetTransportCtr0_Type);
19738 #endif
19739 #ifdef PY_NETTRANSPORTINFO1_PATCH
19740         PY_NETTRANSPORTINFO1_PATCH(&srvsvc_NetTransportInfo1_Type);
19741 #endif
19742 #ifdef PY_NETTRANSPORTCTR1_PATCH
19743         PY_NETTRANSPORTCTR1_PATCH(&srvsvc_NetTransportCtr1_Type);
19744 #endif
19745 #ifdef PY_NETTRANSPORTINFO2_PATCH
19746         PY_NETTRANSPORTINFO2_PATCH(&srvsvc_NetTransportInfo2_Type);
19747 #endif
19748 #ifdef PY_NETTRANSPORTCTR2_PATCH
19749         PY_NETTRANSPORTCTR2_PATCH(&srvsvc_NetTransportCtr2_Type);
19750 #endif
19751 #ifdef PY_NETTRANSPORTINFO3_PATCH
19752         PY_NETTRANSPORTINFO3_PATCH(&srvsvc_NetTransportInfo3_Type);
19753 #endif
19754 #ifdef PY_NETTRANSPORTCTR3_PATCH
19755         PY_NETTRANSPORTCTR3_PATCH(&srvsvc_NetTransportCtr3_Type);
19756 #endif
19757 #ifdef PY_NETTRANSPORTINFOCTR_PATCH
19758         PY_NETTRANSPORTINFOCTR_PATCH(&srvsvc_NetTransportInfoCtr_Type);
19759 #endif
19760 #ifdef PY_NETREMOTETODINFO_PATCH
19761         PY_NETREMOTETODINFO_PATCH(&srvsvc_NetRemoteTODInfo_Type);
19762 #endif
19763 #ifdef PY_SRVSVC_PATCH
19764         PY_SRVSVC_PATCH(&srvsvc_InterfaceType);
19765 #endif
19766
19767         m = Py_InitModule3("srvsvc", srvsvc_methods, "srvsvc DCE/RPC");
19768         if (m == NULL)
19769                 return;
19770
19771         PyModule_AddObject(m, "SHARE_1005_FORCE_SHARED_DELETE", PyInt_FromLong(SHARE_1005_FORCE_SHARED_DELETE));
19772         PyModule_AddObject(m, "SHARE_1005_ENABLE_HASH", PyInt_FromLong(SHARE_1005_ENABLE_HASH));
19773         PyModule_AddObject(m, "SHARE_1005_FORCE_LEVELII_OPLOCK", PyInt_FromLong(SHARE_1005_FORCE_LEVELII_OPLOCK));
19774         PyModule_AddObject(m, "STYPE_HIDDEN", PyInt_FromLong(0x80000000));
19775         PyModule_AddObject(m, "STYPE_PRINTQ", PyInt_FromLong(STYPE_PRINTQ));
19776         PyModule_AddObject(m, "STYPE_TEMPORARY", PyInt_FromLong(0x40000000));
19777         PyModule_AddObject(m, "PLATFORM_ID_OSF", PyInt_FromLong(PLATFORM_ID_OSF));
19778         PyModule_AddObject(m, "SHARE_1005_ENCRYPT_DATA", PyInt_FromLong(SHARE_1005_ENCRYPT_DATA));
19779         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_AUTO_REINT", PyInt_FromLong(SHARE_1005_CSC_CACHE_AUTO_REINT));
19780         PyModule_AddObject(m, "SHARE_1005_DFS_ROOT", PyInt_FromLong(SHARE_1005_DFS_ROOT));
19781         PyModule_AddObject(m, "STYPE_PRINTQ_HIDDEN", PyInt_FromLong(STYPE_PRINTQ_HIDDEN));
19782         PyModule_AddObject(m, "STYPE_DEVICE_TEMPORARY", PyInt_FromLong(STYPE_DEVICE_TEMPORARY));
19783         PyModule_AddObject(m, "STYPE_PRINTQ_TEMPORARY", PyInt_FromLong(STYPE_PRINTQ_TEMPORARY));
19784         PyModule_AddObject(m, "STYPE_DEVICE_HIDDEN", PyInt_FromLong(STYPE_DEVICE_HIDDEN));
19785         PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_SHIFT", PyInt_FromLong(4));
19786         PyModule_AddObject(m, "PLATFORM_ID_DOS", PyInt_FromLong(PLATFORM_ID_DOS));
19787         PyModule_AddObject(m, "STYPE_DEVICE", PyInt_FromLong(STYPE_DEVICE));
19788         PyModule_AddObject(m, "SHARE_1005_IN_DFS", PyInt_FromLong(SHARE_1005_IN_DFS));
19789         PyModule_AddObject(m, "SHARE_1005_RESTRICT_EXCLUSIVE_OPENS", PyInt_FromLong(SHARE_1005_RESTRICT_EXCLUSIVE_OPENS));
19790         PyModule_AddObject(m, "PLATFORM_ID_NT", PyInt_FromLong(PLATFORM_ID_NT));
19791         PyModule_AddObject(m, "STYPE_IPC_TEMPORARY", PyInt_FromLong(STYPE_IPC_TEMPORARY));
19792         PyModule_AddObject(m, "SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM", PyInt_FromLong(SHARE_1005_ACCESS_BASED_DIRECTORY_ENUM));
19793         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_MANUAL_REINT", PyInt_FromLong(0x00000000));
19794         PyModule_AddObject(m, "STYPE_DISKTREE_HIDDEN", PyInt_FromLong(STYPE_DISKTREE_HIDDEN));
19795         PyModule_AddObject(m, "STYPE_DISKTREE", PyInt_FromLong(STYPE_DISKTREE));
19796         PyModule_AddObject(m, "SHARE_1005_ALLOW_NAMESPACE_CACHING", PyInt_FromLong(SHARE_1005_ALLOW_NAMESPACE_CACHING));
19797         PyModule_AddObject(m, "SHARE_1005_ENABLE_CA", PyInt_FromLong(SHARE_1005_ENABLE_CA));
19798         PyModule_AddObject(m, "PLATFORM_ID_VMS", PyInt_FromLong(PLATFORM_ID_VMS));
19799         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_VDO", PyInt_FromLong(SHARE_1005_CSC_CACHE_VDO));
19800         PyModule_AddObject(m, "STYPE_IPC_HIDDEN", PyInt_FromLong(STYPE_IPC_HIDDEN));
19801         PyModule_AddObject(m, "STYPE_IPC", PyInt_FromLong(STYPE_IPC));
19802         PyModule_AddObject(m, "SHARE_1005_CSC_POLICY_MASK", PyInt_FromLong(0x00000030));
19803         PyModule_AddObject(m, "STYPE_DISKTREE_TEMPORARY", PyInt_FromLong(STYPE_DISKTREE_TEMPORARY));
19804         PyModule_AddObject(m, "SHARE_1005_CSC_CACHE_NONE", PyInt_FromLong(SHARE_1005_CSC_CACHE_NONE));
19805         PyModule_AddObject(m, "PLATFORM_ID_OS2", PyInt_FromLong(PLATFORM_ID_OS2));
19806         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
19807         PyModule_AddObject(m, "NetCharDevInfo0", (PyObject *)(void *)&srvsvc_NetCharDevInfo0_Type);
19808         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
19809         PyModule_AddObject(m, "NetCharDevCtr0", (PyObject *)(void *)&srvsvc_NetCharDevCtr0_Type);
19810         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
19811         PyModule_AddObject(m, "NetCharDevInfo1", (PyObject *)(void *)&srvsvc_NetCharDevInfo1_Type);
19812         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
19813         PyModule_AddObject(m, "NetCharDevCtr1", (PyObject *)(void *)&srvsvc_NetCharDevCtr1_Type);
19814         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
19815         PyModule_AddObject(m, "NetCharDevInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevInfoCtr_Type);
19816         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
19817         PyModule_AddObject(m, "NetCharDevQInfo0", (PyObject *)(void *)&srvsvc_NetCharDevQInfo0_Type);
19818         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
19819         PyModule_AddObject(m, "NetCharDevQCtr0", (PyObject *)(void *)&srvsvc_NetCharDevQCtr0_Type);
19820         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
19821         PyModule_AddObject(m, "NetCharDevQInfo1", (PyObject *)(void *)&srvsvc_NetCharDevQInfo1_Type);
19822         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
19823         PyModule_AddObject(m, "NetCharDevQCtr1", (PyObject *)(void *)&srvsvc_NetCharDevQCtr1_Type);
19824         Py_INCREF((PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
19825         PyModule_AddObject(m, "NetCharDevQInfoCtr", (PyObject *)(void *)&srvsvc_NetCharDevQInfoCtr_Type);
19826         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
19827         PyModule_AddObject(m, "NetConnInfo0", (PyObject *)(void *)&srvsvc_NetConnInfo0_Type);
19828         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
19829         PyModule_AddObject(m, "NetConnCtr0", (PyObject *)(void *)&srvsvc_NetConnCtr0_Type);
19830         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
19831         PyModule_AddObject(m, "NetConnInfo1", (PyObject *)(void *)&srvsvc_NetConnInfo1_Type);
19832         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
19833         PyModule_AddObject(m, "NetConnCtr1", (PyObject *)(void *)&srvsvc_NetConnCtr1_Type);
19834         Py_INCREF((PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
19835         PyModule_AddObject(m, "NetConnInfoCtr", (PyObject *)(void *)&srvsvc_NetConnInfoCtr_Type);
19836         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
19837         PyModule_AddObject(m, "NetFileInfo2", (PyObject *)(void *)&srvsvc_NetFileInfo2_Type);
19838         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
19839         PyModule_AddObject(m, "NetFileCtr2", (PyObject *)(void *)&srvsvc_NetFileCtr2_Type);
19840         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
19841         PyModule_AddObject(m, "NetFileInfo3", (PyObject *)(void *)&srvsvc_NetFileInfo3_Type);
19842         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
19843         PyModule_AddObject(m, "NetFileCtr3", (PyObject *)(void *)&srvsvc_NetFileCtr3_Type);
19844         Py_INCREF((PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
19845         PyModule_AddObject(m, "NetFileInfoCtr", (PyObject *)(void *)&srvsvc_NetFileInfoCtr_Type);
19846         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
19847         PyModule_AddObject(m, "NetSessInfo0", (PyObject *)(void *)&srvsvc_NetSessInfo0_Type);
19848         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
19849         PyModule_AddObject(m, "NetSessCtr0", (PyObject *)(void *)&srvsvc_NetSessCtr0_Type);
19850         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
19851         PyModule_AddObject(m, "NetSessInfo1", (PyObject *)(void *)&srvsvc_NetSessInfo1_Type);
19852         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
19853         PyModule_AddObject(m, "NetSessCtr1", (PyObject *)(void *)&srvsvc_NetSessCtr1_Type);
19854         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
19855         PyModule_AddObject(m, "NetSessInfo2", (PyObject *)(void *)&srvsvc_NetSessInfo2_Type);
19856         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
19857         PyModule_AddObject(m, "NetSessCtr2", (PyObject *)(void *)&srvsvc_NetSessCtr2_Type);
19858         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
19859         PyModule_AddObject(m, "NetSessInfo10", (PyObject *)(void *)&srvsvc_NetSessInfo10_Type);
19860         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
19861         PyModule_AddObject(m, "NetSessCtr10", (PyObject *)(void *)&srvsvc_NetSessCtr10_Type);
19862         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
19863         PyModule_AddObject(m, "NetSessInfo502", (PyObject *)(void *)&srvsvc_NetSessInfo502_Type);
19864         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
19865         PyModule_AddObject(m, "NetSessCtr502", (PyObject *)(void *)&srvsvc_NetSessCtr502_Type);
19866         Py_INCREF((PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
19867         PyModule_AddObject(m, "NetSessInfoCtr", (PyObject *)(void *)&srvsvc_NetSessInfoCtr_Type);
19868         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
19869         PyModule_AddObject(m, "NetShareInfo0", (PyObject *)(void *)&srvsvc_NetShareInfo0_Type);
19870         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
19871         PyModule_AddObject(m, "NetShareCtr0", (PyObject *)(void *)&srvsvc_NetShareCtr0_Type);
19872         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
19873         PyModule_AddObject(m, "NetShareInfo1", (PyObject *)(void *)&srvsvc_NetShareInfo1_Type);
19874         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
19875         PyModule_AddObject(m, "NetShareCtr1", (PyObject *)(void *)&srvsvc_NetShareCtr1_Type);
19876         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
19877         PyModule_AddObject(m, "NetShareInfo2", (PyObject *)(void *)&srvsvc_NetShareInfo2_Type);
19878         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
19879         PyModule_AddObject(m, "NetShareCtr2", (PyObject *)(void *)&srvsvc_NetShareCtr2_Type);
19880         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
19881         PyModule_AddObject(m, "NetShareInfo501", (PyObject *)(void *)&srvsvc_NetShareInfo501_Type);
19882         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
19883         PyModule_AddObject(m, "NetShareCtr501", (PyObject *)(void *)&srvsvc_NetShareCtr501_Type);
19884         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
19885         PyModule_AddObject(m, "NetShareInfo502", (PyObject *)(void *)&srvsvc_NetShareInfo502_Type);
19886         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
19887         PyModule_AddObject(m, "NetShareCtr502", (PyObject *)(void *)&srvsvc_NetShareCtr502_Type);
19888         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
19889         PyModule_AddObject(m, "NetShareInfo1004", (PyObject *)(void *)&srvsvc_NetShareInfo1004_Type);
19890         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
19891         PyModule_AddObject(m, "NetShareCtr1004", (PyObject *)(void *)&srvsvc_NetShareCtr1004_Type);
19892         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
19893         PyModule_AddObject(m, "NetShareInfo1005", (PyObject *)(void *)&srvsvc_NetShareInfo1005_Type);
19894         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
19895         PyModule_AddObject(m, "NetShareCtr1005", (PyObject *)(void *)&srvsvc_NetShareCtr1005_Type);
19896         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
19897         PyModule_AddObject(m, "NetShareInfo1006", (PyObject *)(void *)&srvsvc_NetShareInfo1006_Type);
19898         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
19899         PyModule_AddObject(m, "NetShareCtr1006", (PyObject *)(void *)&srvsvc_NetShareCtr1006_Type);
19900         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
19901         PyModule_AddObject(m, "NetShareInfo1007", (PyObject *)(void *)&srvsvc_NetShareInfo1007_Type);
19902         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
19903         PyModule_AddObject(m, "NetShareCtr1007", (PyObject *)(void *)&srvsvc_NetShareCtr1007_Type);
19904         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
19905         PyModule_AddObject(m, "NetShareCtr1501", (PyObject *)(void *)&srvsvc_NetShareCtr1501_Type);
19906         Py_INCREF((PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
19907         PyModule_AddObject(m, "NetShareInfoCtr", (PyObject *)(void *)&srvsvc_NetShareInfoCtr_Type);
19908         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
19909         PyModule_AddObject(m, "NetSrvInfo100", (PyObject *)(void *)&srvsvc_NetSrvInfo100_Type);
19910         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
19911         PyModule_AddObject(m, "NetSrvInfo101", (PyObject *)(void *)&srvsvc_NetSrvInfo101_Type);
19912         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
19913         PyModule_AddObject(m, "NetSrvInfo102", (PyObject *)(void *)&srvsvc_NetSrvInfo102_Type);
19914         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
19915         PyModule_AddObject(m, "NetSrvInfo402", (PyObject *)(void *)&srvsvc_NetSrvInfo402_Type);
19916         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
19917         PyModule_AddObject(m, "NetSrvInfo403", (PyObject *)(void *)&srvsvc_NetSrvInfo403_Type);
19918         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
19919         PyModule_AddObject(m, "NetSrvInfo502", (PyObject *)(void *)&srvsvc_NetSrvInfo502_Type);
19920         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
19921         PyModule_AddObject(m, "NetSrvInfo503", (PyObject *)(void *)&srvsvc_NetSrvInfo503_Type);
19922         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
19923         PyModule_AddObject(m, "NetSrvInfo599", (PyObject *)(void *)&srvsvc_NetSrvInfo599_Type);
19924         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
19925         PyModule_AddObject(m, "NetSrvInfo1005", (PyObject *)(void *)&srvsvc_NetSrvInfo1005_Type);
19926         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
19927         PyModule_AddObject(m, "NetSrvInfo1010", (PyObject *)(void *)&srvsvc_NetSrvInfo1010_Type);
19928         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
19929         PyModule_AddObject(m, "NetSrvInfo1016", (PyObject *)(void *)&srvsvc_NetSrvInfo1016_Type);
19930         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
19931         PyModule_AddObject(m, "NetSrvInfo1017", (PyObject *)(void *)&srvsvc_NetSrvInfo1017_Type);
19932         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
19933         PyModule_AddObject(m, "NetSrvInfo1018", (PyObject *)(void *)&srvsvc_NetSrvInfo1018_Type);
19934         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
19935         PyModule_AddObject(m, "NetSrvInfo1107", (PyObject *)(void *)&srvsvc_NetSrvInfo1107_Type);
19936         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
19937         PyModule_AddObject(m, "NetSrvInfo1501", (PyObject *)(void *)&srvsvc_NetSrvInfo1501_Type);
19938         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
19939         PyModule_AddObject(m, "NetSrvInfo1502", (PyObject *)(void *)&srvsvc_NetSrvInfo1502_Type);
19940         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
19941         PyModule_AddObject(m, "NetSrvInfo1503", (PyObject *)(void *)&srvsvc_NetSrvInfo1503_Type);
19942         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
19943         PyModule_AddObject(m, "NetSrvInfo1506", (PyObject *)(void *)&srvsvc_NetSrvInfo1506_Type);
19944         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
19945         PyModule_AddObject(m, "NetSrvInfo1509", (PyObject *)(void *)&srvsvc_NetSrvInfo1509_Type);
19946         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
19947         PyModule_AddObject(m, "NetSrvInfo1510", (PyObject *)(void *)&srvsvc_NetSrvInfo1510_Type);
19948         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
19949         PyModule_AddObject(m, "NetSrvInfo1511", (PyObject *)(void *)&srvsvc_NetSrvInfo1511_Type);
19950         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
19951         PyModule_AddObject(m, "NetSrvInfo1512", (PyObject *)(void *)&srvsvc_NetSrvInfo1512_Type);
19952         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
19953         PyModule_AddObject(m, "NetSrvInfo1513", (PyObject *)(void *)&srvsvc_NetSrvInfo1513_Type);
19954         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
19955         PyModule_AddObject(m, "NetSrvInfo1514", (PyObject *)(void *)&srvsvc_NetSrvInfo1514_Type);
19956         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
19957         PyModule_AddObject(m, "NetSrvInfo1515", (PyObject *)(void *)&srvsvc_NetSrvInfo1515_Type);
19958         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
19959         PyModule_AddObject(m, "NetSrvInfo1516", (PyObject *)(void *)&srvsvc_NetSrvInfo1516_Type);
19960         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
19961         PyModule_AddObject(m, "NetSrvInfo1518", (PyObject *)(void *)&srvsvc_NetSrvInfo1518_Type);
19962         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
19963         PyModule_AddObject(m, "NetSrvInfo1520", (PyObject *)(void *)&srvsvc_NetSrvInfo1520_Type);
19964         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
19965         PyModule_AddObject(m, "NetSrvInfo1521", (PyObject *)(void *)&srvsvc_NetSrvInfo1521_Type);
19966         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
19967         PyModule_AddObject(m, "NetSrvInfo1522", (PyObject *)(void *)&srvsvc_NetSrvInfo1522_Type);
19968         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
19969         PyModule_AddObject(m, "NetSrvInfo1523", (PyObject *)(void *)&srvsvc_NetSrvInfo1523_Type);
19970         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
19971         PyModule_AddObject(m, "NetSrvInfo1524", (PyObject *)(void *)&srvsvc_NetSrvInfo1524_Type);
19972         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
19973         PyModule_AddObject(m, "NetSrvInfo1525", (PyObject *)(void *)&srvsvc_NetSrvInfo1525_Type);
19974         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
19975         PyModule_AddObject(m, "NetSrvInfo1528", (PyObject *)(void *)&srvsvc_NetSrvInfo1528_Type);
19976         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
19977         PyModule_AddObject(m, "NetSrvInfo1529", (PyObject *)(void *)&srvsvc_NetSrvInfo1529_Type);
19978         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
19979         PyModule_AddObject(m, "NetSrvInfo1530", (PyObject *)(void *)&srvsvc_NetSrvInfo1530_Type);
19980         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
19981         PyModule_AddObject(m, "NetSrvInfo1533", (PyObject *)(void *)&srvsvc_NetSrvInfo1533_Type);
19982         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
19983         PyModule_AddObject(m, "NetSrvInfo1534", (PyObject *)(void *)&srvsvc_NetSrvInfo1534_Type);
19984         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
19985         PyModule_AddObject(m, "NetSrvInfo1535", (PyObject *)(void *)&srvsvc_NetSrvInfo1535_Type);
19986         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
19987         PyModule_AddObject(m, "NetSrvInfo1536", (PyObject *)(void *)&srvsvc_NetSrvInfo1536_Type);
19988         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
19989         PyModule_AddObject(m, "NetSrvInfo1537", (PyObject *)(void *)&srvsvc_NetSrvInfo1537_Type);
19990         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
19991         PyModule_AddObject(m, "NetSrvInfo1538", (PyObject *)(void *)&srvsvc_NetSrvInfo1538_Type);
19992         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
19993         PyModule_AddObject(m, "NetSrvInfo1539", (PyObject *)(void *)&srvsvc_NetSrvInfo1539_Type);
19994         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
19995         PyModule_AddObject(m, "NetSrvInfo1540", (PyObject *)(void *)&srvsvc_NetSrvInfo1540_Type);
19996         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
19997         PyModule_AddObject(m, "NetSrvInfo1541", (PyObject *)(void *)&srvsvc_NetSrvInfo1541_Type);
19998         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
19999         PyModule_AddObject(m, "NetSrvInfo1542", (PyObject *)(void *)&srvsvc_NetSrvInfo1542_Type);
20000         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
20001         PyModule_AddObject(m, "NetSrvInfo1543", (PyObject *)(void *)&srvsvc_NetSrvInfo1543_Type);
20002         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
20003         PyModule_AddObject(m, "NetSrvInfo1544", (PyObject *)(void *)&srvsvc_NetSrvInfo1544_Type);
20004         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
20005         PyModule_AddObject(m, "NetSrvInfo1545", (PyObject *)(void *)&srvsvc_NetSrvInfo1545_Type);
20006         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
20007         PyModule_AddObject(m, "NetSrvInfo1546", (PyObject *)(void *)&srvsvc_NetSrvInfo1546_Type);
20008         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
20009         PyModule_AddObject(m, "NetSrvInfo1547", (PyObject *)(void *)&srvsvc_NetSrvInfo1547_Type);
20010         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
20011         PyModule_AddObject(m, "NetSrvInfo1548", (PyObject *)(void *)&srvsvc_NetSrvInfo1548_Type);
20012         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
20013         PyModule_AddObject(m, "NetSrvInfo1549", (PyObject *)(void *)&srvsvc_NetSrvInfo1549_Type);
20014         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
20015         PyModule_AddObject(m, "NetSrvInfo1550", (PyObject *)(void *)&srvsvc_NetSrvInfo1550_Type);
20016         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
20017         PyModule_AddObject(m, "NetSrvInfo1552", (PyObject *)(void *)&srvsvc_NetSrvInfo1552_Type);
20018         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
20019         PyModule_AddObject(m, "NetSrvInfo1553", (PyObject *)(void *)&srvsvc_NetSrvInfo1553_Type);
20020         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
20021         PyModule_AddObject(m, "NetSrvInfo1554", (PyObject *)(void *)&srvsvc_NetSrvInfo1554_Type);
20022         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
20023         PyModule_AddObject(m, "NetSrvInfo1555", (PyObject *)(void *)&srvsvc_NetSrvInfo1555_Type);
20024         Py_INCREF((PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
20025         PyModule_AddObject(m, "NetSrvInfo1556", (PyObject *)(void *)&srvsvc_NetSrvInfo1556_Type);
20026         Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
20027         PyModule_AddObject(m, "NetDiskInfo0", (PyObject *)(void *)&srvsvc_NetDiskInfo0_Type);
20028         Py_INCREF((PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
20029         PyModule_AddObject(m, "NetDiskInfo", (PyObject *)(void *)&srvsvc_NetDiskInfo_Type);
20030         Py_INCREF((PyObject *)(void *)&srvsvc_Statistics_Type);
20031         PyModule_AddObject(m, "Statistics", (PyObject *)(void *)&srvsvc_Statistics_Type);
20032         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
20033         PyModule_AddObject(m, "NetTransportInfo0", (PyObject *)(void *)&srvsvc_NetTransportInfo0_Type);
20034         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
20035         PyModule_AddObject(m, "NetTransportCtr0", (PyObject *)(void *)&srvsvc_NetTransportCtr0_Type);
20036         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
20037         PyModule_AddObject(m, "NetTransportInfo1", (PyObject *)(void *)&srvsvc_NetTransportInfo1_Type);
20038         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
20039         PyModule_AddObject(m, "NetTransportCtr1", (PyObject *)(void *)&srvsvc_NetTransportCtr1_Type);
20040         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
20041         PyModule_AddObject(m, "NetTransportInfo2", (PyObject *)(void *)&srvsvc_NetTransportInfo2_Type);
20042         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
20043         PyModule_AddObject(m, "NetTransportCtr2", (PyObject *)(void *)&srvsvc_NetTransportCtr2_Type);
20044         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
20045         PyModule_AddObject(m, "NetTransportInfo3", (PyObject *)(void *)&srvsvc_NetTransportInfo3_Type);
20046         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
20047         PyModule_AddObject(m, "NetTransportCtr3", (PyObject *)(void *)&srvsvc_NetTransportCtr3_Type);
20048         Py_INCREF((PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
20049         PyModule_AddObject(m, "NetTransportInfoCtr", (PyObject *)(void *)&srvsvc_NetTransportInfoCtr_Type);
20050         Py_INCREF((PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
20051         PyModule_AddObject(m, "NetRemoteTODInfo", (PyObject *)(void *)&srvsvc_NetRemoteTODInfo_Type);
20052         Py_INCREF((PyObject *)(void *)&srvsvc_InterfaceType);
20053         PyModule_AddObject(m, "srvsvc", (PyObject *)(void *)&srvsvc_InterfaceType);
20054 #ifdef PY_MOD_SRVSVC_PATCH
20055         PY_MOD_SRVSVC_PATCH(m);
20056 #endif
20057
20058 }