source3/librpc/gen_ndr/py_drsblobs.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #include <Python.h>
   4 #include "includes.h"
   5 #include "lib/talloc/pytalloc.h"
   6 #include "librpc/rpc/pyrpc.h"
   7 #include "librpc/gen_ndr/ndr_drsblobs.h"
   8 #include "librpc/gen_ndr/ndr_drsblobs_c.h"
   9
  10 #include "librpc/gen_ndr/drsuapi.h"
  11 #include "librpc/gen_ndr/misc.h"
  12 #include "librpc/gen_ndr/samr.h"
  13 #include "librpc/gen_ndr/lsa.h"
  14 #include "librpc/gen_ndr/security.h"
  15 staticforward PyTypeObject replPropertyMetaData1_Type;
  16 staticforward PyTypeObject replPropertyMetaDataCtr1_Type;
  17 staticforward PyTypeObject replPropertyMetaDataBlob_Type;
  18 staticforward PyTypeObject replUpToDateVectorCtr1_Type;
  19 staticforward PyTypeObject replUpToDateVectorCtr2_Type;
  20 staticforward PyTypeObject replUpToDateVectorBlob_Type;
  21 staticforward PyTypeObject repsFromTo1OtherInfo_Type;
  22 staticforward PyTypeObject repsFromTo1_Type;
  23 staticforward PyTypeObject repsFromTo2OtherInfo_Type;
  24 staticforward PyTypeObject repsFromTo2_Type;
  25 staticforward PyTypeObject repsFromToBlob_Type;
  26 staticforward PyTypeObject partialAttributeSetCtr1_Type;
  27 staticforward PyTypeObject partialAttributeSetBlob_Type;
  28 staticforward PyTypeObject schemaInfoBlob_Type;
  29 staticforward PyTypeObject drsuapi_MSPrefixMap_Entry_Type;
  30 staticforward PyTypeObject drsuapi_MSPrefixMap_Ctr_Type;
  31 staticforward PyTypeObject prefixMapBlob_Type;
  32 staticforward PyTypeObject ldapControlDirSyncBlob_Type;
  33 staticforward PyTypeObject ldapControlDirSyncCookie_Type;
  34 staticforward PyTypeObject supplementalCredentialsPackage_Type;
  35 staticforward PyTypeObject supplementalCredentialsSubBlob_Type;
  36 staticforward PyTypeObject supplementalCredentialsBlob_Type;
  37 staticforward PyTypeObject package_PackagesBlob_Type;
  38 staticforward PyTypeObject package_PrimaryCLEARTEXTBlob_Type;
  39 staticforward PyTypeObject package_PrimaryWDigestHash_Type;
  40 staticforward PyTypeObject package_PrimaryWDigestBlob_Type;
  41 staticforward PyTypeObject AuthInfoNone_Type;
  42 staticforward PyTypeObject AuthInfoNT4Owf_Type;
  43 staticforward PyTypeObject AuthInfoClear_Type;
  44 staticforward PyTypeObject AuthInfoVersion_Type;
  45 staticforward PyTypeObject AuthenticationInformation_Type;
  46 staticforward PyTypeObject AuthenticationInformationArray_Type;
  47 staticforward PyTypeObject trustAuthInOutBlob_Type;
  48 staticforward PyTypeObject trustCurrentPasswords_Type;
  49 staticforward PyTypeObject trustDomainPasswords_Type;
  50 staticforward PyTypeObject DsCompressedChunk_Type;
  51 staticforward PyTypeObject ExtendedErrorAString_Type;
  52 staticforward PyTypeObject ExtendedErrorUString_Type;
  53 staticforward PyTypeObject ExtendedErrorBlob_Type;
  54 staticforward PyTypeObject ExtendedErrorComputerName_Type;
  55 staticforward PyTypeObject ExtendedErrorParam_Type;
  56 staticforward PyTypeObject ExtendedErrorInfo_Type;
  57 staticforward PyTypeObject ExtendedErrorInfoPtr_Type;
  58 staticforward PyTypeObject ForestTrustString_Type;
  59 staticforward PyTypeObject ForestTrustDataDomainInfo_Type;
  60 staticforward PyTypeObject ForestTrustDataBinaryData_Type;
  61 staticforward PyTypeObject ForestTrustInfoRecord_Type;
  62 staticforward PyTypeObject ForestTrustInfoRecordArmor_Type;
  63 staticforward PyTypeObject ForestTrustInfo_Type;
  64 staticforward PyTypeObject drsblobs_InterfaceType;
  65
  66 static PyTypeObject *dom_sid_Type;
  67 static PyTypeObject *drsuapi_DsReplicaOIDMapping_Ctr_Type;
  68 static PyTypeObject *samr_Password_Type;
  69 static PyTypeObject *drsuapi_DsReplicaCursor_Type;
  70 static PyTypeObject *drsuapi_DsReplicaHighWaterMark_Type;
  71 static PyTypeObject *GUID_Type;
  72 static PyTypeObject *drsuapi_DsReplicaCursor2_Type;
  73
  74 static PyObject *py_replPropertyMetaData1_get_attid(PyObject *obj, void *closure)
  75 {
  76         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
  77         PyObject *py_attid;
  78         py_attid = PyInt_FromLong(object->attid);
  79         return py_attid;
  80 }
  81
  82 static int py_replPropertyMetaData1_set_attid(PyObject *py_obj, PyObject *value, void *closure)
  83 {
  84         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
  85         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  86         object->attid = PyInt_AsLong(value);
  87         return 0;
  88 }
  89
  90 static PyObject *py_replPropertyMetaData1_get_version(PyObject *obj, void *closure)
  91 {
  92         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
  93         PyObject *py_version;
  94         py_version = PyInt_FromLong(object->version);
  95         return py_version;
  96 }
  97
  98 static int py_replPropertyMetaData1_set_version(PyObject *py_obj, PyObject *value, void *closure)
  99 {
 100         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
 101         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 102         object->version = PyInt_AsLong(value);
 103         return 0;
 104 }
 105
 106 static PyObject *py_replPropertyMetaData1_get_originating_change_time(PyObject *obj, void *closure)
 107 {
 108         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
 109         PyObject *py_originating_change_time;
 110         py_originating_change_time = PyLong_FromLongLong(object->originating_change_time);
 111         return py_originating_change_time;
 112 }
 113
 114 static int py_replPropertyMetaData1_set_originating_change_time(PyObject *py_obj, PyObject *value, void *closure)
 115 {
 116         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
 117         if (PyObject_TypeCheck(value, &PyLong_Type)) {
 118                 object->originating_change_time = PyLong_AsLongLong(value);
 119         } else {
 120                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
 121                         object->originating_change_time = PyInt_AsLong(value);
 122                 } else {
 123                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 124                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 125                         return -1;
 126                 }
 127         }
 128         return 0;
 129 }
 130
 131 static PyObject *py_replPropertyMetaData1_get_originating_invocation_id(PyObject *obj, void *closure)
 132 {
 133         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
 134         PyObject *py_originating_invocation_id;
 135         py_originating_invocation_id = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->originating_invocation_id);
 136         return py_originating_invocation_id;
 137 }
 138
 139 static int py_replPropertyMetaData1_set_originating_invocation_id(PyObject *py_obj, PyObject *value, void *closure)
 140 {
 141         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
 142         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 143         memcpy(&object->originating_invocation_id, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->originating_invocation_id));
 144         return 0;
 145 }
 146
 147 static PyObject *py_replPropertyMetaData1_get_originating_usn(PyObject *obj, void *closure)
 148 {
 149         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
 150         PyObject *py_originating_usn;
 151         py_originating_usn = PyLong_FromLongLong(object->originating_usn);
 152         return py_originating_usn;
 153 }
 154
 155 static int py_replPropertyMetaData1_set_originating_usn(PyObject *py_obj, PyObject *value, void *closure)
 156 {
 157         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
 158         if (PyObject_TypeCheck(value, &PyLong_Type)) {
 159                 object->originating_usn = PyLong_AsLongLong(value);
 160         } else {
 161                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
 162                         object->originating_usn = PyInt_AsLong(value);
 163                 } else {
 164                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 165                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 166                         return -1;
 167                 }
 168         }
 169         return 0;
 170 }
 171
 172 static PyObject *py_replPropertyMetaData1_get_local_usn(PyObject *obj, void *closure)
 173 {
 174         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(obj);
 175         PyObject *py_local_usn;
 176         py_local_usn = PyLong_FromLongLong(object->local_usn);
 177         return py_local_usn;
 178 }
 179
 180 static int py_replPropertyMetaData1_set_local_usn(PyObject *py_obj, PyObject *value, void *closure)
 181 {
 182         struct replPropertyMetaData1 *object = (struct replPropertyMetaData1 *)py_talloc_get_ptr(py_obj);
 183         if (PyObject_TypeCheck(value, &PyLong_Type)) {
 184                 object->local_usn = PyLong_AsLongLong(value);
 185         } else {
 186                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
 187                         object->local_usn = PyInt_AsLong(value);
 188                 } else {
 189                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 190                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 191                         return -1;
 192                 }
 193         }
 194         return 0;
 195 }
 196
 197 static PyGetSetDef py_replPropertyMetaData1_getsetters[] = {
 198         { discard_const_p(char, "attid"), py_replPropertyMetaData1_get_attid, py_replPropertyMetaData1_set_attid },
 199         { discard_const_p(char, "version"), py_replPropertyMetaData1_get_version, py_replPropertyMetaData1_set_version },
 200         { discard_const_p(char, "originating_change_time"), py_replPropertyMetaData1_get_originating_change_time, py_replPropertyMetaData1_set_originating_change_time },
 201         { discard_const_p(char, "originating_invocation_id"), py_replPropertyMetaData1_get_originating_invocation_id, py_replPropertyMetaData1_set_originating_invocation_id },
 202         { discard_const_p(char, "originating_usn"), py_replPropertyMetaData1_get_originating_usn, py_replPropertyMetaData1_set_originating_usn },
 203         { discard_const_p(char, "local_usn"), py_replPropertyMetaData1_get_local_usn, py_replPropertyMetaData1_set_local_usn },
 204         { NULL }
 205 };
 206
 207 static PyObject *py_replPropertyMetaData1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 208 {
 209         return py_talloc_new(struct replPropertyMetaData1, type);
 210 }
 211
 212
 213 static PyTypeObject replPropertyMetaData1_Type = {
 214         PyObject_HEAD_INIT(NULL) 0,
 215         .tp_name = "drsblobs.replPropertyMetaData1",
 216         .tp_basicsize = sizeof(py_talloc_Object),
 217         .tp_dealloc = py_talloc_dealloc,
 218         .tp_getset = py_replPropertyMetaData1_getsetters,
 219         .tp_repr = py_talloc_default_repr,
 220         .tp_methods = NULL,
 221         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 222         .tp_new = py_replPropertyMetaData1_new,
 223 };
 224
 225
 226 static PyObject *py_replPropertyMetaDataCtr1_get_count(PyObject *obj, void *closure)
 227 {
 228         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(obj);
 229         PyObject *py_count;
 230         py_count = PyInt_FromLong(object->count);
 231         return py_count;
 232 }
 233
 234 static int py_replPropertyMetaDataCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
 235 {
 236         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(py_obj);
 237         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 238         object->count = PyInt_AsLong(value);
 239         return 0;
 240 }
 241
 242 static PyObject *py_replPropertyMetaDataCtr1_get_reserved(PyObject *obj, void *closure)
 243 {
 244         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(obj);
 245         PyObject *py_reserved;
 246         py_reserved = PyInt_FromLong(object->reserved);
 247         return py_reserved;
 248 }
 249
 250 static int py_replPropertyMetaDataCtr1_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
 251 {
 252         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(py_obj);
 253         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 254         object->reserved = PyInt_AsLong(value);
 255         return 0;
 256 }
 257
 258 static PyObject *py_replPropertyMetaDataCtr1_get_array(PyObject *obj, void *closure)
 259 {
 260         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(obj);
 261         PyObject *py_array;
 262         py_array = PyList_New(object->count);
 263         if (py_array == NULL) {
 264                 return NULL;
 265         }
 266         {
 267                 int array_cntr_0;
 268                 for (array_cntr_0 = 0; array_cntr_0 < object->count; array_cntr_0++) {
 269                         PyObject *py_array_0;
 270                         py_array_0 = py_talloc_reference_ex(&replPropertyMetaData1_Type, object->array, &object->array[array_cntr_0]);
 271                         PyList_SetItem(py_array, array_cntr_0, py_array_0);
 272                 }
 273         }
 274         return py_array;
 275 }
 276
 277 static int py_replPropertyMetaDataCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
 278 {
 279         struct replPropertyMetaDataCtr1 *object = (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(py_obj);
 280         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 281         {
 282                 int array_cntr_0;
 283                 object->array = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->array, PyList_Size(value));
 284                 for (array_cntr_0 = 0; array_cntr_0 < PyList_Size(value); array_cntr_0++) {
 285                         PY_CHECK_TYPE(&replPropertyMetaData1_Type, PyList_GetItem(value, array_cntr_0), return -1;);
 286                         memcpy(&object->array[array_cntr_0], (struct replPropertyMetaData1 *)py_talloc_get_ptr(PyList_GetItem(value, array_cntr_0)), sizeof(object->array[array_cntr_0]));
 287                 }
 288         }
 289         return 0;
 290 }
 291
 292 static PyGetSetDef py_replPropertyMetaDataCtr1_getsetters[] = {
 293         { discard_const_p(char, "count"), py_replPropertyMetaDataCtr1_get_count, py_replPropertyMetaDataCtr1_set_count },
 294         { discard_const_p(char, "reserved"), py_replPropertyMetaDataCtr1_get_reserved, py_replPropertyMetaDataCtr1_set_reserved },
 295         { discard_const_p(char, "array"), py_replPropertyMetaDataCtr1_get_array, py_replPropertyMetaDataCtr1_set_array },
 296         { NULL }
 297 };
 298
 299 static PyObject *py_replPropertyMetaDataCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 300 {
 301         return py_talloc_new(struct replPropertyMetaDataCtr1, type);
 302 }
 303
 304
 305 static PyTypeObject replPropertyMetaDataCtr1_Type = {
 306         PyObject_HEAD_INIT(NULL) 0,
 307         .tp_name = "drsblobs.replPropertyMetaDataCtr1",
 308         .tp_basicsize = sizeof(py_talloc_Object),
 309         .tp_dealloc = py_talloc_dealloc,
 310         .tp_getset = py_replPropertyMetaDataCtr1_getsetters,
 311         .tp_repr = py_talloc_default_repr,
 312         .tp_methods = NULL,
 313         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 314         .tp_new = py_replPropertyMetaDataCtr1_new,
 315 };
 316
 317 PyObject *py_import_replPropertyMetaDataCtr(TALLOC_CTX *mem_ctx, int level, union replPropertyMetaDataCtr *in)
 318 {
 319         PyObject *ret;
 320
 321         switch (level) {
 322                 case 1:
 323                         ret = py_talloc_reference_ex(&replPropertyMetaDataCtr1_Type, mem_ctx, &in->ctr1);
 324                         return ret;
 325
 326         }
 327         PyErr_SetString(PyExc_TypeError, "unknown union level");
 328         return NULL;
 329 }
 330
 331 union replPropertyMetaDataCtr *py_export_replPropertyMetaDataCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 332 {
 333         union replPropertyMetaDataCtr *ret = talloc_zero(mem_ctx, union replPropertyMetaDataCtr);
 334         switch (level) {
 335                 case 1:
 336                         PY_CHECK_TYPE(&replPropertyMetaDataCtr1_Type, in, talloc_free(ret); return NULL;);
 337                         memcpy(&ret->ctr1, (struct replPropertyMetaDataCtr1 *)py_talloc_get_ptr(in), sizeof(ret->ctr1));
 338                         break;
 339
 340                 default:
 341                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
 342                         talloc_free(ret);
 343                         ret = NULL;
 344         }
 345
 346         return ret;
 347 }
 348
 349
 350 static PyObject *py_replPropertyMetaDataBlob_get_version(PyObject *obj, void *closure)
 351 {
 352         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(obj);
 353         PyObject *py_version;
 354         py_version = PyInt_FromLong(object->version);
 355         return py_version;
 356 }
 357
 358 static int py_replPropertyMetaDataBlob_set_version(PyObject *py_obj, PyObject *value, void *closure)
 359 {
 360         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 361         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 362         object->version = PyInt_AsLong(value);
 363         return 0;
 364 }
 365
 366 static PyObject *py_replPropertyMetaDataBlob_get_reserved(PyObject *obj, void *closure)
 367 {
 368         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(obj);
 369         PyObject *py_reserved;
 370         py_reserved = PyInt_FromLong(object->reserved);
 371         return py_reserved;
 372 }
 373
 374 static int py_replPropertyMetaDataBlob_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
 375 {
 376         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 377         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 378         object->reserved = PyInt_AsLong(value);
 379         return 0;
 380 }
 381
 382 static PyObject *py_replPropertyMetaDataBlob_get_ctr(PyObject *obj, void *closure)
 383 {
 384         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(obj);
 385         PyObject *py_ctr;
 386         py_ctr = py_import_replPropertyMetaDataCtr(py_talloc_get_mem_ctx(obj), object->version, &object->ctr);
 387         if (py_ctr == NULL) {
 388                 return NULL;
 389         }
 390         return py_ctr;
 391 }
 392
 393 static int py_replPropertyMetaDataBlob_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
 394 {
 395         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 396         {
 397                 void *ctr_switch_0;
 398                 ctr_switch_0 = py_export_replPropertyMetaDataCtr(py_talloc_get_mem_ctx(py_obj), object->version, value);
 399                 if (ctr_switch_0 == NULL) { return -1; }
 400                 memcpy(&object->ctr, ctr_switch_0, sizeof(object->ctr));
 401         }
 402         return 0;
 403 }
 404
 405 static PyGetSetDef py_replPropertyMetaDataBlob_getsetters[] = {
 406         { discard_const_p(char, "version"), py_replPropertyMetaDataBlob_get_version, py_replPropertyMetaDataBlob_set_version },
 407         { discard_const_p(char, "reserved"), py_replPropertyMetaDataBlob_get_reserved, py_replPropertyMetaDataBlob_set_reserved },
 408         { discard_const_p(char, "ctr"), py_replPropertyMetaDataBlob_get_ctr, py_replPropertyMetaDataBlob_set_ctr },
 409         { NULL }
 410 };
 411
 412 static PyObject *py_replPropertyMetaDataBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 413 {
 414         return py_talloc_new(struct replPropertyMetaDataBlob, type);
 415 }
 416
 417 static PyObject *py_replPropertyMetaDataBlob_ndr_pack(PyObject *py_obj)
 418 {
 419         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 420         DATA_BLOB blob;
 421         enum ndr_err_code err;
 422         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
 423         if (err != NDR_ERR_SUCCESS) {
 424                 PyErr_SetNdrError(err);
 425                 return NULL;
 426         }
 427
 428         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 429 }
 430
 431 static PyObject *py_replPropertyMetaDataBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
 432 {
 433         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 434         DATA_BLOB blob;
 435         enum ndr_err_code err;
 436         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
 437                 return NULL;
 438
 439         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
 440         if (err != NDR_ERR_SUCCESS) {
 441                 PyErr_SetNdrError(err);
 442                 return NULL;
 443         }
 444
 445         Py_RETURN_NONE;
 446 }
 447
 448 static PyObject *py_replPropertyMetaDataBlob_ndr_print(PyObject *py_obj)
 449 {
 450         struct replPropertyMetaDataBlob *object = (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_obj);
 451         char *retstr;
 452         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_replPropertyMetaDataBlob, "replPropertyMetaDataBlob", object);
 453         return PyString_FromString(retstr);
 454 }
 455
 456 static PyMethodDef py_replPropertyMetaDataBlob_methods[] = {
 457         { "__ndr_pack__", (PyCFunction)py_replPropertyMetaDataBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 458         { "__ndr_unpack__", (PyCFunction)py_replPropertyMetaDataBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
 459         { "__ndr_print__", (PyCFunction)py_replPropertyMetaDataBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 460         { NULL, NULL, 0, NULL }
 461 };
 462
 463
 464 static PyTypeObject replPropertyMetaDataBlob_Type = {
 465         PyObject_HEAD_INIT(NULL) 0,
 466         .tp_name = "drsblobs.replPropertyMetaDataBlob",
 467         .tp_basicsize = sizeof(py_talloc_Object),
 468         .tp_dealloc = py_talloc_dealloc,
 469         .tp_getset = py_replPropertyMetaDataBlob_getsetters,
 470         .tp_repr = py_talloc_default_repr,
 471         .tp_methods = py_replPropertyMetaDataBlob_methods,
 472         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 473         .tp_new = py_replPropertyMetaDataBlob_new,
 474 };
 475
 476
 477 static PyObject *py_replUpToDateVectorCtr1_get_count(PyObject *obj, void *closure)
 478 {
 479         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(obj);
 480         PyObject *py_count;
 481         py_count = PyInt_FromLong(object->count);
 482         return py_count;
 483 }
 484
 485 static int py_replUpToDateVectorCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
 486 {
 487         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(py_obj);
 488         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 489         object->count = PyInt_AsLong(value);
 490         return 0;
 491 }
 492
 493 static PyObject *py_replUpToDateVectorCtr1_get_reserved(PyObject *obj, void *closure)
 494 {
 495         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(obj);
 496         PyObject *py_reserved;
 497         py_reserved = PyInt_FromLong(object->reserved);
 498         return py_reserved;
 499 }
 500
 501 static int py_replUpToDateVectorCtr1_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
 502 {
 503         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(py_obj);
 504         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 505         object->reserved = PyInt_AsLong(value);
 506         return 0;
 507 }
 508
 509 static PyObject *py_replUpToDateVectorCtr1_get_cursors(PyObject *obj, void *closure)
 510 {
 511         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(obj);
 512         PyObject *py_cursors;
 513         py_cursors = PyList_New(object->count);
 514         if (py_cursors == NULL) {
 515                 return NULL;
 516         }
 517         {
 518                 int cursors_cntr_0;
 519                 for (cursors_cntr_0 = 0; cursors_cntr_0 < object->count; cursors_cntr_0++) {
 520                         PyObject *py_cursors_0;
 521                         py_cursors_0 = py_talloc_reference_ex(drsuapi_DsReplicaCursor_Type, object->cursors, &object->cursors[cursors_cntr_0]);
 522                         PyList_SetItem(py_cursors, cursors_cntr_0, py_cursors_0);
 523                 }
 524         }
 525         return py_cursors;
 526 }
 527
 528 static int py_replUpToDateVectorCtr1_set_cursors(PyObject *py_obj, PyObject *value, void *closure)
 529 {
 530         struct replUpToDateVectorCtr1 *object = (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(py_obj);
 531         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 532         {
 533                 int cursors_cntr_0;
 534                 object->cursors = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->cursors, PyList_Size(value));
 535                 for (cursors_cntr_0 = 0; cursors_cntr_0 < PyList_Size(value); cursors_cntr_0++) {
 536                         PY_CHECK_TYPE(drsuapi_DsReplicaCursor_Type, PyList_GetItem(value, cursors_cntr_0), return -1;);
 537                         memcpy(&object->cursors[cursors_cntr_0], (struct drsuapi_DsReplicaCursor *)py_talloc_get_ptr(PyList_GetItem(value, cursors_cntr_0)), sizeof(object->cursors[cursors_cntr_0]));
 538                 }
 539         }
 540         return 0;
 541 }
 542
 543 static PyGetSetDef py_replUpToDateVectorCtr1_getsetters[] = {
 544         { discard_const_p(char, "count"), py_replUpToDateVectorCtr1_get_count, py_replUpToDateVectorCtr1_set_count },
 545         { discard_const_p(char, "reserved"), py_replUpToDateVectorCtr1_get_reserved, py_replUpToDateVectorCtr1_set_reserved },
 546         { discard_const_p(char, "cursors"), py_replUpToDateVectorCtr1_get_cursors, py_replUpToDateVectorCtr1_set_cursors },
 547         { NULL }
 548 };
 549
 550 static PyObject *py_replUpToDateVectorCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 551 {
 552         return py_talloc_new(struct replUpToDateVectorCtr1, type);
 553 }
 554
 555
 556 static PyTypeObject replUpToDateVectorCtr1_Type = {
 557         PyObject_HEAD_INIT(NULL) 0,
 558         .tp_name = "drsblobs.replUpToDateVectorCtr1",
 559         .tp_basicsize = sizeof(py_talloc_Object),
 560         .tp_dealloc = py_talloc_dealloc,
 561         .tp_getset = py_replUpToDateVectorCtr1_getsetters,
 562         .tp_repr = py_talloc_default_repr,
 563         .tp_methods = NULL,
 564         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 565         .tp_new = py_replUpToDateVectorCtr1_new,
 566 };
 567
 568
 569 static PyObject *py_replUpToDateVectorCtr2_get_count(PyObject *obj, void *closure)
 570 {
 571         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(obj);
 572         PyObject *py_count;
 573         py_count = PyInt_FromLong(object->count);
 574         return py_count;
 575 }
 576
 577 static int py_replUpToDateVectorCtr2_set_count(PyObject *py_obj, PyObject *value, void *closure)
 578 {
 579         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(py_obj);
 580         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 581         object->count = PyInt_AsLong(value);
 582         return 0;
 583 }
 584
 585 static PyObject *py_replUpToDateVectorCtr2_get_reserved(PyObject *obj, void *closure)
 586 {
 587         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(obj);
 588         PyObject *py_reserved;
 589         py_reserved = PyInt_FromLong(object->reserved);
 590         return py_reserved;
 591 }
 592
 593 static int py_replUpToDateVectorCtr2_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
 594 {
 595         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(py_obj);
 596         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 597         object->reserved = PyInt_AsLong(value);
 598         return 0;
 599 }
 600
 601 static PyObject *py_replUpToDateVectorCtr2_get_cursors(PyObject *obj, void *closure)
 602 {
 603         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(obj);
 604         PyObject *py_cursors;
 605         py_cursors = PyList_New(object->count);
 606         if (py_cursors == NULL) {
 607                 return NULL;
 608         }
 609         {
 610                 int cursors_cntr_0;
 611                 for (cursors_cntr_0 = 0; cursors_cntr_0 < object->count; cursors_cntr_0++) {
 612                         PyObject *py_cursors_0;
 613                         py_cursors_0 = py_talloc_reference_ex(drsuapi_DsReplicaCursor2_Type, object->cursors, &object->cursors[cursors_cntr_0]);
 614                         PyList_SetItem(py_cursors, cursors_cntr_0, py_cursors_0);
 615                 }
 616         }
 617         return py_cursors;
 618 }
 619
 620 static int py_replUpToDateVectorCtr2_set_cursors(PyObject *py_obj, PyObject *value, void *closure)
 621 {
 622         struct replUpToDateVectorCtr2 *object = (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(py_obj);
 623         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 624         {
 625                 int cursors_cntr_0;
 626                 object->cursors = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->cursors, PyList_Size(value));
 627                 for (cursors_cntr_0 = 0; cursors_cntr_0 < PyList_Size(value); cursors_cntr_0++) {
 628                         PY_CHECK_TYPE(drsuapi_DsReplicaCursor2_Type, PyList_GetItem(value, cursors_cntr_0), return -1;);
 629                         memcpy(&object->cursors[cursors_cntr_0], (struct drsuapi_DsReplicaCursor2 *)py_talloc_get_ptr(PyList_GetItem(value, cursors_cntr_0)), sizeof(object->cursors[cursors_cntr_0]));
 630                 }
 631         }
 632         return 0;
 633 }
 634
 635 static PyGetSetDef py_replUpToDateVectorCtr2_getsetters[] = {
 636         { discard_const_p(char, "count"), py_replUpToDateVectorCtr2_get_count, py_replUpToDateVectorCtr2_set_count },
 637         { discard_const_p(char, "reserved"), py_replUpToDateVectorCtr2_get_reserved, py_replUpToDateVectorCtr2_set_reserved },
 638         { discard_const_p(char, "cursors"), py_replUpToDateVectorCtr2_get_cursors, py_replUpToDateVectorCtr2_set_cursors },
 639         { NULL }
 640 };
 641
 642 static PyObject *py_replUpToDateVectorCtr2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 643 {
 644         return py_talloc_new(struct replUpToDateVectorCtr2, type);
 645 }
 646
 647
 648 static PyTypeObject replUpToDateVectorCtr2_Type = {
 649         PyObject_HEAD_INIT(NULL) 0,
 650         .tp_name = "drsblobs.replUpToDateVectorCtr2",
 651         .tp_basicsize = sizeof(py_talloc_Object),
 652         .tp_dealloc = py_talloc_dealloc,
 653         .tp_getset = py_replUpToDateVectorCtr2_getsetters,
 654         .tp_repr = py_talloc_default_repr,
 655         .tp_methods = NULL,
 656         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 657         .tp_new = py_replUpToDateVectorCtr2_new,
 658 };
 659
 660 PyObject *py_import_replUpToDateVectorCtr(TALLOC_CTX *mem_ctx, int level, union replUpToDateVectorCtr *in)
 661 {
 662         PyObject *ret;
 663
 664         switch (level) {
 665                 case 1:
 666                         ret = py_talloc_reference_ex(&replUpToDateVectorCtr1_Type, mem_ctx, &in->ctr1);
 667                         return ret;
 668
 669                 case 2:
 670                         ret = py_talloc_reference_ex(&replUpToDateVectorCtr2_Type, mem_ctx, &in->ctr2);
 671                         return ret;
 672
 673         }
 674         PyErr_SetString(PyExc_TypeError, "unknown union level");
 675         return NULL;
 676 }
 677
 678 union replUpToDateVectorCtr *py_export_replUpToDateVectorCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 679 {
 680         union replUpToDateVectorCtr *ret = talloc_zero(mem_ctx, union replUpToDateVectorCtr);
 681         switch (level) {
 682                 case 1:
 683                         PY_CHECK_TYPE(&replUpToDateVectorCtr1_Type, in, talloc_free(ret); return NULL;);
 684                         memcpy(&ret->ctr1, (struct replUpToDateVectorCtr1 *)py_talloc_get_ptr(in), sizeof(ret->ctr1));
 685                         break;
 686
 687                 case 2:
 688                         PY_CHECK_TYPE(&replUpToDateVectorCtr2_Type, in, talloc_free(ret); return NULL;);
 689                         memcpy(&ret->ctr2, (struct replUpToDateVectorCtr2 *)py_talloc_get_ptr(in), sizeof(ret->ctr2));
 690                         break;
 691
 692                 default:
 693                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
 694                         talloc_free(ret);
 695                         ret = NULL;
 696         }
 697
 698         return ret;
 699 }
 700
 701
 702 static PyObject *py_replUpToDateVectorBlob_get_version(PyObject *obj, void *closure)
 703 {
 704         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(obj);
 705         PyObject *py_version;
 706         py_version = PyInt_FromLong(object->version);
 707         return py_version;
 708 }
 709
 710 static int py_replUpToDateVectorBlob_set_version(PyObject *py_obj, PyObject *value, void *closure)
 711 {
 712         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 713         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 714         object->version = PyInt_AsLong(value);
 715         return 0;
 716 }
 717
 718 static PyObject *py_replUpToDateVectorBlob_get_reserved(PyObject *obj, void *closure)
 719 {
 720         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(obj);
 721         PyObject *py_reserved;
 722         py_reserved = PyInt_FromLong(object->reserved);
 723         return py_reserved;
 724 }
 725
 726 static int py_replUpToDateVectorBlob_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
 727 {
 728         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 729         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 730         object->reserved = PyInt_AsLong(value);
 731         return 0;
 732 }
 733
 734 static PyObject *py_replUpToDateVectorBlob_get_ctr(PyObject *obj, void *closure)
 735 {
 736         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(obj);
 737         PyObject *py_ctr;
 738         py_ctr = py_import_replUpToDateVectorCtr(py_talloc_get_mem_ctx(obj), object->version, &object->ctr);
 739         if (py_ctr == NULL) {
 740                 return NULL;
 741         }
 742         return py_ctr;
 743 }
 744
 745 static int py_replUpToDateVectorBlob_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
 746 {
 747         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 748         {
 749                 void *ctr_switch_0;
 750                 ctr_switch_0 = py_export_replUpToDateVectorCtr(py_talloc_get_mem_ctx(py_obj), object->version, value);
 751                 if (ctr_switch_0 == NULL) { return -1; }
 752                 memcpy(&object->ctr, ctr_switch_0, sizeof(object->ctr));
 753         }
 754         return 0;
 755 }
 756
 757 static PyGetSetDef py_replUpToDateVectorBlob_getsetters[] = {
 758         { discard_const_p(char, "version"), py_replUpToDateVectorBlob_get_version, py_replUpToDateVectorBlob_set_version },
 759         { discard_const_p(char, "reserved"), py_replUpToDateVectorBlob_get_reserved, py_replUpToDateVectorBlob_set_reserved },
 760         { discard_const_p(char, "ctr"), py_replUpToDateVectorBlob_get_ctr, py_replUpToDateVectorBlob_set_ctr },
 761         { NULL }
 762 };
 763
 764 static PyObject *py_replUpToDateVectorBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 765 {
 766         return py_talloc_new(struct replUpToDateVectorBlob, type);
 767 }
 768
 769 static PyObject *py_replUpToDateVectorBlob_ndr_pack(PyObject *py_obj)
 770 {
 771         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 772         DATA_BLOB blob;
 773         enum ndr_err_code err;
 774         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_replUpToDateVectorBlob);
 775         if (err != NDR_ERR_SUCCESS) {
 776                 PyErr_SetNdrError(err);
 777                 return NULL;
 778         }
 779
 780         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 781 }
 782
 783 static PyObject *py_replUpToDateVectorBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
 784 {
 785         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 786         DATA_BLOB blob;
 787         enum ndr_err_code err;
 788         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
 789                 return NULL;
 790
 791         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
 792         if (err != NDR_ERR_SUCCESS) {
 793                 PyErr_SetNdrError(err);
 794                 return NULL;
 795         }
 796
 797         Py_RETURN_NONE;
 798 }
 799
 800 static PyObject *py_replUpToDateVectorBlob_ndr_print(PyObject *py_obj)
 801 {
 802         struct replUpToDateVectorBlob *object = (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_obj);
 803         char *retstr;
 804         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_replUpToDateVectorBlob, "replUpToDateVectorBlob", object);
 805         return PyString_FromString(retstr);
 806 }
 807
 808 static PyMethodDef py_replUpToDateVectorBlob_methods[] = {
 809         { "__ndr_pack__", (PyCFunction)py_replUpToDateVectorBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 810         { "__ndr_unpack__", (PyCFunction)py_replUpToDateVectorBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
 811         { "__ndr_print__", (PyCFunction)py_replUpToDateVectorBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 812         { NULL, NULL, 0, NULL }
 813 };
 814
 815
 816 static PyTypeObject replUpToDateVectorBlob_Type = {
 817         PyObject_HEAD_INIT(NULL) 0,
 818         .tp_name = "drsblobs.replUpToDateVectorBlob",
 819         .tp_basicsize = sizeof(py_talloc_Object),
 820         .tp_dealloc = py_talloc_dealloc,
 821         .tp_getset = py_replUpToDateVectorBlob_getsetters,
 822         .tp_repr = py_talloc_default_repr,
 823         .tp_methods = py_replUpToDateVectorBlob_methods,
 824         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 825         .tp_new = py_replUpToDateVectorBlob_new,
 826 };
 827
 828
 829 static PyObject *py_repsFromTo1OtherInfo_get___dns_name_size(PyObject *obj, void *closure)
 830 {
 831         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(obj);
 832         PyObject *py___dns_name_size;
 833         py___dns_name_size = PyInt_FromLong(object->__dns_name_size);
 834         return py___dns_name_size;
 835 }
 836
 837 static int py_repsFromTo1OtherInfo_set___dns_name_size(PyObject *py_obj, PyObject *value, void *closure)
 838 {
 839         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(py_obj);
 840         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 841         object->__dns_name_size = PyInt_AsLong(value);
 842         return 0;
 843 }
 844
 845 static PyObject *py_repsFromTo1OtherInfo_get_dns_name(PyObject *obj, void *closure)
 846 {
 847         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(obj);
 848         PyObject *py_dns_name;
 849         py_dns_name = PyUnicode_Decode(object->dns_name, strlen(object->dns_name), "utf-8", "ignore");
 850         return py_dns_name;
 851 }
 852
 853 static int py_repsFromTo1OtherInfo_set_dns_name(PyObject *py_obj, PyObject *value, void *closure)
 854 {
 855         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(py_obj);
 856         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
 857         object->dns_name = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 858         return 0;
 859 }
 860
 861 static PyGetSetDef py_repsFromTo1OtherInfo_getsetters[] = {
 862         { discard_const_p(char, "__dns_name_size"), py_repsFromTo1OtherInfo_get___dns_name_size, py_repsFromTo1OtherInfo_set___dns_name_size },
 863         { discard_const_p(char, "dns_name"), py_repsFromTo1OtherInfo_get_dns_name, py_repsFromTo1OtherInfo_set_dns_name },
 864         { NULL }
 865 };
 866
 867 static PyObject *py_repsFromTo1OtherInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 868 {
 869         return py_talloc_new(struct repsFromTo1OtherInfo, type);
 870 }
 871
 872 static PyObject *py_repsFromTo1OtherInfo_ndr_pack(PyObject *py_obj)
 873 {
 874         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(py_obj);
 875         DATA_BLOB blob;
 876         enum ndr_err_code err;
 877         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_repsFromTo1OtherInfo);
 878         if (err != NDR_ERR_SUCCESS) {
 879                 PyErr_SetNdrError(err);
 880                 return NULL;
 881         }
 882
 883         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 884 }
 885
 886 static PyObject *py_repsFromTo1OtherInfo_ndr_unpack(PyObject *py_obj, PyObject *args)
 887 {
 888         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(py_obj);
 889         DATA_BLOB blob;
 890         enum ndr_err_code err;
 891         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
 892                 return NULL;
 893
 894         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_repsFromTo1OtherInfo);
 895         if (err != NDR_ERR_SUCCESS) {
 896                 PyErr_SetNdrError(err);
 897                 return NULL;
 898         }
 899
 900         Py_RETURN_NONE;
 901 }
 902
 903 static PyObject *py_repsFromTo1OtherInfo_ndr_print(PyObject *py_obj)
 904 {
 905         struct repsFromTo1OtherInfo *object = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(py_obj);
 906         char *retstr;
 907         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_repsFromTo1OtherInfo, "repsFromTo1OtherInfo", object);
 908         return PyString_FromString(retstr);
 909 }
 910
 911 static PyMethodDef py_repsFromTo1OtherInfo_methods[] = {
 912         { "__ndr_pack__", (PyCFunction)py_repsFromTo1OtherInfo_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 913         { "__ndr_unpack__", (PyCFunction)py_repsFromTo1OtherInfo_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
 914         { "__ndr_print__", (PyCFunction)py_repsFromTo1OtherInfo_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 915         { NULL, NULL, 0, NULL }
 916 };
 917
 918
 919 static PyTypeObject repsFromTo1OtherInfo_Type = {
 920         PyObject_HEAD_INIT(NULL) 0,
 921         .tp_name = "drsblobs.repsFromTo1OtherInfo",
 922         .tp_basicsize = sizeof(py_talloc_Object),
 923         .tp_dealloc = py_talloc_dealloc,
 924         .tp_getset = py_repsFromTo1OtherInfo_getsetters,
 925         .tp_repr = py_talloc_default_repr,
 926         .tp_methods = py_repsFromTo1OtherInfo_methods,
 927         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 928         .tp_new = py_repsFromTo1OtherInfo_new,
 929 };
 930
 931
 932 static PyObject *py_repsFromTo1_get_blobsize(PyObject *obj, void *closure)
 933 {
 934         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
 935         PyObject *py_blobsize;
 936         py_blobsize = PyInt_FromLong(object->blobsize);
 937         return py_blobsize;
 938 }
 939
 940 static int py_repsFromTo1_set_blobsize(PyObject *py_obj, PyObject *value, void *closure)
 941 {
 942         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
 943         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 944         object->blobsize = PyInt_AsLong(value);
 945         return 0;
 946 }
 947
 948 static PyObject *py_repsFromTo1_get_consecutive_sync_failures(PyObject *obj, void *closure)
 949 {
 950         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
 951         PyObject *py_consecutive_sync_failures;
 952         py_consecutive_sync_failures = PyInt_FromLong(object->consecutive_sync_failures);
 953         return py_consecutive_sync_failures;
 954 }
 955
 956 static int py_repsFromTo1_set_consecutive_sync_failures(PyObject *py_obj, PyObject *value, void *closure)
 957 {
 958         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
 959         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 960         object->consecutive_sync_failures = PyInt_AsLong(value);
 961         return 0;
 962 }
 963
 964 static PyObject *py_repsFromTo1_get_last_success(PyObject *obj, void *closure)
 965 {
 966         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
 967         PyObject *py_last_success;
 968         py_last_success = PyLong_FromLongLong(object->last_success);
 969         return py_last_success;
 970 }
 971
 972 static int py_repsFromTo1_set_last_success(PyObject *py_obj, PyObject *value, void *closure)
 973 {
 974         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
 975         if (PyObject_TypeCheck(value, &PyLong_Type)) {
 976                 object->last_success = PyLong_AsLongLong(value);
 977         } else {
 978                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
 979                         object->last_success = PyInt_AsLong(value);
 980                 } else {
 981                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 982                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 983                         return -1;
 984                 }
 985         }
 986         return 0;
 987 }
 988
 989 static PyObject *py_repsFromTo1_get_last_attempt(PyObject *obj, void *closure)
 990 {
 991         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
 992         PyObject *py_last_attempt;
 993         py_last_attempt = PyLong_FromLongLong(object->last_attempt);
 994         return py_last_attempt;
 995 }
 996
 997 static int py_repsFromTo1_set_last_attempt(PyObject *py_obj, PyObject *value, void *closure)
 998 {
 999         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1000         if (PyObject_TypeCheck(value, &PyLong_Type)) {
1001                 object->last_attempt = PyLong_AsLongLong(value);
1002         } else {
1003                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
1004                         object->last_attempt = PyInt_AsLong(value);
1005                 } else {
1006                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1007                           PyInt_Type.tp_name, PyLong_Type.tp_name);
1008                         return -1;
1009                 }
1010         }
1011         return 0;
1012 }
1013
1014 static PyObject *py_repsFromTo1_get_result_last_attempt(PyObject *obj, void *closure)
1015 {
1016         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1017         PyObject *py_result_last_attempt;
1018         py_result_last_attempt = PyErr_FromWERROR(object->result_last_attempt);
1019         return py_result_last_attempt;
1020 }
1021
1022 static int py_repsFromTo1_set_result_last_attempt(PyObject *py_obj, PyObject *value, void *closure)
1023 {
1024         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1025         object->result_last_attempt = W_ERROR(PyInt_AsLong(value));
1026         return 0;
1027 }
1028
1029 static PyObject *py_repsFromTo1_get_other_info(PyObject *obj, void *closure)
1030 {
1031         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1032         PyObject *py_other_info;
1033         if (object->other_info == NULL) {
1034                 py_other_info = Py_None;
1035                 Py_INCREF(py_other_info);
1036         } else {
1037                 py_other_info = py_talloc_reference_ex(&repsFromTo1OtherInfo_Type, object->other_info, object->other_info);
1038         }
1039         return py_other_info;
1040 }
1041
1042 static int py_repsFromTo1_set_other_info(PyObject *py_obj, PyObject *value, void *closure)
1043 {
1044         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1045         talloc_free(object->other_info);
1046         if (value == Py_None) {
1047                 object->other_info = NULL;
1048         } else {
1049                 object->other_info = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->other_info);
1050                 PY_CHECK_TYPE(&repsFromTo1OtherInfo_Type, value, return -1;);
1051                 object->other_info = (struct repsFromTo1OtherInfo *)py_talloc_get_ptr(value);
1052         }
1053         return 0;
1054 }
1055
1056 static PyObject *py_repsFromTo1_get_other_info_length(PyObject *obj, void *closure)
1057 {
1058         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1059         PyObject *py_other_info_length;
1060         py_other_info_length = PyInt_FromLong(object->other_info_length);
1061         return py_other_info_length;
1062 }
1063
1064 static int py_repsFromTo1_set_other_info_length(PyObject *py_obj, PyObject *value, void *closure)
1065 {
1066         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1067         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1068         object->other_info_length = PyInt_AsLong(value);
1069         return 0;
1070 }
1071
1072 static PyObject *py_repsFromTo1_get_replica_flags(PyObject *obj, void *closure)
1073 {
1074         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1075         PyObject *py_replica_flags;
1076         py_replica_flags = PyInt_FromLong(object->replica_flags);
1077         return py_replica_flags;
1078 }
1079
1080 static int py_repsFromTo1_set_replica_flags(PyObject *py_obj, PyObject *value, void *closure)
1081 {
1082         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1083         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1084         object->replica_flags = PyInt_AsLong(value);
1085         return 0;
1086 }
1087
1088 static PyObject *py_repsFromTo1_get_schedule(PyObject *obj, void *closure)
1089 {
1090         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1091         PyObject *py_schedule;
1092         py_schedule = PyList_New(84);
1093         if (py_schedule == NULL) {
1094                 return NULL;
1095         }
1096         {
1097                 int schedule_cntr_0;
1098                 for (schedule_cntr_0 = 0; schedule_cntr_0 < 84; schedule_cntr_0++) {
1099                         PyObject *py_schedule_0;
1100                         py_schedule_0 = PyInt_FromLong(object->schedule[schedule_cntr_0]);
1101                         PyList_SetItem(py_schedule, schedule_cntr_0, py_schedule_0);
1102                 }
1103         }
1104         return py_schedule;
1105 }
1106
1107 static int py_repsFromTo1_set_schedule(PyObject *py_obj, PyObject *value, void *closure)
1108 {
1109         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1110         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1111         {
1112                 int schedule_cntr_0;
1113                 for (schedule_cntr_0 = 0; schedule_cntr_0 < PyList_Size(value); schedule_cntr_0++) {
1114                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, schedule_cntr_0), return -1;);
1115                         object->schedule[schedule_cntr_0] = PyInt_AsLong(PyList_GetItem(value, schedule_cntr_0));
1116                 }
1117         }
1118         return 0;
1119 }
1120
1121 static PyObject *py_repsFromTo1_get_reserved(PyObject *obj, void *closure)
1122 {
1123         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1124         PyObject *py_reserved;
1125         py_reserved = PyInt_FromLong(object->reserved);
1126         return py_reserved;
1127 }
1128
1129 static int py_repsFromTo1_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
1130 {
1131         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1132         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1133         object->reserved = PyInt_AsLong(value);
1134         return 0;
1135 }
1136
1137 static PyObject *py_repsFromTo1_get_highwatermark(PyObject *obj, void *closure)
1138 {
1139         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1140         PyObject *py_highwatermark;
1141         py_highwatermark = py_talloc_reference_ex(drsuapi_DsReplicaHighWaterMark_Type, py_talloc_get_mem_ctx(obj), &object->highwatermark);
1142         return py_highwatermark;
1143 }
1144
1145 static int py_repsFromTo1_set_highwatermark(PyObject *py_obj, PyObject *value, void *closure)
1146 {
1147         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1148         PY_CHECK_TYPE(drsuapi_DsReplicaHighWaterMark_Type, value, return -1;);
1149         memcpy(&object->highwatermark, (struct drsuapi_DsReplicaHighWaterMark *)py_talloc_get_ptr(value), sizeof(object->highwatermark));
1150         return 0;
1151 }
1152
1153 static PyObject *py_repsFromTo1_get_source_dsa_obj_guid(PyObject *obj, void *closure)
1154 {
1155         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1156         PyObject *py_source_dsa_obj_guid;
1157         py_source_dsa_obj_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->source_dsa_obj_guid);
1158         return py_source_dsa_obj_guid;
1159 }
1160
1161 static int py_repsFromTo1_set_source_dsa_obj_guid(PyObject *py_obj, PyObject *value, void *closure)
1162 {
1163         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1164         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1165         memcpy(&object->source_dsa_obj_guid, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->source_dsa_obj_guid));
1166         return 0;
1167 }
1168
1169 static PyObject *py_repsFromTo1_get_source_dsa_invocation_id(PyObject *obj, void *closure)
1170 {
1171         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1172         PyObject *py_source_dsa_invocation_id;
1173         py_source_dsa_invocation_id = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->source_dsa_invocation_id);
1174         return py_source_dsa_invocation_id;
1175 }
1176
1177 static int py_repsFromTo1_set_source_dsa_invocation_id(PyObject *py_obj, PyObject *value, void *closure)
1178 {
1179         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1180         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1181         memcpy(&object->source_dsa_invocation_id, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->source_dsa_invocation_id));
1182         return 0;
1183 }
1184
1185 static PyObject *py_repsFromTo1_get_transport_guid(PyObject *obj, void *closure)
1186 {
1187         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(obj);
1188         PyObject *py_transport_guid;
1189         py_transport_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->transport_guid);
1190         return py_transport_guid;
1191 }
1192
1193 static int py_repsFromTo1_set_transport_guid(PyObject *py_obj, PyObject *value, void *closure)
1194 {
1195         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1196         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1197         memcpy(&object->transport_guid, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->transport_guid));
1198         return 0;
1199 }
1200
1201 static PyGetSetDef py_repsFromTo1_getsetters[] = {
1202         { discard_const_p(char, "blobsize"), py_repsFromTo1_get_blobsize, py_repsFromTo1_set_blobsize },
1203         { discard_const_p(char, "consecutive_sync_failures"), py_repsFromTo1_get_consecutive_sync_failures, py_repsFromTo1_set_consecutive_sync_failures },
1204         { discard_const_p(char, "last_success"), py_repsFromTo1_get_last_success, py_repsFromTo1_set_last_success },
1205         { discard_const_p(char, "last_attempt"), py_repsFromTo1_get_last_attempt, py_repsFromTo1_set_last_attempt },
1206         { discard_const_p(char, "result_last_attempt"), py_repsFromTo1_get_result_last_attempt, py_repsFromTo1_set_result_last_attempt },
1207         { discard_const_p(char, "other_info"), py_repsFromTo1_get_other_info, py_repsFromTo1_set_other_info },
1208         { discard_const_p(char, "other_info_length"), py_repsFromTo1_get_other_info_length, py_repsFromTo1_set_other_info_length },
1209         { discard_const_p(char, "replica_flags"), py_repsFromTo1_get_replica_flags, py_repsFromTo1_set_replica_flags },
1210         { discard_const_p(char, "schedule"), py_repsFromTo1_get_schedule, py_repsFromTo1_set_schedule },
1211         { discard_const_p(char, "reserved"), py_repsFromTo1_get_reserved, py_repsFromTo1_set_reserved },
1212         { discard_const_p(char, "highwatermark"), py_repsFromTo1_get_highwatermark, py_repsFromTo1_set_highwatermark },
1213         { discard_const_p(char, "source_dsa_obj_guid"), py_repsFromTo1_get_source_dsa_obj_guid, py_repsFromTo1_set_source_dsa_obj_guid },
1214         { discard_const_p(char, "source_dsa_invocation_id"), py_repsFromTo1_get_source_dsa_invocation_id, py_repsFromTo1_set_source_dsa_invocation_id },
1215         { discard_const_p(char, "transport_guid"), py_repsFromTo1_get_transport_guid, py_repsFromTo1_set_transport_guid },
1216         { NULL }
1217 };
1218
1219 static PyObject *py_repsFromTo1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1220 {
1221         return py_talloc_new(struct repsFromTo1, type);
1222 }
1223
1224 static PyObject *py_repsFromTo1_ndr_pack(PyObject *py_obj)
1225 {
1226         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1227         DATA_BLOB blob;
1228         enum ndr_err_code err;
1229         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_repsFromTo1);
1230         if (err != NDR_ERR_SUCCESS) {
1231                 PyErr_SetNdrError(err);
1232                 return NULL;
1233         }
1234
1235         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1236 }
1237
1238 static PyObject *py_repsFromTo1_ndr_unpack(PyObject *py_obj, PyObject *args)
1239 {
1240         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1241         DATA_BLOB blob;
1242         enum ndr_err_code err;
1243         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
1244                 return NULL;
1245
1246         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_repsFromTo1);
1247         if (err != NDR_ERR_SUCCESS) {
1248                 PyErr_SetNdrError(err);
1249                 return NULL;
1250         }
1251
1252         Py_RETURN_NONE;
1253 }
1254
1255 static PyObject *py_repsFromTo1_ndr_print(PyObject *py_obj)
1256 {
1257         struct repsFromTo1 *object = (struct repsFromTo1 *)py_talloc_get_ptr(py_obj);
1258         char *retstr;
1259         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_repsFromTo1, "repsFromTo1", object);
1260         return PyString_FromString(retstr);
1261 }
1262
1263 static PyMethodDef py_repsFromTo1_methods[] = {
1264         { "__ndr_pack__", (PyCFunction)py_repsFromTo1_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1265         { "__ndr_unpack__", (PyCFunction)py_repsFromTo1_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
1266         { "__ndr_print__", (PyCFunction)py_repsFromTo1_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1267         { NULL, NULL, 0, NULL }
1268 };
1269
1270
1271 static PyTypeObject repsFromTo1_Type = {
1272         PyObject_HEAD_INIT(NULL) 0,
1273         .tp_name = "drsblobs.repsFromTo1",
1274         .tp_basicsize = sizeof(py_talloc_Object),
1275         .tp_dealloc = py_talloc_dealloc,
1276         .tp_getset = py_repsFromTo1_getsetters,
1277         .tp_repr = py_talloc_default_repr,
1278         .tp_methods = py_repsFromTo1_methods,
1279         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1280         .tp_new = py_repsFromTo1_new,
1281 };
1282
1283
1284 static PyObject *py_repsFromTo2OtherInfo_get___ndr_size(PyObject *obj, void *closure)
1285 {
1286         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(obj);
1287         PyObject *py___ndr_size;
1288         py___ndr_size = PyInt_FromLong(object->__ndr_size);
1289         return py___ndr_size;
1290 }
1291
1292 static int py_repsFromTo2OtherInfo_set___ndr_size(PyObject *py_obj, PyObject *value, void *closure)
1293 {
1294         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1295         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1296         object->__ndr_size = PyInt_AsLong(value);
1297         return 0;
1298 }
1299
1300 static PyObject *py_repsFromTo2OtherInfo_get_dns_name1(PyObject *obj, void *closure)
1301 {
1302         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(obj);
1303         PyObject *py_dns_name1;
1304         py_dns_name1 = PyString_FromString(object->dns_name1);
1305         return py_dns_name1;
1306 }
1307
1308 static int py_repsFromTo2OtherInfo_set_dns_name1(PyObject *py_obj, PyObject *value, void *closure)
1309 {
1310         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1311         object->dns_name1 = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AsString(value));
1312         return 0;
1313 }
1314
1315 static PyObject *py_repsFromTo2OtherInfo_get_unknown1(PyObject *obj, void *closure)
1316 {
1317         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(obj);
1318         PyObject *py_unknown1;
1319         py_unknown1 = PyInt_FromLong(object->unknown1);
1320         return py_unknown1;
1321 }
1322
1323 static int py_repsFromTo2OtherInfo_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
1324 {
1325         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1326         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1327         object->unknown1 = PyInt_AsLong(value);
1328         return 0;
1329 }
1330
1331 static PyObject *py_repsFromTo2OtherInfo_get_dns_name2(PyObject *obj, void *closure)
1332 {
1333         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(obj);
1334         PyObject *py_dns_name2;
1335         py_dns_name2 = PyString_FromString(object->dns_name2);
1336         return py_dns_name2;
1337 }
1338
1339 static int py_repsFromTo2OtherInfo_set_dns_name2(PyObject *py_obj, PyObject *value, void *closure)
1340 {
1341         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1342         object->dns_name2 = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AsString(value));
1343         return 0;
1344 }
1345
1346 static PyObject *py_repsFromTo2OtherInfo_get_unknown2(PyObject *obj, void *closure)
1347 {
1348         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(obj);
1349         PyObject *py_unknown2;
1350         py_unknown2 = PyLong_FromLongLong(object->unknown2);
1351         return py_unknown2;
1352 }
1353
1354 static int py_repsFromTo2OtherInfo_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
1355 {
1356         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1357         if (PyObject_TypeCheck(value, &PyLong_Type)) {
1358                 object->unknown2 = PyLong_AsLongLong(value);
1359         } else {
1360                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
1361                         object->unknown2 = PyInt_AsLong(value);
1362                 } else {
1363                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1364                           PyInt_Type.tp_name, PyLong_Type.tp_name);
1365                         return -1;
1366                 }
1367         }
1368         return 0;
1369 }
1370
1371 static PyGetSetDef py_repsFromTo2OtherInfo_getsetters[] = {
1372         { discard_const_p(char, "__ndr_size"), py_repsFromTo2OtherInfo_get___ndr_size, py_repsFromTo2OtherInfo_set___ndr_size },
1373         { discard_const_p(char, "dns_name1"), py_repsFromTo2OtherInfo_get_dns_name1, py_repsFromTo2OtherInfo_set_dns_name1 },
1374         { discard_const_p(char, "unknown1"), py_repsFromTo2OtherInfo_get_unknown1, py_repsFromTo2OtherInfo_set_unknown1 },
1375         { discard_const_p(char, "dns_name2"), py_repsFromTo2OtherInfo_get_dns_name2, py_repsFromTo2OtherInfo_set_dns_name2 },
1376         { discard_const_p(char, "unknown2"), py_repsFromTo2OtherInfo_get_unknown2, py_repsFromTo2OtherInfo_set_unknown2 },
1377         { NULL }
1378 };
1379
1380 static PyObject *py_repsFromTo2OtherInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1381 {
1382         return py_talloc_new(struct repsFromTo2OtherInfo, type);
1383 }
1384
1385 static PyObject *py_repsFromTo2OtherInfo_ndr_pack(PyObject *py_obj)
1386 {
1387         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1388         DATA_BLOB blob;
1389         enum ndr_err_code err;
1390         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_repsFromTo2OtherInfo);
1391         if (err != NDR_ERR_SUCCESS) {
1392                 PyErr_SetNdrError(err);
1393                 return NULL;
1394         }
1395
1396         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1397 }
1398
1399 static PyObject *py_repsFromTo2OtherInfo_ndr_unpack(PyObject *py_obj, PyObject *args)
1400 {
1401         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1402         DATA_BLOB blob;
1403         enum ndr_err_code err;
1404         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
1405                 return NULL;
1406
1407         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_repsFromTo2OtherInfo);
1408         if (err != NDR_ERR_SUCCESS) {
1409                 PyErr_SetNdrError(err);
1410                 return NULL;
1411         }
1412
1413         Py_RETURN_NONE;
1414 }
1415
1416 static PyObject *py_repsFromTo2OtherInfo_ndr_print(PyObject *py_obj)
1417 {
1418         struct repsFromTo2OtherInfo *object = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(py_obj);
1419         char *retstr;
1420         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_repsFromTo2OtherInfo, "repsFromTo2OtherInfo", object);
1421         return PyString_FromString(retstr);
1422 }
1423
1424 static PyMethodDef py_repsFromTo2OtherInfo_methods[] = {
1425         { "__ndr_pack__", (PyCFunction)py_repsFromTo2OtherInfo_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1426         { "__ndr_unpack__", (PyCFunction)py_repsFromTo2OtherInfo_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
1427         { "__ndr_print__", (PyCFunction)py_repsFromTo2OtherInfo_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1428         { NULL, NULL, 0, NULL }
1429 };
1430
1431
1432 static PyTypeObject repsFromTo2OtherInfo_Type = {
1433         PyObject_HEAD_INIT(NULL) 0,
1434         .tp_name = "drsblobs.repsFromTo2OtherInfo",
1435         .tp_basicsize = sizeof(py_talloc_Object),
1436         .tp_dealloc = py_talloc_dealloc,
1437         .tp_getset = py_repsFromTo2OtherInfo_getsetters,
1438         .tp_repr = py_talloc_default_repr,
1439         .tp_methods = py_repsFromTo2OtherInfo_methods,
1440         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1441         .tp_new = py_repsFromTo2OtherInfo_new,
1442 };
1443
1444
1445 static PyObject *py_repsFromTo2_get_blobsize(PyObject *obj, void *closure)
1446 {
1447         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1448         PyObject *py_blobsize;
1449         py_blobsize = PyInt_FromLong(object->blobsize);
1450         return py_blobsize;
1451 }
1452
1453 static int py_repsFromTo2_set_blobsize(PyObject *py_obj, PyObject *value, void *closure)
1454 {
1455         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1456         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1457         object->blobsize = PyInt_AsLong(value);
1458         return 0;
1459 }
1460
1461 static PyObject *py_repsFromTo2_get_consecutive_sync_failures(PyObject *obj, void *closure)
1462 {
1463         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1464         PyObject *py_consecutive_sync_failures;
1465         py_consecutive_sync_failures = PyInt_FromLong(object->consecutive_sync_failures);
1466         return py_consecutive_sync_failures;
1467 }
1468
1469 static int py_repsFromTo2_set_consecutive_sync_failures(PyObject *py_obj, PyObject *value, void *closure)
1470 {
1471         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1472         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1473         object->consecutive_sync_failures = PyInt_AsLong(value);
1474         return 0;
1475 }
1476
1477 static PyObject *py_repsFromTo2_get_last_success(PyObject *obj, void *closure)
1478 {
1479         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1480         PyObject *py_last_success;
1481         py_last_success = PyLong_FromLongLong(object->last_success);
1482         return py_last_success;
1483 }
1484
1485 static int py_repsFromTo2_set_last_success(PyObject *py_obj, PyObject *value, void *closure)
1486 {
1487         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1488         if (PyObject_TypeCheck(value, &PyLong_Type)) {
1489                 object->last_success = PyLong_AsLongLong(value);
1490         } else {
1491                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
1492                         object->last_success = PyInt_AsLong(value);
1493                 } else {
1494                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1495                           PyInt_Type.tp_name, PyLong_Type.tp_name);
1496                         return -1;
1497                 }
1498         }
1499         return 0;
1500 }
1501
1502 static PyObject *py_repsFromTo2_get_last_attempt(PyObject *obj, void *closure)
1503 {
1504         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1505         PyObject *py_last_attempt;
1506         py_last_attempt = PyLong_FromLongLong(object->last_attempt);
1507         return py_last_attempt;
1508 }
1509
1510 static int py_repsFromTo2_set_last_attempt(PyObject *py_obj, PyObject *value, void *closure)
1511 {
1512         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1513         if (PyObject_TypeCheck(value, &PyLong_Type)) {
1514                 object->last_attempt = PyLong_AsLongLong(value);
1515         } else {
1516                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
1517                         object->last_attempt = PyInt_AsLong(value);
1518                 } else {
1519                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1520                           PyInt_Type.tp_name, PyLong_Type.tp_name);
1521                         return -1;
1522                 }
1523         }
1524         return 0;
1525 }
1526
1527 static PyObject *py_repsFromTo2_get_result_last_attempt(PyObject *obj, void *closure)
1528 {
1529         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1530         PyObject *py_result_last_attempt;
1531         py_result_last_attempt = PyErr_FromWERROR(object->result_last_attempt);
1532         return py_result_last_attempt;
1533 }
1534
1535 static int py_repsFromTo2_set_result_last_attempt(PyObject *py_obj, PyObject *value, void *closure)
1536 {
1537         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1538         object->result_last_attempt = W_ERROR(PyInt_AsLong(value));
1539         return 0;
1540 }
1541
1542 static PyObject *py_repsFromTo2_get_other_info(PyObject *obj, void *closure)
1543 {
1544         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1545         PyObject *py_other_info;
1546         if (object->other_info == NULL) {
1547                 py_other_info = Py_None;
1548                 Py_INCREF(py_other_info);
1549         } else {
1550                 py_other_info = py_talloc_reference_ex(&repsFromTo2OtherInfo_Type, object->other_info, object->other_info);
1551         }
1552         return py_other_info;
1553 }
1554
1555 static int py_repsFromTo2_set_other_info(PyObject *py_obj, PyObject *value, void *closure)
1556 {
1557         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1558         talloc_free(object->other_info);
1559         if (value == Py_None) {
1560                 object->other_info = NULL;
1561         } else {
1562                 object->other_info = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->other_info);
1563                 PY_CHECK_TYPE(&repsFromTo2OtherInfo_Type, value, return -1;);
1564                 object->other_info = (struct repsFromTo2OtherInfo *)py_talloc_get_ptr(value);
1565         }
1566         return 0;
1567 }
1568
1569 static PyObject *py_repsFromTo2_get_other_info_length(PyObject *obj, void *closure)
1570 {
1571         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1572         PyObject *py_other_info_length;
1573         py_other_info_length = PyInt_FromLong(object->other_info_length);
1574         return py_other_info_length;
1575 }
1576
1577 static int py_repsFromTo2_set_other_info_length(PyObject *py_obj, PyObject *value, void *closure)
1578 {
1579         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1580         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1581         object->other_info_length = PyInt_AsLong(value);
1582         return 0;
1583 }
1584
1585 static PyObject *py_repsFromTo2_get_replica_flags(PyObject *obj, void *closure)
1586 {
1587         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1588         PyObject *py_replica_flags;
1589         py_replica_flags = PyInt_FromLong(object->replica_flags);
1590         return py_replica_flags;
1591 }
1592
1593 static int py_repsFromTo2_set_replica_flags(PyObject *py_obj, PyObject *value, void *closure)
1594 {
1595         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1596         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1597         object->replica_flags = PyInt_AsLong(value);
1598         return 0;
1599 }
1600
1601 static PyObject *py_repsFromTo2_get_schedule(PyObject *obj, void *closure)
1602 {
1603         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1604         PyObject *py_schedule;
1605         py_schedule = PyList_New(84);
1606         if (py_schedule == NULL) {
1607                 return NULL;
1608         }
1609         {
1610                 int schedule_cntr_0;
1611                 for (schedule_cntr_0 = 0; schedule_cntr_0 < 84; schedule_cntr_0++) {
1612                         PyObject *py_schedule_0;
1613                         py_schedule_0 = PyInt_FromLong(object->schedule[schedule_cntr_0]);
1614                         PyList_SetItem(py_schedule, schedule_cntr_0, py_schedule_0);
1615                 }
1616         }
1617         return py_schedule;
1618 }
1619
1620 static int py_repsFromTo2_set_schedule(PyObject *py_obj, PyObject *value, void *closure)
1621 {
1622         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1623         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1624         {
1625                 int schedule_cntr_0;
1626                 for (schedule_cntr_0 = 0; schedule_cntr_0 < PyList_Size(value); schedule_cntr_0++) {
1627                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, schedule_cntr_0), return -1;);
1628                         object->schedule[schedule_cntr_0] = PyInt_AsLong(PyList_GetItem(value, schedule_cntr_0));
1629                 }
1630         }
1631         return 0;
1632 }
1633
1634 static PyObject *py_repsFromTo2_get_reserved(PyObject *obj, void *closure)
1635 {
1636         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1637         PyObject *py_reserved;
1638         py_reserved = PyInt_FromLong(object->reserved);
1639         return py_reserved;
1640 }
1641
1642 static int py_repsFromTo2_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
1643 {
1644         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1645         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1646         object->reserved = PyInt_AsLong(value);
1647         return 0;
1648 }
1649
1650 static PyObject *py_repsFromTo2_get_highwatermark(PyObject *obj, void *closure)
1651 {
1652         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1653         PyObject *py_highwatermark;
1654         py_highwatermark = py_talloc_reference_ex(drsuapi_DsReplicaHighWaterMark_Type, py_talloc_get_mem_ctx(obj), &object->highwatermark);
1655         return py_highwatermark;
1656 }
1657
1658 static int py_repsFromTo2_set_highwatermark(PyObject *py_obj, PyObject *value, void *closure)
1659 {
1660         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1661         PY_CHECK_TYPE(drsuapi_DsReplicaHighWaterMark_Type, value, return -1;);
1662         memcpy(&object->highwatermark, (struct drsuapi_DsReplicaHighWaterMark *)py_talloc_get_ptr(value), sizeof(object->highwatermark));
1663         return 0;
1664 }
1665
1666 static PyObject *py_repsFromTo2_get_source_dsa_obj_guid(PyObject *obj, void *closure)
1667 {
1668         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1669         PyObject *py_source_dsa_obj_guid;
1670         py_source_dsa_obj_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->source_dsa_obj_guid);
1671         return py_source_dsa_obj_guid;
1672 }
1673
1674 static int py_repsFromTo2_set_source_dsa_obj_guid(PyObject *py_obj, PyObject *value, void *closure)
1675 {
1676         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1677         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1678         memcpy(&object->source_dsa_obj_guid, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->source_dsa_obj_guid));
1679         return 0;
1680 }
1681
1682 static PyObject *py_repsFromTo2_get_source_dsa_invocation_id(PyObject *obj, void *closure)
1683 {
1684         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1685         PyObject *py_source_dsa_invocation_id;
1686         py_source_dsa_invocation_id = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->source_dsa_invocation_id);
1687         return py_source_dsa_invocation_id;
1688 }
1689
1690 static int py_repsFromTo2_set_source_dsa_invocation_id(PyObject *py_obj, PyObject *value, void *closure)
1691 {
1692         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1693         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1694         memcpy(&object->source_dsa_invocation_id, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->source_dsa_invocation_id));
1695         return 0;
1696 }
1697
1698 static PyObject *py_repsFromTo2_get_transport_guid(PyObject *obj, void *closure)
1699 {
1700         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1701         PyObject *py_transport_guid;
1702         py_transport_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->transport_guid);
1703         return py_transport_guid;
1704 }
1705
1706 static int py_repsFromTo2_set_transport_guid(PyObject *py_obj, PyObject *value, void *closure)
1707 {
1708         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1709         PY_CHECK_TYPE(GUID_Type, value, return -1;);
1710         memcpy(&object->transport_guid, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->transport_guid));
1711         return 0;
1712 }
1713
1714 static PyObject *py_repsFromTo2_get_unknown1(PyObject *obj, void *closure)
1715 {
1716         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(obj);
1717         PyObject *py_unknown1;
1718         py_unknown1 = PyLong_FromLongLong(object->unknown1);
1719         return py_unknown1;
1720 }
1721
1722 static int py_repsFromTo2_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
1723 {
1724         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1725         if (PyObject_TypeCheck(value, &PyLong_Type)) {
1726                 object->unknown1 = PyLong_AsLongLong(value);
1727         } else {
1728                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
1729                         object->unknown1 = PyInt_AsLong(value);
1730                 } else {
1731                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1732                           PyInt_Type.tp_name, PyLong_Type.tp_name);
1733                         return -1;
1734                 }
1735         }
1736         return 0;
1737 }
1738
1739 static PyGetSetDef py_repsFromTo2_getsetters[] = {
1740         { discard_const_p(char, "blobsize"), py_repsFromTo2_get_blobsize, py_repsFromTo2_set_blobsize },
1741         { discard_const_p(char, "consecutive_sync_failures"), py_repsFromTo2_get_consecutive_sync_failures, py_repsFromTo2_set_consecutive_sync_failures },
1742         { discard_const_p(char, "last_success"), py_repsFromTo2_get_last_success, py_repsFromTo2_set_last_success },
1743         { discard_const_p(char, "last_attempt"), py_repsFromTo2_get_last_attempt, py_repsFromTo2_set_last_attempt },
1744         { discard_const_p(char, "result_last_attempt"), py_repsFromTo2_get_result_last_attempt, py_repsFromTo2_set_result_last_attempt },
1745         { discard_const_p(char, "other_info"), py_repsFromTo2_get_other_info, py_repsFromTo2_set_other_info },
1746         { discard_const_p(char, "other_info_length"), py_repsFromTo2_get_other_info_length, py_repsFromTo2_set_other_info_length },
1747         { discard_const_p(char, "replica_flags"), py_repsFromTo2_get_replica_flags, py_repsFromTo2_set_replica_flags },
1748         { discard_const_p(char, "schedule"), py_repsFromTo2_get_schedule, py_repsFromTo2_set_schedule },
1749         { discard_const_p(char, "reserved"), py_repsFromTo2_get_reserved, py_repsFromTo2_set_reserved },
1750         { discard_const_p(char, "highwatermark"), py_repsFromTo2_get_highwatermark, py_repsFromTo2_set_highwatermark },
1751         { discard_const_p(char, "source_dsa_obj_guid"), py_repsFromTo2_get_source_dsa_obj_guid, py_repsFromTo2_set_source_dsa_obj_guid },
1752         { discard_const_p(char, "source_dsa_invocation_id"), py_repsFromTo2_get_source_dsa_invocation_id, py_repsFromTo2_set_source_dsa_invocation_id },
1753         { discard_const_p(char, "transport_guid"), py_repsFromTo2_get_transport_guid, py_repsFromTo2_set_transport_guid },
1754         { discard_const_p(char, "unknown1"), py_repsFromTo2_get_unknown1, py_repsFromTo2_set_unknown1 },
1755         { NULL }
1756 };
1757
1758 static PyObject *py_repsFromTo2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1759 {
1760         return py_talloc_new(struct repsFromTo2, type);
1761 }
1762
1763 static PyObject *py_repsFromTo2_ndr_pack(PyObject *py_obj)
1764 {
1765         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1766         DATA_BLOB blob;
1767         enum ndr_err_code err;
1768         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_repsFromTo2);
1769         if (err != NDR_ERR_SUCCESS) {
1770                 PyErr_SetNdrError(err);
1771                 return NULL;
1772         }
1773
1774         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1775 }
1776
1777 static PyObject *py_repsFromTo2_ndr_unpack(PyObject *py_obj, PyObject *args)
1778 {
1779         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1780         DATA_BLOB blob;
1781         enum ndr_err_code err;
1782         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
1783                 return NULL;
1784
1785         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_repsFromTo2);
1786         if (err != NDR_ERR_SUCCESS) {
1787                 PyErr_SetNdrError(err);
1788                 return NULL;
1789         }
1790
1791         Py_RETURN_NONE;
1792 }
1793
1794 static PyObject *py_repsFromTo2_ndr_print(PyObject *py_obj)
1795 {
1796         struct repsFromTo2 *object = (struct repsFromTo2 *)py_talloc_get_ptr(py_obj);
1797         char *retstr;
1798         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_repsFromTo2, "repsFromTo2", object);
1799         return PyString_FromString(retstr);
1800 }
1801
1802 static PyMethodDef py_repsFromTo2_methods[] = {
1803         { "__ndr_pack__", (PyCFunction)py_repsFromTo2_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1804         { "__ndr_unpack__", (PyCFunction)py_repsFromTo2_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
1805         { "__ndr_print__", (PyCFunction)py_repsFromTo2_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1806         { NULL, NULL, 0, NULL }
1807 };
1808
1809
1810 static PyTypeObject repsFromTo2_Type = {
1811         PyObject_HEAD_INIT(NULL) 0,
1812         .tp_name = "drsblobs.repsFromTo2",
1813         .tp_basicsize = sizeof(py_talloc_Object),
1814         .tp_dealloc = py_talloc_dealloc,
1815         .tp_getset = py_repsFromTo2_getsetters,
1816         .tp_repr = py_talloc_default_repr,
1817         .tp_methods = py_repsFromTo2_methods,
1818         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1819         .tp_new = py_repsFromTo2_new,
1820 };
1821
1822 PyObject *py_import_repsFromTo(TALLOC_CTX *mem_ctx, int level, union repsFromTo *in)
1823 {
1824         PyObject *ret;
1825
1826         switch (level) {
1827                 case 1:
1828                         ret = py_talloc_reference_ex(&repsFromTo1_Type, mem_ctx, &in->ctr1);
1829                         return ret;
1830
1831                 case 2:
1832                         ret = py_talloc_reference_ex(&repsFromTo2_Type, mem_ctx, &in->ctr2);
1833                         return ret;
1834
1835         }
1836         PyErr_SetString(PyExc_TypeError, "unknown union level");
1837         return NULL;
1838 }
1839
1840 union repsFromTo *py_export_repsFromTo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1841 {
1842         union repsFromTo *ret = talloc_zero(mem_ctx, union repsFromTo);
1843         switch (level) {
1844                 case 1:
1845                         PY_CHECK_TYPE(&repsFromTo1_Type, in, talloc_free(ret); return NULL;);
1846                         memcpy(&ret->ctr1, (struct repsFromTo1 *)py_talloc_get_ptr(in), sizeof(ret->ctr1));
1847                         break;
1848
1849                 case 2:
1850                         PY_CHECK_TYPE(&repsFromTo2_Type, in, talloc_free(ret); return NULL;);
1851                         memcpy(&ret->ctr2, (struct repsFromTo2 *)py_talloc_get_ptr(in), sizeof(ret->ctr2));
1852                         break;
1853
1854                 default:
1855                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
1856                         talloc_free(ret);
1857                         ret = NULL;
1858         }
1859
1860         return ret;
1861 }
1862
1863
1864 static PyObject *py_repsFromToBlob_get_version(PyObject *obj, void *closure)
1865 {
1866         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(obj);
1867         PyObject *py_version;
1868         py_version = PyInt_FromLong(object->version);
1869         return py_version;
1870 }
1871
1872 static int py_repsFromToBlob_set_version(PyObject *py_obj, PyObject *value, void *closure)
1873 {
1874         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1875         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1876         object->version = PyInt_AsLong(value);
1877         return 0;
1878 }
1879
1880 static PyObject *py_repsFromToBlob_get_reserved(PyObject *obj, void *closure)
1881 {
1882         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(obj);
1883         PyObject *py_reserved;
1884         py_reserved = PyInt_FromLong(object->reserved);
1885         return py_reserved;
1886 }
1887
1888 static int py_repsFromToBlob_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
1889 {
1890         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1891         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1892         object->reserved = PyInt_AsLong(value);
1893         return 0;
1894 }
1895
1896 static PyObject *py_repsFromToBlob_get_ctr(PyObject *obj, void *closure)
1897 {
1898         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(obj);
1899         PyObject *py_ctr;
1900         py_ctr = py_import_repsFromTo(py_talloc_get_mem_ctx(obj), object->version, &object->ctr);
1901         if (py_ctr == NULL) {
1902                 return NULL;
1903         }
1904         return py_ctr;
1905 }
1906
1907 static int py_repsFromToBlob_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
1908 {
1909         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1910         {
1911                 void *ctr_switch_0;
1912                 ctr_switch_0 = py_export_repsFromTo(py_talloc_get_mem_ctx(py_obj), object->version, value);
1913                 if (ctr_switch_0 == NULL) { return -1; }
1914                 memcpy(&object->ctr, ctr_switch_0, sizeof(object->ctr));
1915         }
1916         return 0;
1917 }
1918
1919 static PyGetSetDef py_repsFromToBlob_getsetters[] = {
1920         { discard_const_p(char, "version"), py_repsFromToBlob_get_version, py_repsFromToBlob_set_version },
1921         { discard_const_p(char, "reserved"), py_repsFromToBlob_get_reserved, py_repsFromToBlob_set_reserved },
1922         { discard_const_p(char, "ctr"), py_repsFromToBlob_get_ctr, py_repsFromToBlob_set_ctr },
1923         { NULL }
1924 };
1925
1926 static PyObject *py_repsFromToBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1927 {
1928         return py_talloc_new(struct repsFromToBlob, type);
1929 }
1930
1931 static PyObject *py_repsFromToBlob_ndr_pack(PyObject *py_obj)
1932 {
1933         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1934         DATA_BLOB blob;
1935         enum ndr_err_code err;
1936         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
1937         if (err != NDR_ERR_SUCCESS) {
1938                 PyErr_SetNdrError(err);
1939                 return NULL;
1940         }
1941
1942         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1943 }
1944
1945 static PyObject *py_repsFromToBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
1946 {
1947         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1948         DATA_BLOB blob;
1949         enum ndr_err_code err;
1950         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
1951                 return NULL;
1952
1953         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
1954         if (err != NDR_ERR_SUCCESS) {
1955                 PyErr_SetNdrError(err);
1956                 return NULL;
1957         }
1958
1959         Py_RETURN_NONE;
1960 }
1961
1962 static PyObject *py_repsFromToBlob_ndr_print(PyObject *py_obj)
1963 {
1964         struct repsFromToBlob *object = (struct repsFromToBlob *)py_talloc_get_ptr(py_obj);
1965         char *retstr;
1966         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_repsFromToBlob, "repsFromToBlob", object);
1967         return PyString_FromString(retstr);
1968 }
1969
1970 static PyMethodDef py_repsFromToBlob_methods[] = {
1971         { "__ndr_pack__", (PyCFunction)py_repsFromToBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1972         { "__ndr_unpack__", (PyCFunction)py_repsFromToBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
1973         { "__ndr_print__", (PyCFunction)py_repsFromToBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1974         { NULL, NULL, 0, NULL }
1975 };
1976
1977
1978 static PyTypeObject repsFromToBlob_Type = {
1979         PyObject_HEAD_INIT(NULL) 0,
1980         .tp_name = "drsblobs.repsFromToBlob",
1981         .tp_basicsize = sizeof(py_talloc_Object),
1982         .tp_dealloc = py_talloc_dealloc,
1983         .tp_getset = py_repsFromToBlob_getsetters,
1984         .tp_repr = py_talloc_default_repr,
1985         .tp_methods = py_repsFromToBlob_methods,
1986         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1987         .tp_new = py_repsFromToBlob_new,
1988 };
1989
1990
1991 static PyObject *py_partialAttributeSetCtr1_get_count(PyObject *obj, void *closure)
1992 {
1993         struct partialAttributeSetCtr1 *object = (struct partialAttributeSetCtr1 *)py_talloc_get_ptr(obj);
1994         PyObject *py_count;
1995         py_count = PyInt_FromLong(object->count);
1996         return py_count;
1997 }
1998
1999 static int py_partialAttributeSetCtr1_set_count(PyObject *py_obj, PyObject *value, void *closure)
2000 {
2001         struct partialAttributeSetCtr1 *object = (struct partialAttributeSetCtr1 *)py_talloc_get_ptr(py_obj);
2002         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2003         object->count = PyInt_AsLong(value);
2004         return 0;
2005 }
2006
2007 static PyObject *py_partialAttributeSetCtr1_get_array(PyObject *obj, void *closure)
2008 {
2009         struct partialAttributeSetCtr1 *object = (struct partialAttributeSetCtr1 *)py_talloc_get_ptr(obj);
2010         PyObject *py_array;
2011         py_array = PyList_New(object->count);
2012         if (py_array == NULL) {
2013                 return NULL;
2014         }
2015         {
2016                 int array_cntr_0;
2017                 for (array_cntr_0 = 0; array_cntr_0 < object->count; array_cntr_0++) {
2018                         PyObject *py_array_0;
2019                         py_array_0 = PyInt_FromLong(object->array[array_cntr_0]);
2020                         PyList_SetItem(py_array, array_cntr_0, py_array_0);
2021                 }
2022         }
2023         return py_array;
2024 }
2025
2026 static int py_partialAttributeSetCtr1_set_array(PyObject *py_obj, PyObject *value, void *closure)
2027 {
2028         struct partialAttributeSetCtr1 *object = (struct partialAttributeSetCtr1 *)py_talloc_get_ptr(py_obj);
2029         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2030         {
2031                 int array_cntr_0;
2032                 object->array = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->array, PyList_Size(value));
2033                 for (array_cntr_0 = 0; array_cntr_0 < PyList_Size(value); array_cntr_0++) {
2034                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, array_cntr_0), return -1;);
2035                         object->array[array_cntr_0] = PyInt_AsLong(PyList_GetItem(value, array_cntr_0));
2036                 }
2037         }
2038         return 0;
2039 }
2040
2041 static PyGetSetDef py_partialAttributeSetCtr1_getsetters[] = {
2042         { discard_const_p(char, "count"), py_partialAttributeSetCtr1_get_count, py_partialAttributeSetCtr1_set_count },
2043         { discard_const_p(char, "array"), py_partialAttributeSetCtr1_get_array, py_partialAttributeSetCtr1_set_array },
2044         { NULL }
2045 };
2046
2047 static PyObject *py_partialAttributeSetCtr1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2048 {
2049         return py_talloc_new(struct partialAttributeSetCtr1, type);
2050 }
2051
2052
2053 static PyTypeObject partialAttributeSetCtr1_Type = {
2054         PyObject_HEAD_INIT(NULL) 0,
2055         .tp_name = "drsblobs.partialAttributeSetCtr1",
2056         .tp_basicsize = sizeof(py_talloc_Object),
2057         .tp_dealloc = py_talloc_dealloc,
2058         .tp_getset = py_partialAttributeSetCtr1_getsetters,
2059         .tp_repr = py_talloc_default_repr,
2060         .tp_methods = NULL,
2061         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2062         .tp_new = py_partialAttributeSetCtr1_new,
2063 };
2064
2065 PyObject *py_import_partialAttributeSetCtr(TALLOC_CTX *mem_ctx, int level, union partialAttributeSetCtr *in)
2066 {
2067         PyObject *ret;
2068
2069         switch (level) {
2070                 case 1:
2071                         ret = py_talloc_reference_ex(&partialAttributeSetCtr1_Type, mem_ctx, &in->ctr1);
2072                         return ret;
2073
2074         }
2075         PyErr_SetString(PyExc_TypeError, "unknown union level");
2076         return NULL;
2077 }
2078
2079 union partialAttributeSetCtr *py_export_partialAttributeSetCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2080 {
2081         union partialAttributeSetCtr *ret = talloc_zero(mem_ctx, union partialAttributeSetCtr);
2082         switch (level) {
2083                 case 1:
2084                         PY_CHECK_TYPE(&partialAttributeSetCtr1_Type, in, talloc_free(ret); return NULL;);
2085                         memcpy(&ret->ctr1, (struct partialAttributeSetCtr1 *)py_talloc_get_ptr(in), sizeof(ret->ctr1));
2086                         break;
2087
2088                 default:
2089                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
2090                         talloc_free(ret);
2091                         ret = NULL;
2092         }
2093
2094         return ret;
2095 }
2096
2097
2098 static PyObject *py_partialAttributeSetBlob_get_version(PyObject *obj, void *closure)
2099 {
2100         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(obj);
2101         PyObject *py_version;
2102         py_version = PyInt_FromLong(object->version);
2103         return py_version;
2104 }
2105
2106 static int py_partialAttributeSetBlob_set_version(PyObject *py_obj, PyObject *value, void *closure)
2107 {
2108         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2109         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2110         object->version = PyInt_AsLong(value);
2111         return 0;
2112 }
2113
2114 static PyObject *py_partialAttributeSetBlob_get_reserved(PyObject *obj, void *closure)
2115 {
2116         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(obj);
2117         PyObject *py_reserved;
2118         py_reserved = PyInt_FromLong(object->reserved);
2119         return py_reserved;
2120 }
2121
2122 static int py_partialAttributeSetBlob_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
2123 {
2124         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2125         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2126         object->reserved = PyInt_AsLong(value);
2127         return 0;
2128 }
2129
2130 static PyObject *py_partialAttributeSetBlob_get_ctr(PyObject *obj, void *closure)
2131 {
2132         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(obj);
2133         PyObject *py_ctr;
2134         py_ctr = py_import_partialAttributeSetCtr(py_talloc_get_mem_ctx(obj), object->version, &object->ctr);
2135         if (py_ctr == NULL) {
2136                 return NULL;
2137         }
2138         return py_ctr;
2139 }
2140
2141 static int py_partialAttributeSetBlob_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
2142 {
2143         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2144         {
2145                 void *ctr_switch_0;
2146                 ctr_switch_0 = py_export_partialAttributeSetCtr(py_talloc_get_mem_ctx(py_obj), object->version, value);
2147                 if (ctr_switch_0 == NULL) { return -1; }
2148                 memcpy(&object->ctr, ctr_switch_0, sizeof(object->ctr));
2149         }
2150         return 0;
2151 }
2152
2153 static PyGetSetDef py_partialAttributeSetBlob_getsetters[] = {
2154         { discard_const_p(char, "version"), py_partialAttributeSetBlob_get_version, py_partialAttributeSetBlob_set_version },
2155         { discard_const_p(char, "reserved"), py_partialAttributeSetBlob_get_reserved, py_partialAttributeSetBlob_set_reserved },
2156         { discard_const_p(char, "ctr"), py_partialAttributeSetBlob_get_ctr, py_partialAttributeSetBlob_set_ctr },
2157         { NULL }
2158 };
2159
2160 static PyObject *py_partialAttributeSetBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2161 {
2162         return py_talloc_new(struct partialAttributeSetBlob, type);
2163 }
2164
2165 static PyObject *py_partialAttributeSetBlob_ndr_pack(PyObject *py_obj)
2166 {
2167         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2168         DATA_BLOB blob;
2169         enum ndr_err_code err;
2170         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_partialAttributeSetBlob);
2171         if (err != NDR_ERR_SUCCESS) {
2172                 PyErr_SetNdrError(err);
2173                 return NULL;
2174         }
2175
2176         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2177 }
2178
2179 static PyObject *py_partialAttributeSetBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
2180 {
2181         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2182         DATA_BLOB blob;
2183         enum ndr_err_code err;
2184         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
2185                 return NULL;
2186
2187         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_partialAttributeSetBlob);
2188         if (err != NDR_ERR_SUCCESS) {
2189                 PyErr_SetNdrError(err);
2190                 return NULL;
2191         }
2192
2193         Py_RETURN_NONE;
2194 }
2195
2196 static PyObject *py_partialAttributeSetBlob_ndr_print(PyObject *py_obj)
2197 {
2198         struct partialAttributeSetBlob *object = (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_obj);
2199         char *retstr;
2200         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_partialAttributeSetBlob, "partialAttributeSetBlob", object);
2201         return PyString_FromString(retstr);
2202 }
2203
2204 static PyMethodDef py_partialAttributeSetBlob_methods[] = {
2205         { "__ndr_pack__", (PyCFunction)py_partialAttributeSetBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2206         { "__ndr_unpack__", (PyCFunction)py_partialAttributeSetBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
2207         { "__ndr_print__", (PyCFunction)py_partialAttributeSetBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2208         { NULL, NULL, 0, NULL }
2209 };
2210
2211
2212 static PyTypeObject partialAttributeSetBlob_Type = {
2213         PyObject_HEAD_INIT(NULL) 0,
2214         .tp_name = "drsblobs.partialAttributeSetBlob",
2215         .tp_basicsize = sizeof(py_talloc_Object),
2216         .tp_dealloc = py_talloc_dealloc,
2217         .tp_getset = py_partialAttributeSetBlob_getsetters,
2218         .tp_repr = py_talloc_default_repr,
2219         .tp_methods = py_partialAttributeSetBlob_methods,
2220         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2221         .tp_new = py_partialAttributeSetBlob_new,
2222 };
2223
2224
2225 static PyObject *py_schemaInfoBlob_get_marker(PyObject *obj, void *closure)
2226 {
2227         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(obj);
2228         PyObject *py_marker;
2229         py_marker = PyInt_FromLong(object->marker);
2230         return py_marker;
2231 }
2232
2233 static int py_schemaInfoBlob_set_marker(PyObject *py_obj, PyObject *value, void *closure)
2234 {
2235         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2236         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2237         object->marker = PyInt_AsLong(value);
2238         return 0;
2239 }
2240
2241 static PyObject *py_schemaInfoBlob_get_revision(PyObject *obj, void *closure)
2242 {
2243         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(obj);
2244         PyObject *py_revision;
2245         py_revision = PyInt_FromLong(object->revision);
2246         return py_revision;
2247 }
2248
2249 static int py_schemaInfoBlob_set_revision(PyObject *py_obj, PyObject *value, void *closure)
2250 {
2251         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2252         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2253         object->revision = PyInt_AsLong(value);
2254         return 0;
2255 }
2256
2257 static PyObject *py_schemaInfoBlob_get_invocation_id(PyObject *obj, void *closure)
2258 {
2259         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(obj);
2260         PyObject *py_invocation_id;
2261         py_invocation_id = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->invocation_id);
2262         return py_invocation_id;
2263 }
2264
2265 static int py_schemaInfoBlob_set_invocation_id(PyObject *py_obj, PyObject *value, void *closure)
2266 {
2267         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2268         PY_CHECK_TYPE(GUID_Type, value, return -1;);
2269         memcpy(&object->invocation_id, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->invocation_id));
2270         return 0;
2271 }
2272
2273 static PyGetSetDef py_schemaInfoBlob_getsetters[] = {
2274         { discard_const_p(char, "marker"), py_schemaInfoBlob_get_marker, py_schemaInfoBlob_set_marker },
2275         { discard_const_p(char, "revision"), py_schemaInfoBlob_get_revision, py_schemaInfoBlob_set_revision },
2276         { discard_const_p(char, "invocation_id"), py_schemaInfoBlob_get_invocation_id, py_schemaInfoBlob_set_invocation_id },
2277         { NULL }
2278 };
2279
2280 static PyObject *py_schemaInfoBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2281 {
2282         return py_talloc_new(struct schemaInfoBlob, type);
2283 }
2284
2285 static PyObject *py_schemaInfoBlob_ndr_pack(PyObject *py_obj)
2286 {
2287         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2288         DATA_BLOB blob;
2289         enum ndr_err_code err;
2290         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_schemaInfoBlob);
2291         if (err != NDR_ERR_SUCCESS) {
2292                 PyErr_SetNdrError(err);
2293                 return NULL;
2294         }
2295
2296         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2297 }
2298
2299 static PyObject *py_schemaInfoBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
2300 {
2301         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2302         DATA_BLOB blob;
2303         enum ndr_err_code err;
2304         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
2305                 return NULL;
2306
2307         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_schemaInfoBlob);
2308         if (err != NDR_ERR_SUCCESS) {
2309                 PyErr_SetNdrError(err);
2310                 return NULL;
2311         }
2312
2313         Py_RETURN_NONE;
2314 }
2315
2316 static PyObject *py_schemaInfoBlob_ndr_print(PyObject *py_obj)
2317 {
2318         struct schemaInfoBlob *object = (struct schemaInfoBlob *)py_talloc_get_ptr(py_obj);
2319         char *retstr;
2320         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_schemaInfoBlob, "schemaInfoBlob", object);
2321         return PyString_FromString(retstr);
2322 }
2323
2324 static PyMethodDef py_schemaInfoBlob_methods[] = {
2325         { "__ndr_pack__", (PyCFunction)py_schemaInfoBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2326         { "__ndr_unpack__", (PyCFunction)py_schemaInfoBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
2327         { "__ndr_print__", (PyCFunction)py_schemaInfoBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2328         { NULL, NULL, 0, NULL }
2329 };
2330
2331
2332 static PyTypeObject schemaInfoBlob_Type = {
2333         PyObject_HEAD_INIT(NULL) 0,
2334         .tp_name = "drsblobs.schemaInfoBlob",
2335         .tp_basicsize = sizeof(py_talloc_Object),
2336         .tp_dealloc = py_talloc_dealloc,
2337         .tp_getset = py_schemaInfoBlob_getsetters,
2338         .tp_repr = py_talloc_default_repr,
2339         .tp_methods = py_schemaInfoBlob_methods,
2340         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2341         .tp_new = py_schemaInfoBlob_new,
2342 };
2343
2344
2345 static PyObject *py_drsuapi_MSPrefixMap_Entry_get_entryID(PyObject *obj, void *closure)
2346 {
2347         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(obj);
2348         PyObject *py_entryID;
2349         py_entryID = PyInt_FromLong(object->entryID);
2350         return py_entryID;
2351 }
2352
2353 static int py_drsuapi_MSPrefixMap_Entry_set_entryID(PyObject *py_obj, PyObject *value, void *closure)
2354 {
2355         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(py_obj);
2356         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2357         object->entryID = PyInt_AsLong(value);
2358         return 0;
2359 }
2360
2361 static PyObject *py_drsuapi_MSPrefixMap_Entry_get_length(PyObject *obj, void *closure)
2362 {
2363         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(obj);
2364         PyObject *py_length;
2365         py_length = PyInt_FromLong(object->length);
2366         return py_length;
2367 }
2368
2369 static int py_drsuapi_MSPrefixMap_Entry_set_length(PyObject *py_obj, PyObject *value, void *closure)
2370 {
2371         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(py_obj);
2372         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2373         object->length = PyInt_AsLong(value);
2374         return 0;
2375 }
2376
2377 static PyObject *py_drsuapi_MSPrefixMap_Entry_get_binary_oid(PyObject *obj, void *closure)
2378 {
2379         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(obj);
2380         PyObject *py_binary_oid;
2381         py_binary_oid = PyList_New(object->length);
2382         if (py_binary_oid == NULL) {
2383                 return NULL;
2384         }
2385         {
2386                 int binary_oid_cntr_0;
2387                 for (binary_oid_cntr_0 = 0; binary_oid_cntr_0 < object->length; binary_oid_cntr_0++) {
2388                         PyObject *py_binary_oid_0;
2389                         py_binary_oid_0 = PyInt_FromLong(object->binary_oid[binary_oid_cntr_0]);
2390                         PyList_SetItem(py_binary_oid, binary_oid_cntr_0, py_binary_oid_0);
2391                 }
2392         }
2393         return py_binary_oid;
2394 }
2395
2396 static int py_drsuapi_MSPrefixMap_Entry_set_binary_oid(PyObject *py_obj, PyObject *value, void *closure)
2397 {
2398         struct drsuapi_MSPrefixMap_Entry *object = (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(py_obj);
2399         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2400         {
2401                 int binary_oid_cntr_0;
2402                 object->binary_oid = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->binary_oid, PyList_Size(value));
2403                 for (binary_oid_cntr_0 = 0; binary_oid_cntr_0 < PyList_Size(value); binary_oid_cntr_0++) {
2404                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, binary_oid_cntr_0), return -1;);
2405                         object->binary_oid[binary_oid_cntr_0] = PyInt_AsLong(PyList_GetItem(value, binary_oid_cntr_0));
2406                 }
2407         }
2408         return 0;
2409 }
2410
2411 static PyGetSetDef py_drsuapi_MSPrefixMap_Entry_getsetters[] = {
2412         { discard_const_p(char, "entryID"), py_drsuapi_MSPrefixMap_Entry_get_entryID, py_drsuapi_MSPrefixMap_Entry_set_entryID },
2413         { discard_const_p(char, "length"), py_drsuapi_MSPrefixMap_Entry_get_length, py_drsuapi_MSPrefixMap_Entry_set_length },
2414         { discard_const_p(char, "binary_oid"), py_drsuapi_MSPrefixMap_Entry_get_binary_oid, py_drsuapi_MSPrefixMap_Entry_set_binary_oid },
2415         { NULL }
2416 };
2417
2418 static PyObject *py_drsuapi_MSPrefixMap_Entry_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2419 {
2420         return py_talloc_new(struct drsuapi_MSPrefixMap_Entry, type);
2421 }
2422
2423
2424 static PyTypeObject drsuapi_MSPrefixMap_Entry_Type = {
2425         PyObject_HEAD_INIT(NULL) 0,
2426         .tp_name = "drsblobs.drsuapi_MSPrefixMap_Entry",
2427         .tp_basicsize = sizeof(py_talloc_Object),
2428         .tp_dealloc = py_talloc_dealloc,
2429         .tp_getset = py_drsuapi_MSPrefixMap_Entry_getsetters,
2430         .tp_repr = py_talloc_default_repr,
2431         .tp_methods = NULL,
2432         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2433         .tp_new = py_drsuapi_MSPrefixMap_Entry_new,
2434 };
2435
2436
2437 static PyObject *py_drsuapi_MSPrefixMap_Ctr_get_num_entries(PyObject *obj, void *closure)
2438 {
2439         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(obj);
2440         PyObject *py_num_entries;
2441         py_num_entries = PyInt_FromLong(object->num_entries);
2442         return py_num_entries;
2443 }
2444
2445 static int py_drsuapi_MSPrefixMap_Ctr_set_num_entries(PyObject *py_obj, PyObject *value, void *closure)
2446 {
2447         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2448         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2449         object->num_entries = PyInt_AsLong(value);
2450         return 0;
2451 }
2452
2453 static PyObject *py_drsuapi_MSPrefixMap_Ctr_get___ndr_size(PyObject *obj, void *closure)
2454 {
2455         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(obj);
2456         PyObject *py___ndr_size;
2457         py___ndr_size = PyInt_FromLong(object->__ndr_size);
2458         return py___ndr_size;
2459 }
2460
2461 static int py_drsuapi_MSPrefixMap_Ctr_set___ndr_size(PyObject *py_obj, PyObject *value, void *closure)
2462 {
2463         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2464         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2465         object->__ndr_size = PyInt_AsLong(value);
2466         return 0;
2467 }
2468
2469 static PyObject *py_drsuapi_MSPrefixMap_Ctr_get_entries(PyObject *obj, void *closure)
2470 {
2471         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(obj);
2472         PyObject *py_entries;
2473         py_entries = PyList_New(object->num_entries);
2474         if (py_entries == NULL) {
2475                 return NULL;
2476         }
2477         {
2478                 int entries_cntr_0;
2479                 for (entries_cntr_0 = 0; entries_cntr_0 < object->num_entries; entries_cntr_0++) {
2480                         PyObject *py_entries_0;
2481                         py_entries_0 = py_talloc_reference_ex(&drsuapi_MSPrefixMap_Entry_Type, object->entries, &object->entries[entries_cntr_0]);
2482                         PyList_SetItem(py_entries, entries_cntr_0, py_entries_0);
2483                 }
2484         }
2485         return py_entries;
2486 }
2487
2488 static int py_drsuapi_MSPrefixMap_Ctr_set_entries(PyObject *py_obj, PyObject *value, void *closure)
2489 {
2490         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2491         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2492         {
2493                 int entries_cntr_0;
2494                 object->entries = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->entries, PyList_Size(value));
2495                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_Size(value); entries_cntr_0++) {
2496                         PY_CHECK_TYPE(&drsuapi_MSPrefixMap_Entry_Type, PyList_GetItem(value, entries_cntr_0), return -1;);
2497                         memcpy(&object->entries[entries_cntr_0], (struct drsuapi_MSPrefixMap_Entry *)py_talloc_get_ptr(PyList_GetItem(value, entries_cntr_0)), sizeof(object->entries[entries_cntr_0]));
2498                 }
2499         }
2500         return 0;
2501 }
2502
2503 static PyGetSetDef py_drsuapi_MSPrefixMap_Ctr_getsetters[] = {
2504         { discard_const_p(char, "num_entries"), py_drsuapi_MSPrefixMap_Ctr_get_num_entries, py_drsuapi_MSPrefixMap_Ctr_set_num_entries },
2505         { discard_const_p(char, "__ndr_size"), py_drsuapi_MSPrefixMap_Ctr_get___ndr_size, py_drsuapi_MSPrefixMap_Ctr_set___ndr_size },
2506         { discard_const_p(char, "entries"), py_drsuapi_MSPrefixMap_Ctr_get_entries, py_drsuapi_MSPrefixMap_Ctr_set_entries },
2507         { NULL }
2508 };
2509
2510 static PyObject *py_drsuapi_MSPrefixMap_Ctr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2511 {
2512         return py_talloc_new(struct drsuapi_MSPrefixMap_Ctr, type);
2513 }
2514
2515 static PyObject *py_drsuapi_MSPrefixMap_Ctr_ndr_pack(PyObject *py_obj)
2516 {
2517         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2518         DATA_BLOB blob;
2519         enum ndr_err_code err;
2520         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_drsuapi_MSPrefixMap_Ctr);
2521         if (err != NDR_ERR_SUCCESS) {
2522                 PyErr_SetNdrError(err);
2523                 return NULL;
2524         }
2525
2526         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2527 }
2528
2529 static PyObject *py_drsuapi_MSPrefixMap_Ctr_ndr_unpack(PyObject *py_obj, PyObject *args)
2530 {
2531         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2532         DATA_BLOB blob;
2533         enum ndr_err_code err;
2534         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
2535                 return NULL;
2536
2537         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_drsuapi_MSPrefixMap_Ctr);
2538         if (err != NDR_ERR_SUCCESS) {
2539                 PyErr_SetNdrError(err);
2540                 return NULL;
2541         }
2542
2543         Py_RETURN_NONE;
2544 }
2545
2546 static PyObject *py_drsuapi_MSPrefixMap_Ctr_ndr_print(PyObject *py_obj)
2547 {
2548         struct drsuapi_MSPrefixMap_Ctr *object = (struct drsuapi_MSPrefixMap_Ctr *)py_talloc_get_ptr(py_obj);
2549         char *retstr;
2550         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_drsuapi_MSPrefixMap_Ctr, "drsuapi_MSPrefixMap_Ctr", object);
2551         return PyString_FromString(retstr);
2552 }
2553
2554 static PyMethodDef py_drsuapi_MSPrefixMap_Ctr_methods[] = {
2555         { "__ndr_pack__", (PyCFunction)py_drsuapi_MSPrefixMap_Ctr_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2556         { "__ndr_unpack__", (PyCFunction)py_drsuapi_MSPrefixMap_Ctr_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
2557         { "__ndr_print__", (PyCFunction)py_drsuapi_MSPrefixMap_Ctr_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2558         { NULL, NULL, 0, NULL }
2559 };
2560
2561
2562 static PyTypeObject drsuapi_MSPrefixMap_Ctr_Type = {
2563         PyObject_HEAD_INIT(NULL) 0,
2564         .tp_name = "drsblobs.drsuapi_MSPrefixMap_Ctr",
2565         .tp_basicsize = sizeof(py_talloc_Object),
2566         .tp_dealloc = py_talloc_dealloc,
2567         .tp_getset = py_drsuapi_MSPrefixMap_Ctr_getsetters,
2568         .tp_repr = py_talloc_default_repr,
2569         .tp_methods = py_drsuapi_MSPrefixMap_Ctr_methods,
2570         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2571         .tp_new = py_drsuapi_MSPrefixMap_Ctr_new,
2572 };
2573
2574 PyObject *py_import_prefixMapCtr(TALLOC_CTX *mem_ctx, int level, union prefixMapCtr *in)
2575 {
2576         PyObject *ret;
2577
2578         switch (level) {
2579                 case PREFIX_MAP_VERSION_DSDB:
2580                         ret = py_talloc_reference_ex(drsuapi_DsReplicaOIDMapping_Ctr_Type, mem_ctx, &in->dsdb);
2581                         return ret;
2582
2583         }
2584         PyErr_SetString(PyExc_TypeError, "unknown union level");
2585         return NULL;
2586 }
2587
2588 union prefixMapCtr *py_export_prefixMapCtr(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2589 {
2590         union prefixMapCtr *ret = talloc_zero(mem_ctx, union prefixMapCtr);
2591         switch (level) {
2592                 case PREFIX_MAP_VERSION_DSDB:
2593                         PY_CHECK_TYPE(drsuapi_DsReplicaOIDMapping_Ctr_Type, in, talloc_free(ret); return NULL;);
2594                         memcpy(&ret->dsdb, (struct drsuapi_DsReplicaOIDMapping_Ctr *)py_talloc_get_ptr(in), sizeof(ret->dsdb));
2595                         break;
2596
2597                 default:
2598                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
2599                         talloc_free(ret);
2600                         ret = NULL;
2601         }
2602
2603         return ret;
2604 }
2605
2606
2607 static PyObject *py_prefixMapBlob_get_version(PyObject *obj, void *closure)
2608 {
2609         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(obj);
2610         PyObject *py_version;
2611         py_version = PyInt_FromLong(object->version);
2612         return py_version;
2613 }
2614
2615 static int py_prefixMapBlob_set_version(PyObject *py_obj, PyObject *value, void *closure)
2616 {
2617         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2618         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2619         object->version = PyInt_AsLong(value);
2620         return 0;
2621 }
2622
2623 static PyObject *py_prefixMapBlob_get_reserved(PyObject *obj, void *closure)
2624 {
2625         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(obj);
2626         PyObject *py_reserved;
2627         py_reserved = PyInt_FromLong(object->reserved);
2628         return py_reserved;
2629 }
2630
2631 static int py_prefixMapBlob_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
2632 {
2633         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2634         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2635         object->reserved = PyInt_AsLong(value);
2636         return 0;
2637 }
2638
2639 static PyObject *py_prefixMapBlob_get_ctr(PyObject *obj, void *closure)
2640 {
2641         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(obj);
2642         PyObject *py_ctr;
2643         py_ctr = py_import_prefixMapCtr(py_talloc_get_mem_ctx(obj), object->version, &object->ctr);
2644         if (py_ctr == NULL) {
2645                 return NULL;
2646         }
2647         return py_ctr;
2648 }
2649
2650 static int py_prefixMapBlob_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
2651 {
2652         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2653         {
2654                 void *ctr_switch_0;
2655                 ctr_switch_0 = py_export_prefixMapCtr(py_talloc_get_mem_ctx(py_obj), object->version, value);
2656                 if (ctr_switch_0 == NULL) { return -1; }
2657                 memcpy(&object->ctr, ctr_switch_0, sizeof(object->ctr));
2658         }
2659         return 0;
2660 }
2661
2662 static PyGetSetDef py_prefixMapBlob_getsetters[] = {
2663         { discard_const_p(char, "version"), py_prefixMapBlob_get_version, py_prefixMapBlob_set_version },
2664         { discard_const_p(char, "reserved"), py_prefixMapBlob_get_reserved, py_prefixMapBlob_set_reserved },
2665         { discard_const_p(char, "ctr"), py_prefixMapBlob_get_ctr, py_prefixMapBlob_set_ctr },
2666         { NULL }
2667 };
2668
2669 static PyObject *py_prefixMapBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2670 {
2671         return py_talloc_new(struct prefixMapBlob, type);
2672 }
2673
2674 static PyObject *py_prefixMapBlob_ndr_pack(PyObject *py_obj)
2675 {
2676         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2677         DATA_BLOB blob;
2678         enum ndr_err_code err;
2679         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
2680         if (err != NDR_ERR_SUCCESS) {
2681                 PyErr_SetNdrError(err);
2682                 return NULL;
2683         }
2684
2685         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2686 }
2687
2688 static PyObject *py_prefixMapBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
2689 {
2690         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2691         DATA_BLOB blob;
2692         enum ndr_err_code err;
2693         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
2694                 return NULL;
2695
2696         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
2697         if (err != NDR_ERR_SUCCESS) {
2698                 PyErr_SetNdrError(err);
2699                 return NULL;
2700         }
2701
2702         Py_RETURN_NONE;
2703 }
2704
2705 static PyObject *py_prefixMapBlob_ndr_print(PyObject *py_obj)
2706 {
2707         struct prefixMapBlob *object = (struct prefixMapBlob *)py_talloc_get_ptr(py_obj);
2708         char *retstr;
2709         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_prefixMapBlob, "prefixMapBlob", object);
2710         return PyString_FromString(retstr);
2711 }
2712
2713 static PyMethodDef py_prefixMapBlob_methods[] = {
2714         { "__ndr_pack__", (PyCFunction)py_prefixMapBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2715         { "__ndr_unpack__", (PyCFunction)py_prefixMapBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
2716         { "__ndr_print__", (PyCFunction)py_prefixMapBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2717         { NULL, NULL, 0, NULL }
2718 };
2719
2720
2721 static PyTypeObject prefixMapBlob_Type = {
2722         PyObject_HEAD_INIT(NULL) 0,
2723         .tp_name = "drsblobs.prefixMapBlob",
2724         .tp_basicsize = sizeof(py_talloc_Object),
2725         .tp_dealloc = py_talloc_dealloc,
2726         .tp_getset = py_prefixMapBlob_getsetters,
2727         .tp_repr = py_talloc_default_repr,
2728         .tp_methods = py_prefixMapBlob_methods,
2729         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2730         .tp_new = py_prefixMapBlob_new,
2731 };
2732
2733 PyObject *py_import_ldapControlDirSyncExtra(TALLOC_CTX *mem_ctx, int level, union ldapControlDirSyncExtra *in)
2734 {
2735         PyObject *ret;
2736
2737         switch (level) {
2738                 case 0:
2739                         ret = Py_None;
2740                         Py_INCREF(ret);
2741                         return ret;
2742
2743                 default:
2744                         ret = py_talloc_reference_ex(&replUpToDateVectorBlob_Type, mem_ctx, &in->uptodateness_vector);
2745                         return ret;
2746
2747         }
2748         PyErr_SetString(PyExc_TypeError, "unknown union level");
2749         return NULL;
2750 }
2751
2752 union ldapControlDirSyncExtra *py_export_ldapControlDirSyncExtra(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2753 {
2754         union ldapControlDirSyncExtra *ret = talloc_zero(mem_ctx, union ldapControlDirSyncExtra);
2755         switch (level) {
2756                 case 0:
2757                         break;
2758
2759                 default:
2760                         PY_CHECK_TYPE(&replUpToDateVectorBlob_Type, in, talloc_free(ret); return NULL;);
2761                         memcpy(&ret->uptodateness_vector, (struct replUpToDateVectorBlob *)py_talloc_get_ptr(in), sizeof(ret->uptodateness_vector));
2762                         break;
2763
2764         }
2765
2766         return ret;
2767 }
2768
2769
2770 static PyObject *py_ldapControlDirSyncBlob_get_u1(PyObject *obj, void *closure)
2771 {
2772         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2773         PyObject *py_u1;
2774         py_u1 = PyInt_FromLong(object->u1);
2775         return py_u1;
2776 }
2777
2778 static int py_ldapControlDirSyncBlob_set_u1(PyObject *py_obj, PyObject *value, void *closure)
2779 {
2780         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2781         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2782         object->u1 = PyInt_AsLong(value);
2783         return 0;
2784 }
2785
2786 static PyObject *py_ldapControlDirSyncBlob_get_time(PyObject *obj, void *closure)
2787 {
2788         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2789         PyObject *py_time;
2790         py_time = PyLong_FromLongLong(object->time);
2791         return py_time;
2792 }
2793
2794 static int py_ldapControlDirSyncBlob_set_time(PyObject *py_obj, PyObject *value, void *closure)
2795 {
2796         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2797         if (PyObject_TypeCheck(value, &PyLong_Type)) {
2798                 object->time = PyLong_AsLongLong(value);
2799         } else {
2800                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
2801                         object->time = PyInt_AsLong(value);
2802                 } else {
2803                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2804                           PyInt_Type.tp_name, PyLong_Type.tp_name);
2805                         return -1;
2806                 }
2807         }
2808         return 0;
2809 }
2810
2811 static PyObject *py_ldapControlDirSyncBlob_get_u2(PyObject *obj, void *closure)
2812 {
2813         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2814         PyObject *py_u2;
2815         py_u2 = PyInt_FromLong(object->u2);
2816         return py_u2;
2817 }
2818
2819 static int py_ldapControlDirSyncBlob_set_u2(PyObject *py_obj, PyObject *value, void *closure)
2820 {
2821         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2822         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2823         object->u2 = PyInt_AsLong(value);
2824         return 0;
2825 }
2826
2827 static PyObject *py_ldapControlDirSyncBlob_get_u3(PyObject *obj, void *closure)
2828 {
2829         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2830         PyObject *py_u3;
2831         py_u3 = PyInt_FromLong(object->u3);
2832         return py_u3;
2833 }
2834
2835 static int py_ldapControlDirSyncBlob_set_u3(PyObject *py_obj, PyObject *value, void *closure)
2836 {
2837         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2838         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2839         object->u3 = PyInt_AsLong(value);
2840         return 0;
2841 }
2842
2843 static PyObject *py_ldapControlDirSyncBlob_get_extra_length(PyObject *obj, void *closure)
2844 {
2845         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2846         PyObject *py_extra_length;
2847         py_extra_length = PyInt_FromLong(object->extra_length);
2848         return py_extra_length;
2849 }
2850
2851 static int py_ldapControlDirSyncBlob_set_extra_length(PyObject *py_obj, PyObject *value, void *closure)
2852 {
2853         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2854         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2855         object->extra_length = PyInt_AsLong(value);
2856         return 0;
2857 }
2858
2859 static PyObject *py_ldapControlDirSyncBlob_get_highwatermark(PyObject *obj, void *closure)
2860 {
2861         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2862         PyObject *py_highwatermark;
2863         py_highwatermark = py_talloc_reference_ex(drsuapi_DsReplicaHighWaterMark_Type, py_talloc_get_mem_ctx(obj), &object->highwatermark);
2864         return py_highwatermark;
2865 }
2866
2867 static int py_ldapControlDirSyncBlob_set_highwatermark(PyObject *py_obj, PyObject *value, void *closure)
2868 {
2869         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2870         PY_CHECK_TYPE(drsuapi_DsReplicaHighWaterMark_Type, value, return -1;);
2871         memcpy(&object->highwatermark, (struct drsuapi_DsReplicaHighWaterMark *)py_talloc_get_ptr(value), sizeof(object->highwatermark));
2872         return 0;
2873 }
2874
2875 static PyObject *py_ldapControlDirSyncBlob_get_guid1(PyObject *obj, void *closure)
2876 {
2877         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2878         PyObject *py_guid1;
2879         py_guid1 = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->guid1);
2880         return py_guid1;
2881 }
2882
2883 static int py_ldapControlDirSyncBlob_set_guid1(PyObject *py_obj, PyObject *value, void *closure)
2884 {
2885         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2886         PY_CHECK_TYPE(GUID_Type, value, return -1;);
2887         memcpy(&object->guid1, (struct GUID *)py_talloc_get_ptr(value), sizeof(object->guid1));
2888         return 0;
2889 }
2890
2891 static PyObject *py_ldapControlDirSyncBlob_get_extra(PyObject *obj, void *closure)
2892 {
2893         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(obj);
2894         PyObject *py_extra;
2895         py_extra = py_import_ldapControlDirSyncExtra(py_talloc_get_mem_ctx(obj), object->extra_length, &object->extra);
2896         if (py_extra == NULL) {
2897                 return NULL;
2898         }
2899         return py_extra;
2900 }
2901
2902 static int py_ldapControlDirSyncBlob_set_extra(PyObject *py_obj, PyObject *value, void *closure)
2903 {
2904         struct ldapControlDirSyncBlob *object = (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(py_obj);
2905         {
2906                 void *extra_switch_0;
2907                 extra_switch_0 = py_export_ldapControlDirSyncExtra(py_talloc_get_mem_ctx(py_obj), object->extra_length, value);
2908                 if (extra_switch_0 == NULL) { return -1; }
2909                 memcpy(&object->extra, extra_switch_0, sizeof(object->extra));
2910         }
2911         return 0;
2912 }
2913
2914 static PyGetSetDef py_ldapControlDirSyncBlob_getsetters[] = {
2915         { discard_const_p(char, "u1"), py_ldapControlDirSyncBlob_get_u1, py_ldapControlDirSyncBlob_set_u1 },
2916         { discard_const_p(char, "time"), py_ldapControlDirSyncBlob_get_time, py_ldapControlDirSyncBlob_set_time },
2917         { discard_const_p(char, "u2"), py_ldapControlDirSyncBlob_get_u2, py_ldapControlDirSyncBlob_set_u2 },
2918         { discard_const_p(char, "u3"), py_ldapControlDirSyncBlob_get_u3, py_ldapControlDirSyncBlob_set_u3 },
2919         { discard_const_p(char, "extra_length"), py_ldapControlDirSyncBlob_get_extra_length, py_ldapControlDirSyncBlob_set_extra_length },
2920         { discard_const_p(char, "highwatermark"), py_ldapControlDirSyncBlob_get_highwatermark, py_ldapControlDirSyncBlob_set_highwatermark },
2921         { discard_const_p(char, "guid1"), py_ldapControlDirSyncBlob_get_guid1, py_ldapControlDirSyncBlob_set_guid1 },
2922         { discard_const_p(char, "extra"), py_ldapControlDirSyncBlob_get_extra, py_ldapControlDirSyncBlob_set_extra },
2923         { NULL }
2924 };
2925
2926 static PyObject *py_ldapControlDirSyncBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2927 {
2928         return py_talloc_new(struct ldapControlDirSyncBlob, type);
2929 }
2930
2931
2932 static PyTypeObject ldapControlDirSyncBlob_Type = {
2933         PyObject_HEAD_INIT(NULL) 0,
2934         .tp_name = "drsblobs.ldapControlDirSyncBlob",
2935         .tp_basicsize = sizeof(py_talloc_Object),
2936         .tp_dealloc = py_talloc_dealloc,
2937         .tp_getset = py_ldapControlDirSyncBlob_getsetters,
2938         .tp_repr = py_talloc_default_repr,
2939         .tp_methods = NULL,
2940         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2941         .tp_new = py_ldapControlDirSyncBlob_new,
2942 };
2943
2944
2945 static PyObject *py_ldapControlDirSyncCookie_get_msds(PyObject *obj, void *closure)
2946 {
2947         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(obj);
2948         PyObject *py_msds;
2949         py_msds = PyUnicode_Decode(object->msds, strlen(object->msds), "utf-8", "ignore");
2950         return py_msds;
2951 }
2952
2953 static int py_ldapControlDirSyncCookie_set_msds(PyObject *py_obj, PyObject *value, void *closure)
2954 {
2955         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_obj);
2956         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
2957         object->msds = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
2958         return 0;
2959 }
2960
2961 static PyObject *py_ldapControlDirSyncCookie_get_blob(PyObject *obj, void *closure)
2962 {
2963         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(obj);
2964         PyObject *py_blob;
2965         py_blob = py_talloc_reference_ex(&ldapControlDirSyncBlob_Type, py_talloc_get_mem_ctx(obj), &object->blob);
2966         return py_blob;
2967 }
2968
2969 static int py_ldapControlDirSyncCookie_set_blob(PyObject *py_obj, PyObject *value, void *closure)
2970 {
2971         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_obj);
2972         PY_CHECK_TYPE(&ldapControlDirSyncBlob_Type, value, return -1;);
2973         memcpy(&object->blob, (struct ldapControlDirSyncBlob *)py_talloc_get_ptr(value), sizeof(object->blob));
2974         return 0;
2975 }
2976
2977 static PyGetSetDef py_ldapControlDirSyncCookie_getsetters[] = {
2978         { discard_const_p(char, "msds"), py_ldapControlDirSyncCookie_get_msds, py_ldapControlDirSyncCookie_set_msds },
2979         { discard_const_p(char, "blob"), py_ldapControlDirSyncCookie_get_blob, py_ldapControlDirSyncCookie_set_blob },
2980         { NULL }
2981 };
2982
2983 static PyObject *py_ldapControlDirSyncCookie_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2984 {
2985         return py_talloc_new(struct ldapControlDirSyncCookie, type);
2986 }
2987
2988 static PyObject *py_ldapControlDirSyncCookie_ndr_pack(PyObject *py_obj)
2989 {
2990         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_obj);
2991         DATA_BLOB blob;
2992         enum ndr_err_code err;
2993         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ldapControlDirSyncCookie);
2994         if (err != NDR_ERR_SUCCESS) {
2995                 PyErr_SetNdrError(err);
2996                 return NULL;
2997         }
2998
2999         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3000 }
3001
3002 static PyObject *py_ldapControlDirSyncCookie_ndr_unpack(PyObject *py_obj, PyObject *args)
3003 {
3004         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_obj);
3005         DATA_BLOB blob;
3006         enum ndr_err_code err;
3007         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
3008                 return NULL;
3009
3010         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ldapControlDirSyncCookie);
3011         if (err != NDR_ERR_SUCCESS) {
3012                 PyErr_SetNdrError(err);
3013                 return NULL;
3014         }
3015
3016         Py_RETURN_NONE;
3017 }
3018
3019 static PyObject *py_ldapControlDirSyncCookie_ndr_print(PyObject *py_obj)
3020 {
3021         struct ldapControlDirSyncCookie *object = (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_obj);
3022         char *retstr;
3023         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ldapControlDirSyncCookie, "ldapControlDirSyncCookie", object);
3024         return PyString_FromString(retstr);
3025 }
3026
3027 static PyMethodDef py_ldapControlDirSyncCookie_methods[] = {
3028         { "__ndr_pack__", (PyCFunction)py_ldapControlDirSyncCookie_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3029         { "__ndr_unpack__", (PyCFunction)py_ldapControlDirSyncCookie_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
3030         { "__ndr_print__", (PyCFunction)py_ldapControlDirSyncCookie_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3031         { NULL, NULL, 0, NULL }
3032 };
3033
3034
3035 static PyTypeObject ldapControlDirSyncCookie_Type = {
3036         PyObject_HEAD_INIT(NULL) 0,
3037         .tp_name = "drsblobs.ldapControlDirSyncCookie",
3038         .tp_basicsize = sizeof(py_talloc_Object),
3039         .tp_dealloc = py_talloc_dealloc,
3040         .tp_getset = py_ldapControlDirSyncCookie_getsetters,
3041         .tp_repr = py_talloc_default_repr,
3042         .tp_methods = py_ldapControlDirSyncCookie_methods,
3043         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3044         .tp_new = py_ldapControlDirSyncCookie_new,
3045 };
3046
3047
3048 static PyObject *py_supplementalCredentialsPackage_get_name_len(PyObject *obj, void *closure)
3049 {
3050         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(obj);
3051         PyObject *py_name_len;
3052         py_name_len = PyInt_FromLong(object->name_len);
3053         return py_name_len;
3054 }
3055
3056 static int py_supplementalCredentialsPackage_set_name_len(PyObject *py_obj, PyObject *value, void *closure)
3057 {
3058         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(py_obj);
3059         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3060         object->name_len = PyInt_AsLong(value);
3061         return 0;
3062 }
3063
3064 static PyObject *py_supplementalCredentialsPackage_get_data_len(PyObject *obj, void *closure)
3065 {
3066         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(obj);
3067         PyObject *py_data_len;
3068         py_data_len = PyInt_FromLong(object->data_len);
3069         return py_data_len;
3070 }
3071
3072 static int py_supplementalCredentialsPackage_set_data_len(PyObject *py_obj, PyObject *value, void *closure)
3073 {
3074         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(py_obj);
3075         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3076         object->data_len = PyInt_AsLong(value);
3077         return 0;
3078 }
3079
3080 static PyObject *py_supplementalCredentialsPackage_get_reserved(PyObject *obj, void *closure)
3081 {
3082         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(obj);
3083         PyObject *py_reserved;
3084         py_reserved = PyInt_FromLong(object->reserved);
3085         return py_reserved;
3086 }
3087
3088 static int py_supplementalCredentialsPackage_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
3089 {
3090         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(py_obj);
3091         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3092         object->reserved = PyInt_AsLong(value);
3093         return 0;
3094 }
3095
3096 static PyObject *py_supplementalCredentialsPackage_get_name(PyObject *obj, void *closure)
3097 {
3098         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(obj);
3099         PyObject *py_name;
3100         py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
3101         return py_name;
3102 }
3103
3104 static int py_supplementalCredentialsPackage_set_name(PyObject *py_obj, PyObject *value, void *closure)
3105 {
3106         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(py_obj);
3107         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
3108         object->name = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3109         return 0;
3110 }
3111
3112 static PyObject *py_supplementalCredentialsPackage_get_data(PyObject *obj, void *closure)
3113 {
3114         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(obj);
3115         PyObject *py_data;
3116         py_data = PyUnicode_Decode(object->data, strlen(object->data), "utf-8", "ignore");
3117         return py_data;
3118 }
3119
3120 static int py_supplementalCredentialsPackage_set_data(PyObject *py_obj, PyObject *value, void *closure)
3121 {
3122         struct supplementalCredentialsPackage *object = (struct supplementalCredentialsPackage *)py_talloc_get_ptr(py_obj);
3123         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
3124         object->data = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3125         return 0;
3126 }
3127
3128 static PyGetSetDef py_supplementalCredentialsPackage_getsetters[] = {
3129         { discard_const_p(char, "name_len"), py_supplementalCredentialsPackage_get_name_len, py_supplementalCredentialsPackage_set_name_len },
3130         { discard_const_p(char, "data_len"), py_supplementalCredentialsPackage_get_data_len, py_supplementalCredentialsPackage_set_data_len },
3131         { discard_const_p(char, "reserved"), py_supplementalCredentialsPackage_get_reserved, py_supplementalCredentialsPackage_set_reserved },
3132         { discard_const_p(char, "name"), py_supplementalCredentialsPackage_get_name, py_supplementalCredentialsPackage_set_name },
3133         { discard_const_p(char, "data"), py_supplementalCredentialsPackage_get_data, py_supplementalCredentialsPackage_set_data },
3134         { NULL }
3135 };
3136
3137 static PyObject *py_supplementalCredentialsPackage_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3138 {
3139         return py_talloc_new(struct supplementalCredentialsPackage, type);
3140 }
3141
3142
3143 static PyTypeObject supplementalCredentialsPackage_Type = {
3144         PyObject_HEAD_INIT(NULL) 0,
3145         .tp_name = "drsblobs.supplementalCredentialsPackage",
3146         .tp_basicsize = sizeof(py_talloc_Object),
3147         .tp_dealloc = py_talloc_dealloc,
3148         .tp_getset = py_supplementalCredentialsPackage_getsetters,
3149         .tp_repr = py_talloc_default_repr,
3150         .tp_methods = NULL,
3151         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3152         .tp_new = py_supplementalCredentialsPackage_new,
3153 };
3154
3155
3156 static PyObject *py_supplementalCredentialsSubBlob_get_prefix(PyObject *obj, void *closure)
3157 {
3158         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(obj);
3159         PyObject *py_prefix;
3160         py_prefix = PyUnicode_Decode(object->prefix, strlen(object->prefix), "utf-8", "ignore");
3161         return py_prefix;
3162 }
3163
3164 static int py_supplementalCredentialsSubBlob_set_prefix(PyObject *py_obj, PyObject *value, void *closure)
3165 {
3166         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(py_obj);
3167         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
3168         object->prefix = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
3169         return 0;
3170 }
3171
3172 static PyObject *py_supplementalCredentialsSubBlob_get_signature(PyObject *obj, void *closure)
3173 {
3174         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(obj);
3175         PyObject *py_signature;
3176         py_signature = PyInt_FromLong(object->signature);
3177         return py_signature;
3178 }
3179
3180 static int py_supplementalCredentialsSubBlob_set_signature(PyObject *py_obj, PyObject *value, void *closure)
3181 {
3182         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(py_obj);
3183         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3184         object->signature = PyInt_AsLong(value);
3185         return 0;
3186 }
3187
3188 static PyObject *py_supplementalCredentialsSubBlob_get_num_packages(PyObject *obj, void *closure)
3189 {
3190         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(obj);
3191         PyObject *py_num_packages;
3192         py_num_packages = PyInt_FromLong(object->num_packages);
3193         return py_num_packages;
3194 }
3195
3196 static int py_supplementalCredentialsSubBlob_set_num_packages(PyObject *py_obj, PyObject *value, void *closure)
3197 {
3198         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(py_obj);
3199         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3200         object->num_packages = PyInt_AsLong(value);
3201         return 0;
3202 }
3203
3204 static PyObject *py_supplementalCredentialsSubBlob_get_packages(PyObject *obj, void *closure)
3205 {
3206         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(obj);
3207         PyObject *py_packages;
3208         py_packages = PyList_New(object->num_packages);
3209         if (py_packages == NULL) {
3210                 return NULL;
3211         }
3212         {
3213                 int packages_cntr_0;
3214                 for (packages_cntr_0 = 0; packages_cntr_0 < object->num_packages; packages_cntr_0++) {
3215                         PyObject *py_packages_0;
3216                         py_packages_0 = py_talloc_reference_ex(&supplementalCredentialsPackage_Type, object->packages, &object->packages[packages_cntr_0]);
3217                         PyList_SetItem(py_packages, packages_cntr_0, py_packages_0);
3218                 }
3219         }
3220         return py_packages;
3221 }
3222
3223 static int py_supplementalCredentialsSubBlob_set_packages(PyObject *py_obj, PyObject *value, void *closure)
3224 {
3225         struct supplementalCredentialsSubBlob *object = (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(py_obj);
3226         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3227         {
3228                 int packages_cntr_0;
3229                 object->packages = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->packages, PyList_Size(value));
3230                 for (packages_cntr_0 = 0; packages_cntr_0 < PyList_Size(value); packages_cntr_0++) {
3231                         PY_CHECK_TYPE(&supplementalCredentialsPackage_Type, PyList_GetItem(value, packages_cntr_0), return -1;);
3232                         memcpy(&object->packages[packages_cntr_0], (struct supplementalCredentialsPackage *)py_talloc_get_ptr(PyList_GetItem(value, packages_cntr_0)), sizeof(object->packages[packages_cntr_0]));
3233                 }
3234         }
3235         return 0;
3236 }
3237
3238 static PyGetSetDef py_supplementalCredentialsSubBlob_getsetters[] = {
3239         { discard_const_p(char, "prefix"), py_supplementalCredentialsSubBlob_get_prefix, py_supplementalCredentialsSubBlob_set_prefix },
3240         { discard_const_p(char, "signature"), py_supplementalCredentialsSubBlob_get_signature, py_supplementalCredentialsSubBlob_set_signature },
3241         { discard_const_p(char, "num_packages"), py_supplementalCredentialsSubBlob_get_num_packages, py_supplementalCredentialsSubBlob_set_num_packages },
3242         { discard_const_p(char, "packages"), py_supplementalCredentialsSubBlob_get_packages, py_supplementalCredentialsSubBlob_set_packages },
3243         { NULL }
3244 };
3245
3246 static PyObject *py_supplementalCredentialsSubBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3247 {
3248         return py_talloc_new(struct supplementalCredentialsSubBlob, type);
3249 }
3250
3251
3252 static PyTypeObject supplementalCredentialsSubBlob_Type = {
3253         PyObject_HEAD_INIT(NULL) 0,
3254         .tp_name = "drsblobs.supplementalCredentialsSubBlob",
3255         .tp_basicsize = sizeof(py_talloc_Object),
3256         .tp_dealloc = py_talloc_dealloc,
3257         .tp_getset = py_supplementalCredentialsSubBlob_getsetters,
3258         .tp_repr = py_talloc_default_repr,
3259         .tp_methods = NULL,
3260         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3261         .tp_new = py_supplementalCredentialsSubBlob_new,
3262 };
3263
3264
3265 static PyObject *py_supplementalCredentialsBlob_get_unknown1(PyObject *obj, void *closure)
3266 {
3267         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(obj);
3268         PyObject *py_unknown1;
3269         py_unknown1 = PyInt_FromLong(object->unknown1);
3270         return py_unknown1;
3271 }
3272
3273 static int py_supplementalCredentialsBlob_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
3274 {
3275         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3276         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3277         object->unknown1 = PyInt_AsLong(value);
3278         return 0;
3279 }
3280
3281 static PyObject *py_supplementalCredentialsBlob_get___ndr_size(PyObject *obj, void *closure)
3282 {
3283         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(obj);
3284         PyObject *py___ndr_size;
3285         py___ndr_size = PyInt_FromLong(object->__ndr_size);
3286         return py___ndr_size;
3287 }
3288
3289 static int py_supplementalCredentialsBlob_set___ndr_size(PyObject *py_obj, PyObject *value, void *closure)
3290 {
3291         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3292         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3293         object->__ndr_size = PyInt_AsLong(value);
3294         return 0;
3295 }
3296
3297 static PyObject *py_supplementalCredentialsBlob_get_unknown2(PyObject *obj, void *closure)
3298 {
3299         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(obj);
3300         PyObject *py_unknown2;
3301         py_unknown2 = PyInt_FromLong(object->unknown2);
3302         return py_unknown2;
3303 }
3304
3305 static int py_supplementalCredentialsBlob_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
3306 {
3307         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3308         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3309         object->unknown2 = PyInt_AsLong(value);
3310         return 0;
3311 }
3312
3313 static PyObject *py_supplementalCredentialsBlob_get_sub(PyObject *obj, void *closure)
3314 {
3315         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(obj);
3316         PyObject *py_sub;
3317         py_sub = py_talloc_reference_ex(&supplementalCredentialsSubBlob_Type, py_talloc_get_mem_ctx(obj), &object->sub);
3318         return py_sub;
3319 }
3320
3321 static int py_supplementalCredentialsBlob_set_sub(PyObject *py_obj, PyObject *value, void *closure)
3322 {
3323         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3324         PY_CHECK_TYPE(&supplementalCredentialsSubBlob_Type, value, return -1;);
3325         memcpy(&object->sub, (struct supplementalCredentialsSubBlob *)py_talloc_get_ptr(value), sizeof(object->sub));
3326         return 0;
3327 }
3328
3329 static PyObject *py_supplementalCredentialsBlob_get_unknown3(PyObject *obj, void *closure)
3330 {
3331         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(obj);
3332         PyObject *py_unknown3;
3333         py_unknown3 = PyInt_FromLong(object->unknown3);
3334         return py_unknown3;
3335 }
3336
3337 static int py_supplementalCredentialsBlob_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
3338 {
3339         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3340         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3341         object->unknown3 = PyInt_AsLong(value);
3342         return 0;
3343 }
3344
3345 static PyGetSetDef py_supplementalCredentialsBlob_getsetters[] = {
3346         { discard_const_p(char, "unknown1"), py_supplementalCredentialsBlob_get_unknown1, py_supplementalCredentialsBlob_set_unknown1 },
3347         { discard_const_p(char, "__ndr_size"), py_supplementalCredentialsBlob_get___ndr_size, py_supplementalCredentialsBlob_set___ndr_size },
3348         { discard_const_p(char, "unknown2"), py_supplementalCredentialsBlob_get_unknown2, py_supplementalCredentialsBlob_set_unknown2 },
3349         { discard_const_p(char, "sub"), py_supplementalCredentialsBlob_get_sub, py_supplementalCredentialsBlob_set_sub },
3350         { discard_const_p(char, "unknown3"), py_supplementalCredentialsBlob_get_unknown3, py_supplementalCredentialsBlob_set_unknown3 },
3351         { NULL }
3352 };
3353
3354 static PyObject *py_supplementalCredentialsBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3355 {
3356         return py_talloc_new(struct supplementalCredentialsBlob, type);
3357 }
3358
3359 static PyObject *py_supplementalCredentialsBlob_ndr_pack(PyObject *py_obj)
3360 {
3361         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3362         DATA_BLOB blob;
3363         enum ndr_err_code err;
3364         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_supplementalCredentialsBlob);
3365         if (err != NDR_ERR_SUCCESS) {
3366                 PyErr_SetNdrError(err);
3367                 return NULL;
3368         }
3369
3370         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3371 }
3372
3373 static PyObject *py_supplementalCredentialsBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
3374 {
3375         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3376         DATA_BLOB blob;
3377         enum ndr_err_code err;
3378         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
3379                 return NULL;
3380
3381         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
3382         if (err != NDR_ERR_SUCCESS) {
3383                 PyErr_SetNdrError(err);
3384                 return NULL;
3385         }
3386
3387         Py_RETURN_NONE;
3388 }
3389
3390 static PyObject *py_supplementalCredentialsBlob_ndr_print(PyObject *py_obj)
3391 {
3392         struct supplementalCredentialsBlob *object = (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_obj);
3393         char *retstr;
3394         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_supplementalCredentialsBlob, "supplementalCredentialsBlob", object);
3395         return PyString_FromString(retstr);
3396 }
3397
3398 static PyMethodDef py_supplementalCredentialsBlob_methods[] = {
3399         { "__ndr_pack__", (PyCFunction)py_supplementalCredentialsBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3400         { "__ndr_unpack__", (PyCFunction)py_supplementalCredentialsBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
3401         { "__ndr_print__", (PyCFunction)py_supplementalCredentialsBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3402         { NULL, NULL, 0, NULL }
3403 };
3404
3405
3406 static PyTypeObject supplementalCredentialsBlob_Type = {
3407         PyObject_HEAD_INIT(NULL) 0,
3408         .tp_name = "drsblobs.supplementalCredentialsBlob",
3409         .tp_basicsize = sizeof(py_talloc_Object),
3410         .tp_dealloc = py_talloc_dealloc,
3411         .tp_getset = py_supplementalCredentialsBlob_getsetters,
3412         .tp_repr = py_talloc_default_repr,
3413         .tp_methods = py_supplementalCredentialsBlob_methods,
3414         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3415         .tp_new = py_supplementalCredentialsBlob_new,
3416 };
3417
3418
3419 static PyObject *py_package_PackagesBlob_get_names(PyObject *obj, void *closure)
3420 {
3421         struct package_PackagesBlob *object = (struct package_PackagesBlob *)py_talloc_get_ptr(obj);
3422         PyObject *py_names;
3423         py_names = PyCObject_FromTallocPtr(object->names);
3424         return py_names;
3425 }
3426
3427 static int py_package_PackagesBlob_set_names(PyObject *py_obj, PyObject *value, void *closure)
3428 {
3429         struct package_PackagesBlob *object = (struct package_PackagesBlob *)py_talloc_get_ptr(py_obj);
3430         object->names = PyCObject_AsVoidPtr(value);
3431         return 0;
3432 }
3433
3434 static PyGetSetDef py_package_PackagesBlob_getsetters[] = {
3435         { discard_const_p(char, "names"), py_package_PackagesBlob_get_names, py_package_PackagesBlob_set_names },
3436         { NULL }
3437 };
3438
3439 static PyObject *py_package_PackagesBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3440 {
3441         return py_talloc_new(struct package_PackagesBlob, type);
3442 }
3443
3444 static PyObject *py_package_PackagesBlob_ndr_pack(PyObject *py_obj)
3445 {
3446         struct package_PackagesBlob *object = (struct package_PackagesBlob *)py_talloc_get_ptr(py_obj);
3447         DATA_BLOB blob;
3448         enum ndr_err_code err;
3449         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_package_PackagesBlob);
3450         if (err != NDR_ERR_SUCCESS) {
3451                 PyErr_SetNdrError(err);
3452                 return NULL;
3453         }
3454
3455         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3456 }
3457
3458 static PyObject *py_package_PackagesBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
3459 {
3460         struct package_PackagesBlob *object = (struct package_PackagesBlob *)py_talloc_get_ptr(py_obj);
3461         DATA_BLOB blob;
3462         enum ndr_err_code err;
3463         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
3464                 return NULL;
3465
3466         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_package_PackagesBlob);
3467         if (err != NDR_ERR_SUCCESS) {
3468                 PyErr_SetNdrError(err);
3469                 return NULL;
3470         }
3471
3472         Py_RETURN_NONE;
3473 }
3474
3475 static PyObject *py_package_PackagesBlob_ndr_print(PyObject *py_obj)
3476 {
3477         struct package_PackagesBlob *object = (struct package_PackagesBlob *)py_talloc_get_ptr(py_obj);
3478         char *retstr;
3479         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_package_PackagesBlob, "package_PackagesBlob", object);
3480         return PyString_FromString(retstr);
3481 }
3482
3483 static PyMethodDef py_package_PackagesBlob_methods[] = {
3484         { "__ndr_pack__", (PyCFunction)py_package_PackagesBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3485         { "__ndr_unpack__", (PyCFunction)py_package_PackagesBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
3486         { "__ndr_print__", (PyCFunction)py_package_PackagesBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3487         { NULL, NULL, 0, NULL }
3488 };
3489
3490
3491 static PyTypeObject package_PackagesBlob_Type = {
3492         PyObject_HEAD_INIT(NULL) 0,
3493         .tp_name = "drsblobs.package_PackagesBlob",
3494         .tp_basicsize = sizeof(py_talloc_Object),
3495         .tp_dealloc = py_talloc_dealloc,
3496         .tp_getset = py_package_PackagesBlob_getsetters,
3497         .tp_repr = py_talloc_default_repr,
3498         .tp_methods = py_package_PackagesBlob_methods,
3499         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3500         .tp_new = py_package_PackagesBlob_new,
3501 };
3502
3503
3504 static PyObject *py_package_PrimaryCLEARTEXTBlob_get_cleartext(PyObject *obj, void *closure)
3505 {
3506         struct package_PrimaryCLEARTEXTBlob *object = (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(obj);
3507         PyObject *py_cleartext;
3508         py_cleartext = PyString_FromStringAndSize((char *)(object->cleartext).data, (object->cleartext).length);
3509         return py_cleartext;
3510 }
3511
3512 static int py_package_PrimaryCLEARTEXTBlob_set_cleartext(PyObject *py_obj, PyObject *value, void *closure)
3513 {
3514         struct package_PrimaryCLEARTEXTBlob *object = (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(py_obj);
3515         object->cleartext = data_blob_talloc(py_talloc_get_mem_ctx(py_obj), PyString_AsString(value), PyString_Size(value));
3516         return 0;
3517 }
3518
3519 static PyGetSetDef py_package_PrimaryCLEARTEXTBlob_getsetters[] = {
3520         { discard_const_p(char, "cleartext"), py_package_PrimaryCLEARTEXTBlob_get_cleartext, py_package_PrimaryCLEARTEXTBlob_set_cleartext },
3521         { NULL }
3522 };
3523
3524 static PyObject *py_package_PrimaryCLEARTEXTBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3525 {
3526         return py_talloc_new(struct package_PrimaryCLEARTEXTBlob, type);
3527 }
3528
3529 static PyObject *py_package_PrimaryCLEARTEXTBlob_ndr_pack(PyObject *py_obj)
3530 {
3531         struct package_PrimaryCLEARTEXTBlob *object = (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(py_obj);
3532         DATA_BLOB blob;
3533         enum ndr_err_code err;
3534         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_package_PrimaryCLEARTEXTBlob);
3535         if (err != NDR_ERR_SUCCESS) {
3536                 PyErr_SetNdrError(err);
3537                 return NULL;
3538         }
3539
3540         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3541 }
3542
3543 static PyObject *py_package_PrimaryCLEARTEXTBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
3544 {
3545         struct package_PrimaryCLEARTEXTBlob *object = (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(py_obj);
3546         DATA_BLOB blob;
3547         enum ndr_err_code err;
3548         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
3549                 return NULL;
3550
3551         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_package_PrimaryCLEARTEXTBlob);
3552         if (err != NDR_ERR_SUCCESS) {
3553                 PyErr_SetNdrError(err);
3554                 return NULL;
3555         }
3556
3557         Py_RETURN_NONE;
3558 }
3559
3560 static PyObject *py_package_PrimaryCLEARTEXTBlob_ndr_print(PyObject *py_obj)
3561 {
3562         struct package_PrimaryCLEARTEXTBlob *object = (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(py_obj);
3563         char *retstr;
3564         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_package_PrimaryCLEARTEXTBlob, "package_PrimaryCLEARTEXTBlob", object);
3565         return PyString_FromString(retstr);
3566 }
3567
3568 static PyMethodDef py_package_PrimaryCLEARTEXTBlob_methods[] = {
3569         { "__ndr_pack__", (PyCFunction)py_package_PrimaryCLEARTEXTBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3570         { "__ndr_unpack__", (PyCFunction)py_package_PrimaryCLEARTEXTBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
3571         { "__ndr_print__", (PyCFunction)py_package_PrimaryCLEARTEXTBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3572         { NULL, NULL, 0, NULL }
3573 };
3574
3575
3576 static PyTypeObject package_PrimaryCLEARTEXTBlob_Type = {
3577         PyObject_HEAD_INIT(NULL) 0,
3578         .tp_name = "drsblobs.package_PrimaryCLEARTEXTBlob",
3579         .tp_basicsize = sizeof(py_talloc_Object),
3580         .tp_dealloc = py_talloc_dealloc,
3581         .tp_getset = py_package_PrimaryCLEARTEXTBlob_getsetters,
3582         .tp_repr = py_talloc_default_repr,
3583         .tp_methods = py_package_PrimaryCLEARTEXTBlob_methods,
3584         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3585         .tp_new = py_package_PrimaryCLEARTEXTBlob_new,
3586 };
3587
3588
3589 static PyObject *py_package_PrimaryWDigestHash_get_hash(PyObject *obj, void *closure)
3590 {
3591         struct package_PrimaryWDigestHash *object = (struct package_PrimaryWDigestHash *)py_talloc_get_ptr(obj);
3592         PyObject *py_hash;
3593         py_hash = PyList_New(16);
3594         if (py_hash == NULL) {
3595                 return NULL;
3596         }
3597         {
3598                 int hash_cntr_0;
3599                 for (hash_cntr_0 = 0; hash_cntr_0 < 16; hash_cntr_0++) {
3600                         PyObject *py_hash_0;
3601                         py_hash_0 = PyInt_FromLong(object->hash[hash_cntr_0]);
3602                         PyList_SetItem(py_hash, hash_cntr_0, py_hash_0);
3603                 }
3604         }
3605         return py_hash;
3606 }
3607
3608 static int py_package_PrimaryWDigestHash_set_hash(PyObject *py_obj, PyObject *value, void *closure)
3609 {
3610         struct package_PrimaryWDigestHash *object = (struct package_PrimaryWDigestHash *)py_talloc_get_ptr(py_obj);
3611         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3612         {
3613                 int hash_cntr_0;
3614                 for (hash_cntr_0 = 0; hash_cntr_0 < PyList_Size(value); hash_cntr_0++) {
3615                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, hash_cntr_0), return -1;);
3616                         object->hash[hash_cntr_0] = PyInt_AsLong(PyList_GetItem(value, hash_cntr_0));
3617                 }
3618         }
3619         return 0;
3620 }
3621
3622 static PyGetSetDef py_package_PrimaryWDigestHash_getsetters[] = {
3623         { discard_const_p(char, "hash"), py_package_PrimaryWDigestHash_get_hash, py_package_PrimaryWDigestHash_set_hash },
3624         { NULL }
3625 };
3626
3627 static PyObject *py_package_PrimaryWDigestHash_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3628 {
3629         return py_talloc_new(struct package_PrimaryWDigestHash, type);
3630 }
3631
3632
3633 static PyTypeObject package_PrimaryWDigestHash_Type = {
3634         PyObject_HEAD_INIT(NULL) 0,
3635         .tp_name = "drsblobs.package_PrimaryWDigestHash",
3636         .tp_basicsize = sizeof(py_talloc_Object),
3637         .tp_dealloc = py_talloc_dealloc,
3638         .tp_getset = py_package_PrimaryWDigestHash_getsetters,
3639         .tp_repr = py_talloc_default_repr,
3640         .tp_methods = NULL,
3641         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3642         .tp_new = py_package_PrimaryWDigestHash_new,
3643 };
3644
3645
3646 static PyObject *py_package_PrimaryWDigestBlob_get_unknown1(PyObject *obj, void *closure)
3647 {
3648         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3649         PyObject *py_unknown1;
3650         py_unknown1 = PyInt_FromLong(object->unknown1);
3651         return py_unknown1;
3652 }
3653
3654 static int py_package_PrimaryWDigestBlob_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
3655 {
3656         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3657         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3658         object->unknown1 = PyInt_AsLong(value);
3659         return 0;
3660 }
3661
3662 static PyObject *py_package_PrimaryWDigestBlob_get_unknown2(PyObject *obj, void *closure)
3663 {
3664         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3665         PyObject *py_unknown2;
3666         py_unknown2 = PyInt_FromLong(object->unknown2);
3667         return py_unknown2;
3668 }
3669
3670 static int py_package_PrimaryWDigestBlob_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
3671 {
3672         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3673         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3674         object->unknown2 = PyInt_AsLong(value);
3675         return 0;
3676 }
3677
3678 static PyObject *py_package_PrimaryWDigestBlob_get_num_hashes(PyObject *obj, void *closure)
3679 {
3680         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3681         PyObject *py_num_hashes;
3682         py_num_hashes = PyInt_FromLong(object->num_hashes);
3683         return py_num_hashes;
3684 }
3685
3686 static int py_package_PrimaryWDigestBlob_set_num_hashes(PyObject *py_obj, PyObject *value, void *closure)
3687 {
3688         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3689         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3690         object->num_hashes = PyInt_AsLong(value);
3691         return 0;
3692 }
3693
3694 static PyObject *py_package_PrimaryWDigestBlob_get_unknown3(PyObject *obj, void *closure)
3695 {
3696         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3697         PyObject *py_unknown3;
3698         py_unknown3 = PyInt_FromLong(object->unknown3);
3699         return py_unknown3;
3700 }
3701
3702 static int py_package_PrimaryWDigestBlob_set_unknown3(PyObject *py_obj, PyObject *value, void *closure)
3703 {
3704         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3705         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3706         object->unknown3 = PyInt_AsLong(value);
3707         return 0;
3708 }
3709
3710 static PyObject *py_package_PrimaryWDigestBlob_get_uuknown4(PyObject *obj, void *closure)
3711 {
3712         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3713         PyObject *py_uuknown4;
3714         py_uuknown4 = PyLong_FromLongLong(object->uuknown4);
3715         return py_uuknown4;
3716 }
3717
3718 static int py_package_PrimaryWDigestBlob_set_uuknown4(PyObject *py_obj, PyObject *value, void *closure)
3719 {
3720         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3721         if (PyObject_TypeCheck(value, &PyLong_Type)) {
3722                 object->uuknown4 = PyLong_AsLongLong(value);
3723         } else {
3724                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
3725                         object->uuknown4 = PyInt_AsLong(value);
3726                 } else {
3727                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3728                           PyInt_Type.tp_name, PyLong_Type.tp_name);
3729                         return -1;
3730                 }
3731         }
3732         return 0;
3733 }
3734
3735 static PyObject *py_package_PrimaryWDigestBlob_get_hashes(PyObject *obj, void *closure)
3736 {
3737         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(obj);
3738         PyObject *py_hashes;
3739         py_hashes = PyList_New(object->num_hashes);
3740         if (py_hashes == NULL) {
3741                 return NULL;
3742         }
3743         {
3744                 int hashes_cntr_0;
3745                 for (hashes_cntr_0 = 0; hashes_cntr_0 < object->num_hashes; hashes_cntr_0++) {
3746                         PyObject *py_hashes_0;
3747                         py_hashes_0 = py_talloc_reference_ex(&package_PrimaryWDigestHash_Type, object->hashes, &object->hashes[hashes_cntr_0]);
3748                         PyList_SetItem(py_hashes, hashes_cntr_0, py_hashes_0);
3749                 }
3750         }
3751         return py_hashes;
3752 }
3753
3754 static int py_package_PrimaryWDigestBlob_set_hashes(PyObject *py_obj, PyObject *value, void *closure)
3755 {
3756         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3757         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3758         {
3759                 int hashes_cntr_0;
3760                 object->hashes = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->hashes, PyList_Size(value));
3761                 for (hashes_cntr_0 = 0; hashes_cntr_0 < PyList_Size(value); hashes_cntr_0++) {
3762                         PY_CHECK_TYPE(&package_PrimaryWDigestHash_Type, PyList_GetItem(value, hashes_cntr_0), return -1;);
3763                         memcpy(&object->hashes[hashes_cntr_0], (struct package_PrimaryWDigestHash *)py_talloc_get_ptr(PyList_GetItem(value, hashes_cntr_0)), sizeof(object->hashes[hashes_cntr_0]));
3764                 }
3765         }
3766         return 0;
3767 }
3768
3769 static PyGetSetDef py_package_PrimaryWDigestBlob_getsetters[] = {
3770         { discard_const_p(char, "unknown1"), py_package_PrimaryWDigestBlob_get_unknown1, py_package_PrimaryWDigestBlob_set_unknown1 },
3771         { discard_const_p(char, "unknown2"), py_package_PrimaryWDigestBlob_get_unknown2, py_package_PrimaryWDigestBlob_set_unknown2 },
3772         { discard_const_p(char, "num_hashes"), py_package_PrimaryWDigestBlob_get_num_hashes, py_package_PrimaryWDigestBlob_set_num_hashes },
3773         { discard_const_p(char, "unknown3"), py_package_PrimaryWDigestBlob_get_unknown3, py_package_PrimaryWDigestBlob_set_unknown3 },
3774         { discard_const_p(char, "uuknown4"), py_package_PrimaryWDigestBlob_get_uuknown4, py_package_PrimaryWDigestBlob_set_uuknown4 },
3775         { discard_const_p(char, "hashes"), py_package_PrimaryWDigestBlob_get_hashes, py_package_PrimaryWDigestBlob_set_hashes },
3776         { NULL }
3777 };
3778
3779 static PyObject *py_package_PrimaryWDigestBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3780 {
3781         return py_talloc_new(struct package_PrimaryWDigestBlob, type);
3782 }
3783
3784 static PyObject *py_package_PrimaryWDigestBlob_ndr_pack(PyObject *py_obj)
3785 {
3786         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3787         DATA_BLOB blob;
3788         enum ndr_err_code err;
3789         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_package_PrimaryWDigestBlob);
3790         if (err != NDR_ERR_SUCCESS) {
3791                 PyErr_SetNdrError(err);
3792                 return NULL;
3793         }
3794
3795         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3796 }
3797
3798 static PyObject *py_package_PrimaryWDigestBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
3799 {
3800         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3801         DATA_BLOB blob;
3802         enum ndr_err_code err;
3803         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
3804                 return NULL;
3805
3806         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_package_PrimaryWDigestBlob);
3807         if (err != NDR_ERR_SUCCESS) {
3808                 PyErr_SetNdrError(err);
3809                 return NULL;
3810         }
3811
3812         Py_RETURN_NONE;
3813 }
3814
3815 static PyObject *py_package_PrimaryWDigestBlob_ndr_print(PyObject *py_obj)
3816 {
3817         struct package_PrimaryWDigestBlob *object = (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_obj);
3818         char *retstr;
3819         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_package_PrimaryWDigestBlob, "package_PrimaryWDigestBlob", object);
3820         return PyString_FromString(retstr);
3821 }
3822
3823 static PyMethodDef py_package_PrimaryWDigestBlob_methods[] = {
3824         { "__ndr_pack__", (PyCFunction)py_package_PrimaryWDigestBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3825         { "__ndr_unpack__", (PyCFunction)py_package_PrimaryWDigestBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
3826         { "__ndr_print__", (PyCFunction)py_package_PrimaryWDigestBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3827         { NULL, NULL, 0, NULL }
3828 };
3829
3830
3831 static PyTypeObject package_PrimaryWDigestBlob_Type = {
3832         PyObject_HEAD_INIT(NULL) 0,
3833         .tp_name = "drsblobs.package_PrimaryWDigestBlob",
3834         .tp_basicsize = sizeof(py_talloc_Object),
3835         .tp_dealloc = py_talloc_dealloc,
3836         .tp_getset = py_package_PrimaryWDigestBlob_getsetters,
3837         .tp_repr = py_talloc_default_repr,
3838         .tp_methods = py_package_PrimaryWDigestBlob_methods,
3839         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3840         .tp_new = py_package_PrimaryWDigestBlob_new,
3841 };
3842
3843
3844 static PyObject *py_AuthInfoNone_get_size(PyObject *obj, void *closure)
3845 {
3846         struct AuthInfoNone *object = (struct AuthInfoNone *)py_talloc_get_ptr(obj);
3847         PyObject *py_size;
3848         py_size = PyInt_FromLong(object->size);
3849         return py_size;
3850 }
3851
3852 static int py_AuthInfoNone_set_size(PyObject *py_obj, PyObject *value, void *closure)
3853 {
3854         struct AuthInfoNone *object = (struct AuthInfoNone *)py_talloc_get_ptr(py_obj);
3855         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3856         object->size = PyInt_AsLong(value);
3857         return 0;
3858 }
3859
3860 static PyGetSetDef py_AuthInfoNone_getsetters[] = {
3861         { discard_const_p(char, "size"), py_AuthInfoNone_get_size, py_AuthInfoNone_set_size },
3862         { NULL }
3863 };
3864
3865 static PyObject *py_AuthInfoNone_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3866 {
3867         return py_talloc_new(struct AuthInfoNone, type);
3868 }
3869
3870
3871 static PyTypeObject AuthInfoNone_Type = {
3872         PyObject_HEAD_INIT(NULL) 0,
3873         .tp_name = "drsblobs.AuthInfoNone",
3874         .tp_basicsize = sizeof(py_talloc_Object),
3875         .tp_dealloc = py_talloc_dealloc,
3876         .tp_getset = py_AuthInfoNone_getsetters,
3877         .tp_repr = py_talloc_default_repr,
3878         .tp_methods = NULL,
3879         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3880         .tp_new = py_AuthInfoNone_new,
3881 };
3882
3883
3884 static PyObject *py_AuthInfoNT4Owf_get_size(PyObject *obj, void *closure)
3885 {
3886         struct AuthInfoNT4Owf *object = (struct AuthInfoNT4Owf *)py_talloc_get_ptr(obj);
3887         PyObject *py_size;
3888         py_size = PyInt_FromLong(object->size);
3889         return py_size;
3890 }
3891
3892 static int py_AuthInfoNT4Owf_set_size(PyObject *py_obj, PyObject *value, void *closure)
3893 {
3894         struct AuthInfoNT4Owf *object = (struct AuthInfoNT4Owf *)py_talloc_get_ptr(py_obj);
3895         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3896         object->size = PyInt_AsLong(value);
3897         return 0;
3898 }
3899
3900 static PyObject *py_AuthInfoNT4Owf_get_password(PyObject *obj, void *closure)
3901 {
3902         struct AuthInfoNT4Owf *object = (struct AuthInfoNT4Owf *)py_talloc_get_ptr(obj);
3903         PyObject *py_password;
3904         py_password = py_talloc_reference_ex(samr_Password_Type, py_talloc_get_mem_ctx(obj), &object->password);
3905         return py_password;
3906 }
3907
3908 static int py_AuthInfoNT4Owf_set_password(PyObject *py_obj, PyObject *value, void *closure)
3909 {
3910         struct AuthInfoNT4Owf *object = (struct AuthInfoNT4Owf *)py_talloc_get_ptr(py_obj);
3911         PY_CHECK_TYPE(samr_Password_Type, value, return -1;);
3912         memcpy(&object->password, (struct samr_Password *)py_talloc_get_ptr(value), sizeof(object->password));
3913         return 0;
3914 }
3915
3916 static PyGetSetDef py_AuthInfoNT4Owf_getsetters[] = {
3917         { discard_const_p(char, "size"), py_AuthInfoNT4Owf_get_size, py_AuthInfoNT4Owf_set_size },
3918         { discard_const_p(char, "password"), py_AuthInfoNT4Owf_get_password, py_AuthInfoNT4Owf_set_password },
3919         { NULL }
3920 };
3921
3922 static PyObject *py_AuthInfoNT4Owf_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3923 {
3924         return py_talloc_new(struct AuthInfoNT4Owf, type);
3925 }
3926
3927
3928 static PyTypeObject AuthInfoNT4Owf_Type = {
3929         PyObject_HEAD_INIT(NULL) 0,
3930         .tp_name = "drsblobs.AuthInfoNT4Owf",
3931         .tp_basicsize = sizeof(py_talloc_Object),
3932         .tp_dealloc = py_talloc_dealloc,
3933         .tp_getset = py_AuthInfoNT4Owf_getsetters,
3934         .tp_repr = py_talloc_default_repr,
3935         .tp_methods = NULL,
3936         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3937         .tp_new = py_AuthInfoNT4Owf_new,
3938 };
3939
3940
3941 static PyObject *py_AuthInfoClear_get_size(PyObject *obj, void *closure)
3942 {
3943         struct AuthInfoClear *object = (struct AuthInfoClear *)py_talloc_get_ptr(obj);
3944         PyObject *py_size;
3945         py_size = PyInt_FromLong(object->size);
3946         return py_size;
3947 }
3948
3949 static int py_AuthInfoClear_set_size(PyObject *py_obj, PyObject *value, void *closure)
3950 {
3951         struct AuthInfoClear *object = (struct AuthInfoClear *)py_talloc_get_ptr(py_obj);
3952         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3953         object->size = PyInt_AsLong(value);
3954         return 0;
3955 }
3956
3957 static PyObject *py_AuthInfoClear_get_password(PyObject *obj, void *closure)
3958 {
3959         struct AuthInfoClear *object = (struct AuthInfoClear *)py_talloc_get_ptr(obj);
3960         PyObject *py_password;
3961         py_password = PyList_New(object->size);
3962         if (py_password == NULL) {
3963                 return NULL;
3964         }
3965         {
3966                 int password_cntr_0;
3967                 for (password_cntr_0 = 0; password_cntr_0 < object->size; password_cntr_0++) {
3968                         PyObject *py_password_0;
3969                         py_password_0 = PyInt_FromLong(object->password[password_cntr_0]);
3970                         PyList_SetItem(py_password, password_cntr_0, py_password_0);
3971                 }
3972         }
3973         return py_password;
3974 }
3975
3976 static int py_AuthInfoClear_set_password(PyObject *py_obj, PyObject *value, void *closure)
3977 {
3978         struct AuthInfoClear *object = (struct AuthInfoClear *)py_talloc_get_ptr(py_obj);
3979         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
3980         {
3981                 int password_cntr_0;
3982                 object->password = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->password, PyList_Size(value));
3983                 for (password_cntr_0 = 0; password_cntr_0 < PyList_Size(value); password_cntr_0++) {
3984                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, password_cntr_0), return -1;);
3985                         object->password[password_cntr_0] = PyInt_AsLong(PyList_GetItem(value, password_cntr_0));
3986                 }
3987         }
3988         return 0;
3989 }
3990
3991 static PyGetSetDef py_AuthInfoClear_getsetters[] = {
3992         { discard_const_p(char, "size"), py_AuthInfoClear_get_size, py_AuthInfoClear_set_size },
3993         { discard_const_p(char, "password"), py_AuthInfoClear_get_password, py_AuthInfoClear_set_password },
3994         { NULL }
3995 };
3996
3997 static PyObject *py_AuthInfoClear_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3998 {
3999         return py_talloc_new(struct AuthInfoClear, type);
4000 }
4001
4002
4003 static PyTypeObject AuthInfoClear_Type = {
4004         PyObject_HEAD_INIT(NULL) 0,
4005         .tp_name = "drsblobs.AuthInfoClear",
4006         .tp_basicsize = sizeof(py_talloc_Object),
4007         .tp_dealloc = py_talloc_dealloc,
4008         .tp_getset = py_AuthInfoClear_getsetters,
4009         .tp_repr = py_talloc_default_repr,
4010         .tp_methods = NULL,
4011         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4012         .tp_new = py_AuthInfoClear_new,
4013 };
4014
4015
4016 static PyObject *py_AuthInfoVersion_get_size(PyObject *obj, void *closure)
4017 {
4018         struct AuthInfoVersion *object = (struct AuthInfoVersion *)py_talloc_get_ptr(obj);
4019         PyObject *py_size;
4020         py_size = PyInt_FromLong(object->size);
4021         return py_size;
4022 }
4023
4024 static int py_AuthInfoVersion_set_size(PyObject *py_obj, PyObject *value, void *closure)
4025 {
4026         struct AuthInfoVersion *object = (struct AuthInfoVersion *)py_talloc_get_ptr(py_obj);
4027         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4028         object->size = PyInt_AsLong(value);
4029         return 0;
4030 }
4031
4032 static PyObject *py_AuthInfoVersion_get_version(PyObject *obj, void *closure)
4033 {
4034         struct AuthInfoVersion *object = (struct AuthInfoVersion *)py_talloc_get_ptr(obj);
4035         PyObject *py_version;
4036         py_version = PyInt_FromLong(object->version);
4037         return py_version;
4038 }
4039
4040 static int py_AuthInfoVersion_set_version(PyObject *py_obj, PyObject *value, void *closure)
4041 {
4042         struct AuthInfoVersion *object = (struct AuthInfoVersion *)py_talloc_get_ptr(py_obj);
4043         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4044         object->version = PyInt_AsLong(value);
4045         return 0;
4046 }
4047
4048 static PyGetSetDef py_AuthInfoVersion_getsetters[] = {
4049         { discard_const_p(char, "size"), py_AuthInfoVersion_get_size, py_AuthInfoVersion_set_size },
4050         { discard_const_p(char, "version"), py_AuthInfoVersion_get_version, py_AuthInfoVersion_set_version },
4051         { NULL }
4052 };
4053
4054 static PyObject *py_AuthInfoVersion_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4055 {
4056         return py_talloc_new(struct AuthInfoVersion, type);
4057 }
4058
4059
4060 static PyTypeObject AuthInfoVersion_Type = {
4061         PyObject_HEAD_INIT(NULL) 0,
4062         .tp_name = "drsblobs.AuthInfoVersion",
4063         .tp_basicsize = sizeof(py_talloc_Object),
4064         .tp_dealloc = py_talloc_dealloc,
4065         .tp_getset = py_AuthInfoVersion_getsetters,
4066         .tp_repr = py_talloc_default_repr,
4067         .tp_methods = NULL,
4068         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4069         .tp_new = py_AuthInfoVersion_new,
4070 };
4071
4072 PyObject *py_import_AuthInfo(TALLOC_CTX *mem_ctx, int level, union AuthInfo *in)
4073 {
4074         PyObject *ret;
4075
4076         switch (level) {
4077                 case TRUST_AUTH_TYPE_NONE:
4078                         ret = py_talloc_reference_ex(&AuthInfoNone_Type, mem_ctx, &in->none);
4079                         return ret;
4080
4081                 case TRUST_AUTH_TYPE_NT4OWF:
4082                         ret = py_talloc_reference_ex(&AuthInfoNT4Owf_Type, mem_ctx, &in->nt4owf);
4083                         return ret;
4084
4085                 case TRUST_AUTH_TYPE_CLEAR:
4086                         ret = py_talloc_reference_ex(&AuthInfoClear_Type, mem_ctx, &in->clear);
4087                         return ret;
4088
4089                 case TRUST_AUTH_TYPE_VERSION:
4090                         ret = py_talloc_reference_ex(&AuthInfoVersion_Type, mem_ctx, &in->version);
4091                         return ret;
4092
4093         }
4094         PyErr_SetString(PyExc_TypeError, "unknown union level");
4095         return NULL;
4096 }
4097
4098 union AuthInfo *py_export_AuthInfo(TALLOC_CTX *mem_ctx, int level, PyObject *in)
4099 {
4100         union AuthInfo *ret = talloc_zero(mem_ctx, union AuthInfo);
4101         switch (level) {
4102                 case TRUST_AUTH_TYPE_NONE:
4103                         PY_CHECK_TYPE(&AuthInfoNone_Type, in, talloc_free(ret); return NULL;);
4104                         memcpy(&ret->none, (struct AuthInfoNone *)py_talloc_get_ptr(in), sizeof(ret->none));
4105                         break;
4106
4107                 case TRUST_AUTH_TYPE_NT4OWF:
4108                         PY_CHECK_TYPE(&AuthInfoNT4Owf_Type, in, talloc_free(ret); return NULL;);
4109                         memcpy(&ret->nt4owf, (struct AuthInfoNT4Owf *)py_talloc_get_ptr(in), sizeof(ret->nt4owf));
4110                         break;
4111
4112                 case TRUST_AUTH_TYPE_CLEAR:
4113                         PY_CHECK_TYPE(&AuthInfoClear_Type, in, talloc_free(ret); return NULL;);
4114                         memcpy(&ret->clear, (struct AuthInfoClear *)py_talloc_get_ptr(in), sizeof(ret->clear));
4115                         break;
4116
4117                 case TRUST_AUTH_TYPE_VERSION:
4118                         PY_CHECK_TYPE(&AuthInfoVersion_Type, in, talloc_free(ret); return NULL;);
4119                         memcpy(&ret->version, (struct AuthInfoVersion *)py_talloc_get_ptr(in), sizeof(ret->version));
4120                         break;
4121
4122                 default:
4123                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
4124                         talloc_free(ret);
4125                         ret = NULL;
4126         }
4127
4128         return ret;
4129 }
4130
4131
4132 static PyObject *py_AuthenticationInformation_get_LastUpdateTime(PyObject *obj, void *closure)
4133 {
4134         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(obj);
4135         PyObject *py_LastUpdateTime;
4136         py_LastUpdateTime = PyLong_FromLongLong(object->LastUpdateTime);
4137         return py_LastUpdateTime;
4138 }
4139
4140 static int py_AuthenticationInformation_set_LastUpdateTime(PyObject *py_obj, PyObject *value, void *closure)
4141 {
4142         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4143         if (PyObject_TypeCheck(value, &PyLong_Type)) {
4144                 object->LastUpdateTime = PyLong_AsLongLong(value);
4145         } else {
4146                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
4147                         object->LastUpdateTime = PyInt_AsLong(value);
4148                 } else {
4149                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4150                           PyInt_Type.tp_name, PyLong_Type.tp_name);
4151                         return -1;
4152                 }
4153         }
4154         return 0;
4155 }
4156
4157 static PyObject *py_AuthenticationInformation_get_AuthType(PyObject *obj, void *closure)
4158 {
4159         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(obj);
4160         PyObject *py_AuthType;
4161         py_AuthType = PyInt_FromLong(object->AuthType);
4162         return py_AuthType;
4163 }
4164
4165 static int py_AuthenticationInformation_set_AuthType(PyObject *py_obj, PyObject *value, void *closure)
4166 {
4167         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4168         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4169         object->AuthType = PyInt_AsLong(value);
4170         return 0;
4171 }
4172
4173 static PyObject *py_AuthenticationInformation_get_AuthInfo(PyObject *obj, void *closure)
4174 {
4175         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(obj);
4176         PyObject *py_AuthInfo;
4177         py_AuthInfo = py_import_AuthInfo(py_talloc_get_mem_ctx(obj), object->AuthType, &object->AuthInfo);
4178         if (py_AuthInfo == NULL) {
4179                 return NULL;
4180         }
4181         return py_AuthInfo;
4182 }
4183
4184 static int py_AuthenticationInformation_set_AuthInfo(PyObject *py_obj, PyObject *value, void *closure)
4185 {
4186         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4187         {
4188                 void *AuthInfo_switch_0;
4189                 AuthInfo_switch_0 = py_export_AuthInfo(py_talloc_get_mem_ctx(py_obj), object->AuthType, value);
4190                 if (AuthInfo_switch_0 == NULL) { return -1; }
4191                 memcpy(&object->AuthInfo, AuthInfo_switch_0, sizeof(object->AuthInfo));
4192         }
4193         return 0;
4194 }
4195
4196 static PyObject *py_AuthenticationInformation_get__pad(PyObject *obj, void *closure)
4197 {
4198         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(obj);
4199         PyObject *py__pad;
4200         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
4201         return py__pad;
4202 }
4203
4204 static int py_AuthenticationInformation_set__pad(PyObject *py_obj, PyObject *value, void *closure)
4205 {
4206         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4207         object->_pad = data_blob_talloc(py_talloc_get_mem_ctx(py_obj), PyString_AsString(value), PyString_Size(value));
4208         return 0;
4209 }
4210
4211 static PyGetSetDef py_AuthenticationInformation_getsetters[] = {
4212         { discard_const_p(char, "LastUpdateTime"), py_AuthenticationInformation_get_LastUpdateTime, py_AuthenticationInformation_set_LastUpdateTime },
4213         { discard_const_p(char, "AuthType"), py_AuthenticationInformation_get_AuthType, py_AuthenticationInformation_set_AuthType },
4214         { discard_const_p(char, "AuthInfo"), py_AuthenticationInformation_get_AuthInfo, py_AuthenticationInformation_set_AuthInfo },
4215         { discard_const_p(char, "_pad"), py_AuthenticationInformation_get__pad, py_AuthenticationInformation_set__pad },
4216         { NULL }
4217 };
4218
4219 static PyObject *py_AuthenticationInformation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4220 {
4221         return py_talloc_new(struct AuthenticationInformation, type);
4222 }
4223
4224 static PyObject *py_AuthenticationInformation_ndr_pack(PyObject *py_obj)
4225 {
4226         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4227         DATA_BLOB blob;
4228         enum ndr_err_code err;
4229         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_AuthenticationInformation);
4230         if (err != NDR_ERR_SUCCESS) {
4231                 PyErr_SetNdrError(err);
4232                 return NULL;
4233         }
4234
4235         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4236 }
4237
4238 static PyObject *py_AuthenticationInformation_ndr_unpack(PyObject *py_obj, PyObject *args)
4239 {
4240         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4241         DATA_BLOB blob;
4242         enum ndr_err_code err;
4243         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
4244                 return NULL;
4245
4246         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_AuthenticationInformation);
4247         if (err != NDR_ERR_SUCCESS) {
4248                 PyErr_SetNdrError(err);
4249                 return NULL;
4250         }
4251
4252         Py_RETURN_NONE;
4253 }
4254
4255 static PyObject *py_AuthenticationInformation_ndr_print(PyObject *py_obj)
4256 {
4257         struct AuthenticationInformation *object = (struct AuthenticationInformation *)py_talloc_get_ptr(py_obj);
4258         char *retstr;
4259         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_AuthenticationInformation, "AuthenticationInformation", object);
4260         return PyString_FromString(retstr);
4261 }
4262
4263 static PyMethodDef py_AuthenticationInformation_methods[] = {
4264         { "__ndr_pack__", (PyCFunction)py_AuthenticationInformation_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4265         { "__ndr_unpack__", (PyCFunction)py_AuthenticationInformation_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
4266         { "__ndr_print__", (PyCFunction)py_AuthenticationInformation_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4267         { NULL, NULL, 0, NULL }
4268 };
4269
4270
4271 static PyTypeObject AuthenticationInformation_Type = {
4272         PyObject_HEAD_INIT(NULL) 0,
4273         .tp_name = "drsblobs.AuthenticationInformation",
4274         .tp_basicsize = sizeof(py_talloc_Object),
4275         .tp_dealloc = py_talloc_dealloc,
4276         .tp_getset = py_AuthenticationInformation_getsetters,
4277         .tp_repr = py_talloc_default_repr,
4278         .tp_methods = py_AuthenticationInformation_methods,
4279         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4280         .tp_new = py_AuthenticationInformation_new,
4281 };
4282
4283
4284 static PyObject *py_AuthenticationInformationArray_get_array(PyObject *obj, void *closure)
4285 {
4286         struct AuthenticationInformationArray *object = (struct AuthenticationInformationArray *)py_talloc_get_ptr(obj);
4287         PyObject *py_array;
4288         py_array = PyList_New(1);
4289         if (py_array == NULL) {
4290                 return NULL;
4291         }
4292         {
4293                 int array_cntr_0;
4294                 for (array_cntr_0 = 0; array_cntr_0 < 1; array_cntr_0++) {
4295                         PyObject *py_array_0;
4296                         py_array_0 = py_talloc_reference_ex(&AuthenticationInformation_Type, object->array, &object->array[array_cntr_0]);
4297                         PyList_SetItem(py_array, array_cntr_0, py_array_0);
4298                 }
4299         }
4300         return py_array;
4301 }
4302
4303 static int py_AuthenticationInformationArray_set_array(PyObject *py_obj, PyObject *value, void *closure)
4304 {
4305         struct AuthenticationInformationArray *object = (struct AuthenticationInformationArray *)py_talloc_get_ptr(py_obj);
4306         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4307         {
4308                 int array_cntr_0;
4309                 object->array = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->array, PyList_Size(value));
4310                 for (array_cntr_0 = 0; array_cntr_0 < PyList_Size(value); array_cntr_0++) {
4311                         PY_CHECK_TYPE(&AuthenticationInformation_Type, PyList_GetItem(value, array_cntr_0), return -1;);
4312                         memcpy(&object->array[array_cntr_0], (struct AuthenticationInformation *)py_talloc_get_ptr(PyList_GetItem(value, array_cntr_0)), sizeof(object->array[array_cntr_0]));
4313                 }
4314         }
4315         return 0;
4316 }
4317
4318 static PyGetSetDef py_AuthenticationInformationArray_getsetters[] = {
4319         { discard_const_p(char, "array"), py_AuthenticationInformationArray_get_array, py_AuthenticationInformationArray_set_array },
4320         { NULL }
4321 };
4322
4323 static PyObject *py_AuthenticationInformationArray_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4324 {
4325         return py_talloc_new(struct AuthenticationInformationArray, type);
4326 }
4327
4328
4329 static PyTypeObject AuthenticationInformationArray_Type = {
4330         PyObject_HEAD_INIT(NULL) 0,
4331         .tp_name = "drsblobs.AuthenticationInformationArray",
4332         .tp_basicsize = sizeof(py_talloc_Object),
4333         .tp_dealloc = py_talloc_dealloc,
4334         .tp_getset = py_AuthenticationInformationArray_getsetters,
4335         .tp_repr = py_talloc_default_repr,
4336         .tp_methods = NULL,
4337         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4338         .tp_new = py_AuthenticationInformationArray_new,
4339 };
4340
4341
4342 static PyObject *py_trustAuthInOutBlob_get_count(PyObject *obj, void *closure)
4343 {
4344         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(obj);
4345         PyObject *py_count;
4346         py_count = PyInt_FromLong(object->count);
4347         return py_count;
4348 }
4349
4350 static int py_trustAuthInOutBlob_set_count(PyObject *py_obj, PyObject *value, void *closure)
4351 {
4352         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4353         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4354         object->count = PyInt_AsLong(value);
4355         return 0;
4356 }
4357
4358 static PyObject *py_trustAuthInOutBlob_get_current(PyObject *obj, void *closure)
4359 {
4360         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(obj);
4361         PyObject *py_current;
4362         if (object->current == NULL) {
4363                 py_current = Py_None;
4364                 Py_INCREF(py_current);
4365         } else {
4366                 py_current = py_talloc_reference_ex(&AuthenticationInformationArray_Type, object->current, object->current);
4367         }
4368         return py_current;
4369 }
4370
4371 static int py_trustAuthInOutBlob_set_current(PyObject *py_obj, PyObject *value, void *closure)
4372 {
4373         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4374         talloc_free(object->current);
4375         if (value == Py_None) {
4376                 object->current = NULL;
4377         } else {
4378                 object->current = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->current);
4379                 PY_CHECK_TYPE(&AuthenticationInformationArray_Type, value, return -1;);
4380                 object->current = (struct AuthenticationInformationArray *)py_talloc_get_ptr(value);
4381         }
4382         return 0;
4383 }
4384
4385 static PyObject *py_trustAuthInOutBlob_get_previous(PyObject *obj, void *closure)
4386 {
4387         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(obj);
4388         PyObject *py_previous;
4389         if (object->previous == NULL) {
4390                 py_previous = Py_None;
4391                 Py_INCREF(py_previous);
4392         } else {
4393                 py_previous = py_talloc_reference_ex(&AuthenticationInformationArray_Type, object->previous, object->previous);
4394         }
4395         return py_previous;
4396 }
4397
4398 static int py_trustAuthInOutBlob_set_previous(PyObject *py_obj, PyObject *value, void *closure)
4399 {
4400         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4401         talloc_free(object->previous);
4402         if (value == Py_None) {
4403                 object->previous = NULL;
4404         } else {
4405                 object->previous = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->previous);
4406                 PY_CHECK_TYPE(&AuthenticationInformationArray_Type, value, return -1;);
4407                 object->previous = (struct AuthenticationInformationArray *)py_talloc_get_ptr(value);
4408         }
4409         return 0;
4410 }
4411
4412 static PyGetSetDef py_trustAuthInOutBlob_getsetters[] = {
4413         { discard_const_p(char, "count"), py_trustAuthInOutBlob_get_count, py_trustAuthInOutBlob_set_count },
4414         { discard_const_p(char, "current"), py_trustAuthInOutBlob_get_current, py_trustAuthInOutBlob_set_current },
4415         { discard_const_p(char, "previous"), py_trustAuthInOutBlob_get_previous, py_trustAuthInOutBlob_set_previous },
4416         { NULL }
4417 };
4418
4419 static PyObject *py_trustAuthInOutBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4420 {
4421         return py_talloc_new(struct trustAuthInOutBlob, type);
4422 }
4423
4424 static PyObject *py_trustAuthInOutBlob_ndr_pack(PyObject *py_obj)
4425 {
4426         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4427         DATA_BLOB blob;
4428         enum ndr_err_code err;
4429         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
4430         if (err != NDR_ERR_SUCCESS) {
4431                 PyErr_SetNdrError(err);
4432                 return NULL;
4433         }
4434
4435         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4436 }
4437
4438 static PyObject *py_trustAuthInOutBlob_ndr_unpack(PyObject *py_obj, PyObject *args)
4439 {
4440         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4441         DATA_BLOB blob;
4442         enum ndr_err_code err;
4443         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
4444                 return NULL;
4445
4446         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_trustAuthInOutBlob);
4447         if (err != NDR_ERR_SUCCESS) {
4448                 PyErr_SetNdrError(err);
4449                 return NULL;
4450         }
4451
4452         Py_RETURN_NONE;
4453 }
4454
4455 static PyObject *py_trustAuthInOutBlob_ndr_print(PyObject *py_obj)
4456 {
4457         struct trustAuthInOutBlob *object = (struct trustAuthInOutBlob *)py_talloc_get_ptr(py_obj);
4458         char *retstr;
4459         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_trustAuthInOutBlob, "trustAuthInOutBlob", object);
4460         return PyString_FromString(retstr);
4461 }
4462
4463 static PyMethodDef py_trustAuthInOutBlob_methods[] = {
4464         { "__ndr_pack__", (PyCFunction)py_trustAuthInOutBlob_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4465         { "__ndr_unpack__", (PyCFunction)py_trustAuthInOutBlob_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
4466         { "__ndr_print__", (PyCFunction)py_trustAuthInOutBlob_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4467         { NULL, NULL, 0, NULL }
4468 };
4469
4470
4471 static PyTypeObject trustAuthInOutBlob_Type = {
4472         PyObject_HEAD_INIT(NULL) 0,
4473         .tp_name = "drsblobs.trustAuthInOutBlob",
4474         .tp_basicsize = sizeof(py_talloc_Object),
4475         .tp_dealloc = py_talloc_dealloc,
4476         .tp_getset = py_trustAuthInOutBlob_getsetters,
4477         .tp_repr = py_talloc_default_repr,
4478         .tp_methods = py_trustAuthInOutBlob_methods,
4479         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4480         .tp_new = py_trustAuthInOutBlob_new,
4481 };
4482
4483
4484 static PyObject *py_trustCurrentPasswords_get_count(PyObject *obj, void *closure)
4485 {
4486         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(obj);
4487         PyObject *py_count;
4488         py_count = PyInt_FromLong(object->count);
4489         return py_count;
4490 }
4491
4492 static int py_trustCurrentPasswords_set_count(PyObject *py_obj, PyObject *value, void *closure)
4493 {
4494         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(py_obj);
4495         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4496         object->count = PyInt_AsLong(value);
4497         return 0;
4498 }
4499
4500 static PyObject *py_trustCurrentPasswords_get_current(PyObject *obj, void *closure)
4501 {
4502         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(obj);
4503         PyObject *py_current;
4504         py_current = PyList_New(object->count);
4505         if (py_current == NULL) {
4506                 return NULL;
4507         }
4508         {
4509                 int current_cntr_0;
4510                 for (current_cntr_0 = 0; current_cntr_0 < object->count; current_cntr_0++) {
4511                         PyObject *py_current_0;
4512                         if (object->current[current_cntr_0] == NULL) {
4513                                 py_current_0 = Py_None;
4514                                 Py_INCREF(py_current_0);
4515                         } else {
4516                                 py_current_0 = py_talloc_reference_ex(&AuthenticationInformation_Type, object->current[current_cntr_0], object->current[current_cntr_0]);
4517                         }
4518                         PyList_SetItem(py_current, current_cntr_0, py_current_0);
4519                 }
4520         }
4521         return py_current;
4522 }
4523
4524 static int py_trustCurrentPasswords_set_current(PyObject *py_obj, PyObject *value, void *closure)
4525 {
4526         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(py_obj);
4527         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4528         {
4529                 int current_cntr_0;
4530                 object->current = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->current, PyList_Size(value));
4531                 for (current_cntr_0 = 0; current_cntr_0 < PyList_Size(value); current_cntr_0++) {
4532                         if (PyList_GetItem(value, current_cntr_0) == Py_None) {
4533                                 object->current[current_cntr_0] = NULL;
4534                         } else {
4535                                 object->current[current_cntr_0] = talloc_ptrtype(object->current, object->current[current_cntr_0]);
4536                                 PY_CHECK_TYPE(&AuthenticationInformation_Type, PyList_GetItem(value, current_cntr_0), return -1;);
4537                                 object->current[current_cntr_0] = (struct AuthenticationInformation *)py_talloc_get_ptr(PyList_GetItem(value, current_cntr_0));
4538                         }
4539                 }
4540         }
4541         return 0;
4542 }
4543
4544 static PyGetSetDef py_trustCurrentPasswords_getsetters[] = {
4545         { discard_const_p(char, "count"), py_trustCurrentPasswords_get_count, py_trustCurrentPasswords_set_count },
4546         { discard_const_p(char, "current"), py_trustCurrentPasswords_get_current, py_trustCurrentPasswords_set_current },
4547         { NULL }
4548 };
4549
4550 static PyObject *py_trustCurrentPasswords_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4551 {
4552         return py_talloc_new(struct trustCurrentPasswords, type);
4553 }
4554
4555 static PyObject *py_trustCurrentPasswords_ndr_pack(PyObject *py_obj)
4556 {
4557         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(py_obj);
4558         DATA_BLOB blob;
4559         enum ndr_err_code err;
4560         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_trustCurrentPasswords);
4561         if (err != NDR_ERR_SUCCESS) {
4562                 PyErr_SetNdrError(err);
4563                 return NULL;
4564         }
4565
4566         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4567 }
4568
4569 static PyObject *py_trustCurrentPasswords_ndr_unpack(PyObject *py_obj, PyObject *args)
4570 {
4571         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(py_obj);
4572         DATA_BLOB blob;
4573         enum ndr_err_code err;
4574         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
4575                 return NULL;
4576
4577         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_trustCurrentPasswords);
4578         if (err != NDR_ERR_SUCCESS) {
4579                 PyErr_SetNdrError(err);
4580                 return NULL;
4581         }
4582
4583         Py_RETURN_NONE;
4584 }
4585
4586 static PyObject *py_trustCurrentPasswords_ndr_print(PyObject *py_obj)
4587 {
4588         struct trustCurrentPasswords *object = (struct trustCurrentPasswords *)py_talloc_get_ptr(py_obj);
4589         char *retstr;
4590         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_trustCurrentPasswords, "trustCurrentPasswords", object);
4591         return PyString_FromString(retstr);
4592 }
4593
4594 static PyMethodDef py_trustCurrentPasswords_methods[] = {
4595         { "__ndr_pack__", (PyCFunction)py_trustCurrentPasswords_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4596         { "__ndr_unpack__", (PyCFunction)py_trustCurrentPasswords_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
4597         { "__ndr_print__", (PyCFunction)py_trustCurrentPasswords_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4598         { NULL, NULL, 0, NULL }
4599 };
4600
4601
4602 static PyTypeObject trustCurrentPasswords_Type = {
4603         PyObject_HEAD_INIT(NULL) 0,
4604         .tp_name = "drsblobs.trustCurrentPasswords",
4605         .tp_basicsize = sizeof(py_talloc_Object),
4606         .tp_dealloc = py_talloc_dealloc,
4607         .tp_getset = py_trustCurrentPasswords_getsetters,
4608         .tp_repr = py_talloc_default_repr,
4609         .tp_methods = py_trustCurrentPasswords_methods,
4610         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4611         .tp_new = py_trustCurrentPasswords_new,
4612 };
4613
4614
4615 static PyObject *py_trustDomainPasswords_get_confounder(PyObject *obj, void *closure)
4616 {
4617         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(obj);
4618         PyObject *py_confounder;
4619         py_confounder = PyList_New(512);
4620         if (py_confounder == NULL) {
4621                 return NULL;
4622         }
4623         {
4624                 int confounder_cntr_0;
4625                 for (confounder_cntr_0 = 0; confounder_cntr_0 < 512; confounder_cntr_0++) {
4626                         PyObject *py_confounder_0;
4627                         py_confounder_0 = PyInt_FromLong(object->confounder[confounder_cntr_0]);
4628                         PyList_SetItem(py_confounder, confounder_cntr_0, py_confounder_0);
4629                 }
4630         }
4631         return py_confounder;
4632 }
4633
4634 static int py_trustDomainPasswords_set_confounder(PyObject *py_obj, PyObject *value, void *closure)
4635 {
4636         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4637         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
4638         {
4639                 int confounder_cntr_0;
4640                 for (confounder_cntr_0 = 0; confounder_cntr_0 < PyList_Size(value); confounder_cntr_0++) {
4641                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, confounder_cntr_0), return -1;);
4642                         object->confounder[confounder_cntr_0] = PyInt_AsLong(PyList_GetItem(value, confounder_cntr_0));
4643                 }
4644         }
4645         return 0;
4646 }
4647
4648 static PyObject *py_trustDomainPasswords_get_outgoing(PyObject *obj, void *closure)
4649 {
4650         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(obj);
4651         PyObject *py_outgoing;
4652         py_outgoing = py_talloc_reference_ex(&trustCurrentPasswords_Type, py_talloc_get_mem_ctx(obj), &object->outgoing);
4653         return py_outgoing;
4654 }
4655
4656 static int py_trustDomainPasswords_set_outgoing(PyObject *py_obj, PyObject *value, void *closure)
4657 {
4658         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4659         PY_CHECK_TYPE(&trustCurrentPasswords_Type, value, return -1;);
4660         memcpy(&object->outgoing, (struct trustCurrentPasswords *)py_talloc_get_ptr(value), sizeof(object->outgoing));
4661         return 0;
4662 }
4663
4664 static PyObject *py_trustDomainPasswords_get_incoming(PyObject *obj, void *closure)
4665 {
4666         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(obj);
4667         PyObject *py_incoming;
4668         py_incoming = py_talloc_reference_ex(&trustCurrentPasswords_Type, py_talloc_get_mem_ctx(obj), &object->incoming);
4669         return py_incoming;
4670 }
4671
4672 static int py_trustDomainPasswords_set_incoming(PyObject *py_obj, PyObject *value, void *closure)
4673 {
4674         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4675         PY_CHECK_TYPE(&trustCurrentPasswords_Type, value, return -1;);
4676         memcpy(&object->incoming, (struct trustCurrentPasswords *)py_talloc_get_ptr(value), sizeof(object->incoming));
4677         return 0;
4678 }
4679
4680 static PyObject *py_trustDomainPasswords_get_outgoing_size(PyObject *obj, void *closure)
4681 {
4682         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(obj);
4683         PyObject *py_outgoing_size;
4684         py_outgoing_size = PyInt_FromLong(object->outgoing_size);
4685         return py_outgoing_size;
4686 }
4687
4688 static int py_trustDomainPasswords_set_outgoing_size(PyObject *py_obj, PyObject *value, void *closure)
4689 {
4690         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4691         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4692         object->outgoing_size = PyInt_AsLong(value);
4693         return 0;
4694 }
4695
4696 static PyObject *py_trustDomainPasswords_get_incoming_size(PyObject *obj, void *closure)
4697 {
4698         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(obj);
4699         PyObject *py_incoming_size;
4700         py_incoming_size = PyInt_FromLong(object->incoming_size);
4701         return py_incoming_size;
4702 }
4703
4704 static int py_trustDomainPasswords_set_incoming_size(PyObject *py_obj, PyObject *value, void *closure)
4705 {
4706         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4707         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4708         object->incoming_size = PyInt_AsLong(value);
4709         return 0;
4710 }
4711
4712 static PyGetSetDef py_trustDomainPasswords_getsetters[] = {
4713         { discard_const_p(char, "confounder"), py_trustDomainPasswords_get_confounder, py_trustDomainPasswords_set_confounder },
4714         { discard_const_p(char, "outgoing"), py_trustDomainPasswords_get_outgoing, py_trustDomainPasswords_set_outgoing },
4715         { discard_const_p(char, "incoming"), py_trustDomainPasswords_get_incoming, py_trustDomainPasswords_set_incoming },
4716         { discard_const_p(char, "outgoing_size"), py_trustDomainPasswords_get_outgoing_size, py_trustDomainPasswords_set_outgoing_size },
4717         { discard_const_p(char, "incoming_size"), py_trustDomainPasswords_get_incoming_size, py_trustDomainPasswords_set_incoming_size },
4718         { NULL }
4719 };
4720
4721 static PyObject *py_trustDomainPasswords_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4722 {
4723         return py_talloc_new(struct trustDomainPasswords, type);
4724 }
4725
4726 static PyObject *py_trustDomainPasswords_ndr_pack(PyObject *py_obj)
4727 {
4728         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4729         DATA_BLOB blob;
4730         enum ndr_err_code err;
4731         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_trustDomainPasswords);
4732         if (err != NDR_ERR_SUCCESS) {
4733                 PyErr_SetNdrError(err);
4734                 return NULL;
4735         }
4736
4737         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4738 }
4739
4740 static PyObject *py_trustDomainPasswords_ndr_unpack(PyObject *py_obj, PyObject *args)
4741 {
4742         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4743         DATA_BLOB blob;
4744         enum ndr_err_code err;
4745         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
4746                 return NULL;
4747
4748         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_trustDomainPasswords);
4749         if (err != NDR_ERR_SUCCESS) {
4750                 PyErr_SetNdrError(err);
4751                 return NULL;
4752         }
4753
4754         Py_RETURN_NONE;
4755 }
4756
4757 static PyObject *py_trustDomainPasswords_ndr_print(PyObject *py_obj)
4758 {
4759         struct trustDomainPasswords *object = (struct trustDomainPasswords *)py_talloc_get_ptr(py_obj);
4760         char *retstr;
4761         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_trustDomainPasswords, "trustDomainPasswords", object);
4762         return PyString_FromString(retstr);
4763 }
4764
4765 static PyMethodDef py_trustDomainPasswords_methods[] = {
4766         { "__ndr_pack__", (PyCFunction)py_trustDomainPasswords_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4767         { "__ndr_unpack__", (PyCFunction)py_trustDomainPasswords_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
4768         { "__ndr_print__", (PyCFunction)py_trustDomainPasswords_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4769         { NULL, NULL, 0, NULL }
4770 };
4771
4772
4773 static PyTypeObject trustDomainPasswords_Type = {
4774         PyObject_HEAD_INIT(NULL) 0,
4775         .tp_name = "drsblobs.trustDomainPasswords",
4776         .tp_basicsize = sizeof(py_talloc_Object),
4777         .tp_dealloc = py_talloc_dealloc,
4778         .tp_getset = py_trustDomainPasswords_getsetters,
4779         .tp_repr = py_talloc_default_repr,
4780         .tp_methods = py_trustDomainPasswords_methods,
4781         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4782         .tp_new = py_trustDomainPasswords_new,
4783 };
4784
4785
4786 static PyObject *py_DsCompressedChunk_get_marker(PyObject *obj, void *closure)
4787 {
4788         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(obj);
4789         PyObject *py_marker;
4790         py_marker = PyInt_FromLong(object->marker);
4791         return py_marker;
4792 }
4793
4794 static int py_DsCompressedChunk_set_marker(PyObject *py_obj, PyObject *value, void *closure)
4795 {
4796         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(py_obj);
4797         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4798         object->marker = PyInt_AsLong(value);
4799         return 0;
4800 }
4801
4802 static PyObject *py_DsCompressedChunk_get_data(PyObject *obj, void *closure)
4803 {
4804         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(obj);
4805         PyObject *py_data;
4806         py_data = PyString_FromStringAndSize((char *)(object->data).data, (object->data).length);
4807         return py_data;
4808 }
4809
4810 static int py_DsCompressedChunk_set_data(PyObject *py_obj, PyObject *value, void *closure)
4811 {
4812         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(py_obj);
4813         object->data = data_blob_talloc(py_talloc_get_mem_ctx(py_obj), PyString_AsString(value), PyString_Size(value));
4814         return 0;
4815 }
4816
4817 static PyGetSetDef py_DsCompressedChunk_getsetters[] = {
4818         { discard_const_p(char, "marker"), py_DsCompressedChunk_get_marker, py_DsCompressedChunk_set_marker },
4819         { discard_const_p(char, "data"), py_DsCompressedChunk_get_data, py_DsCompressedChunk_set_data },
4820         { NULL }
4821 };
4822
4823 static PyObject *py_DsCompressedChunk_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4824 {
4825         return py_talloc_new(struct DsCompressedChunk, type);
4826 }
4827
4828 static PyObject *py_DsCompressedChunk_ndr_pack(PyObject *py_obj)
4829 {
4830         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(py_obj);
4831         DATA_BLOB blob;
4832         enum ndr_err_code err;
4833         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_DsCompressedChunk);
4834         if (err != NDR_ERR_SUCCESS) {
4835                 PyErr_SetNdrError(err);
4836                 return NULL;
4837         }
4838
4839         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4840 }
4841
4842 static PyObject *py_DsCompressedChunk_ndr_unpack(PyObject *py_obj, PyObject *args)
4843 {
4844         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(py_obj);
4845         DATA_BLOB blob;
4846         enum ndr_err_code err;
4847         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
4848                 return NULL;
4849
4850         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DsCompressedChunk);
4851         if (err != NDR_ERR_SUCCESS) {
4852                 PyErr_SetNdrError(err);
4853                 return NULL;
4854         }
4855
4856         Py_RETURN_NONE;
4857 }
4858
4859 static PyObject *py_DsCompressedChunk_ndr_print(PyObject *py_obj)
4860 {
4861         struct DsCompressedChunk *object = (struct DsCompressedChunk *)py_talloc_get_ptr(py_obj);
4862         char *retstr;
4863         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_DsCompressedChunk, "DsCompressedChunk", object);
4864         return PyString_FromString(retstr);
4865 }
4866
4867 static PyMethodDef py_DsCompressedChunk_methods[] = {
4868         { "__ndr_pack__", (PyCFunction)py_DsCompressedChunk_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4869         { "__ndr_unpack__", (PyCFunction)py_DsCompressedChunk_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
4870         { "__ndr_print__", (PyCFunction)py_DsCompressedChunk_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4871         { NULL, NULL, 0, NULL }
4872 };
4873
4874
4875 static PyTypeObject DsCompressedChunk_Type = {
4876         PyObject_HEAD_INIT(NULL) 0,
4877         .tp_name = "drsblobs.DsCompressedChunk",
4878         .tp_basicsize = sizeof(py_talloc_Object),
4879         .tp_dealloc = py_talloc_dealloc,
4880         .tp_getset = py_DsCompressedChunk_getsetters,
4881         .tp_repr = py_talloc_default_repr,
4882         .tp_methods = py_DsCompressedChunk_methods,
4883         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4884         .tp_new = py_DsCompressedChunk_new,
4885 };
4886
4887
4888 static PyObject *py_ExtendedErrorAString_get___size(PyObject *obj, void *closure)
4889 {
4890         struct ExtendedErrorAString *object = (struct ExtendedErrorAString *)py_talloc_get_ptr(obj);
4891         PyObject *py___size;
4892         py___size = PyInt_FromLong(object->__size);
4893         return py___size;
4894 }
4895
4896 static int py_ExtendedErrorAString_set___size(PyObject *py_obj, PyObject *value, void *closure)
4897 {
4898         struct ExtendedErrorAString *object = (struct ExtendedErrorAString *)py_talloc_get_ptr(py_obj);
4899         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4900         object->__size = PyInt_AsLong(value);
4901         return 0;
4902 }
4903
4904 static PyObject *py_ExtendedErrorAString_get_string(PyObject *obj, void *closure)
4905 {
4906         struct ExtendedErrorAString *object = (struct ExtendedErrorAString *)py_talloc_get_ptr(obj);
4907         PyObject *py_string;
4908         if (object->string == NULL) {
4909                 py_string = Py_None;
4910                 Py_INCREF(py_string);
4911         } else {
4912                 py_string = PyUnicode_Decode(object->string, strlen(object->string), "utf-8", "ignore");
4913         }
4914         return py_string;
4915 }
4916
4917 static int py_ExtendedErrorAString_set_string(PyObject *py_obj, PyObject *value, void *closure)
4918 {
4919         struct ExtendedErrorAString *object = (struct ExtendedErrorAString *)py_talloc_get_ptr(py_obj);
4920         if (value == Py_None) {
4921                 object->string = NULL;
4922         } else {
4923                 object->string = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->string);
4924                 PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
4925                 object->string = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4926         }
4927         return 0;
4928 }
4929
4930 static PyGetSetDef py_ExtendedErrorAString_getsetters[] = {
4931         { discard_const_p(char, "__size"), py_ExtendedErrorAString_get___size, py_ExtendedErrorAString_set___size },
4932         { discard_const_p(char, "string"), py_ExtendedErrorAString_get_string, py_ExtendedErrorAString_set_string },
4933         { NULL }
4934 };
4935
4936 static PyObject *py_ExtendedErrorAString_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4937 {
4938         return py_talloc_new(struct ExtendedErrorAString, type);
4939 }
4940
4941
4942 static PyTypeObject ExtendedErrorAString_Type = {
4943         PyObject_HEAD_INIT(NULL) 0,
4944         .tp_name = "drsblobs.ExtendedErrorAString",
4945         .tp_basicsize = sizeof(py_talloc_Object),
4946         .tp_dealloc = py_talloc_dealloc,
4947         .tp_getset = py_ExtendedErrorAString_getsetters,
4948         .tp_repr = py_talloc_default_repr,
4949         .tp_methods = NULL,
4950         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4951         .tp_new = py_ExtendedErrorAString_new,
4952 };
4953
4954
4955 static PyObject *py_ExtendedErrorUString_get___size(PyObject *obj, void *closure)
4956 {
4957         struct ExtendedErrorUString *object = (struct ExtendedErrorUString *)py_talloc_get_ptr(obj);
4958         PyObject *py___size;
4959         py___size = PyInt_FromLong(object->__size);
4960         return py___size;
4961 }
4962
4963 static int py_ExtendedErrorUString_set___size(PyObject *py_obj, PyObject *value, void *closure)
4964 {
4965         struct ExtendedErrorUString *object = (struct ExtendedErrorUString *)py_talloc_get_ptr(py_obj);
4966         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4967         object->__size = PyInt_AsLong(value);
4968         return 0;
4969 }
4970
4971 static PyObject *py_ExtendedErrorUString_get_string(PyObject *obj, void *closure)
4972 {
4973         struct ExtendedErrorUString *object = (struct ExtendedErrorUString *)py_talloc_get_ptr(obj);
4974         PyObject *py_string;
4975         if (object->string == NULL) {
4976                 py_string = Py_None;
4977                 Py_INCREF(py_string);
4978         } else {
4979                 py_string = PyUnicode_Decode(object->string, strlen(object->string), "utf-8", "ignore");
4980         }
4981         return py_string;
4982 }
4983
4984 static int py_ExtendedErrorUString_set_string(PyObject *py_obj, PyObject *value, void *closure)
4985 {
4986         struct ExtendedErrorUString *object = (struct ExtendedErrorUString *)py_talloc_get_ptr(py_obj);
4987         if (value == Py_None) {
4988                 object->string = NULL;
4989         } else {
4990                 object->string = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->string);
4991                 PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
4992                 object->string = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
4993         }
4994         return 0;
4995 }
4996
4997 static PyGetSetDef py_ExtendedErrorUString_getsetters[] = {
4998         { discard_const_p(char, "__size"), py_ExtendedErrorUString_get___size, py_ExtendedErrorUString_set___size },
4999         { discard_const_p(char, "string"), py_ExtendedErrorUString_get_string, py_ExtendedErrorUString_set_string },
5000         { NULL }
5001 };
5002
5003 static PyObject *py_ExtendedErrorUString_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5004 {
5005         return py_talloc_new(struct ExtendedErrorUString, type);
5006 }
5007
5008
5009 static PyTypeObject ExtendedErrorUString_Type = {
5010         PyObject_HEAD_INIT(NULL) 0,
5011         .tp_name = "drsblobs.ExtendedErrorUString",
5012         .tp_basicsize = sizeof(py_talloc_Object),
5013         .tp_dealloc = py_talloc_dealloc,
5014         .tp_getset = py_ExtendedErrorUString_getsetters,
5015         .tp_repr = py_talloc_default_repr,
5016         .tp_methods = NULL,
5017         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5018         .tp_new = py_ExtendedErrorUString_new,
5019 };
5020
5021
5022 static PyObject *py_ExtendedErrorBlob_get_length(PyObject *obj, void *closure)
5023 {
5024         struct ExtendedErrorBlob *object = (struct ExtendedErrorBlob *)py_talloc_get_ptr(obj);
5025         PyObject *py_length;
5026         py_length = PyInt_FromLong(object->length);
5027         return py_length;
5028 }
5029
5030 static int py_ExtendedErrorBlob_set_length(PyObject *py_obj, PyObject *value, void *closure)
5031 {
5032         struct ExtendedErrorBlob *object = (struct ExtendedErrorBlob *)py_talloc_get_ptr(py_obj);
5033         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5034         object->length = PyInt_AsLong(value);
5035         return 0;
5036 }
5037
5038 static PyObject *py_ExtendedErrorBlob_get_data(PyObject *obj, void *closure)
5039 {
5040         struct ExtendedErrorBlob *object = (struct ExtendedErrorBlob *)py_talloc_get_ptr(obj);
5041         PyObject *py_data;
5042         if (object->data == NULL) {
5043                 py_data = Py_None;
5044                 Py_INCREF(py_data);
5045         } else {
5046                 py_data = PyList_New(object->length);
5047                 if (py_data == NULL) {
5048                         return NULL;
5049                 }
5050                 {
5051                         int data_cntr_1;
5052                         for (data_cntr_1 = 0; data_cntr_1 < object->length; data_cntr_1++) {
5053                                 PyObject *py_data_1;
5054                                 py_data_1 = PyInt_FromLong(object->data[data_cntr_1]);
5055                                 PyList_SetItem(py_data, data_cntr_1, py_data_1);
5056                         }
5057                 }
5058         }
5059         return py_data;
5060 }
5061
5062 static int py_ExtendedErrorBlob_set_data(PyObject *py_obj, PyObject *value, void *closure)
5063 {
5064         struct ExtendedErrorBlob *object = (struct ExtendedErrorBlob *)py_talloc_get_ptr(py_obj);
5065         talloc_free(object->data);
5066         if (value == Py_None) {
5067                 object->data = NULL;
5068         } else {
5069                 object->data = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->data);
5070                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5071                 {
5072                         int data_cntr_1;
5073                         object->data = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->data, PyList_Size(value));
5074                         for (data_cntr_1 = 0; data_cntr_1 < PyList_Size(value); data_cntr_1++) {
5075                                 PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, data_cntr_1), return -1;);
5076                                 object->data[data_cntr_1] = PyInt_AsLong(PyList_GetItem(value, data_cntr_1));
5077                         }
5078                 }
5079         }
5080         return 0;
5081 }
5082
5083 static PyGetSetDef py_ExtendedErrorBlob_getsetters[] = {
5084         { discard_const_p(char, "length"), py_ExtendedErrorBlob_get_length, py_ExtendedErrorBlob_set_length },
5085         { discard_const_p(char, "data"), py_ExtendedErrorBlob_get_data, py_ExtendedErrorBlob_set_data },
5086         { NULL }
5087 };
5088
5089 static PyObject *py_ExtendedErrorBlob_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5090 {
5091         return py_talloc_new(struct ExtendedErrorBlob, type);
5092 }
5093
5094
5095 static PyTypeObject ExtendedErrorBlob_Type = {
5096         PyObject_HEAD_INIT(NULL) 0,
5097         .tp_name = "drsblobs.ExtendedErrorBlob",
5098         .tp_basicsize = sizeof(py_talloc_Object),
5099         .tp_dealloc = py_talloc_dealloc,
5100         .tp_getset = py_ExtendedErrorBlob_getsetters,
5101         .tp_repr = py_talloc_default_repr,
5102         .tp_methods = NULL,
5103         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5104         .tp_new = py_ExtendedErrorBlob_new,
5105 };
5106
5107 PyObject *py_import_ExtendedErrorComputerNameU(TALLOC_CTX *mem_ctx, int level, union ExtendedErrorComputerNameU *in)
5108 {
5109         PyObject *ret;
5110
5111         switch (level) {
5112                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
5113                         ret = py_talloc_reference_ex(&ExtendedErrorUString_Type, mem_ctx, &in->name);
5114                         return ret;
5115
5116                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
5117                         ret = Py_None;
5118                         Py_INCREF(ret);
5119                         return ret;
5120
5121         }
5122         PyErr_SetString(PyExc_TypeError, "unknown union level");
5123         return NULL;
5124 }
5125
5126 union ExtendedErrorComputerNameU *py_export_ExtendedErrorComputerNameU(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5127 {
5128         union ExtendedErrorComputerNameU *ret = talloc_zero(mem_ctx, union ExtendedErrorComputerNameU);
5129         switch (level) {
5130                 case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
5131                         PY_CHECK_TYPE(&ExtendedErrorUString_Type, in, talloc_free(ret); return NULL;);
5132                         memcpy(&ret->name, (struct ExtendedErrorUString *)py_talloc_get_ptr(in), sizeof(ret->name));
5133                         break;
5134
5135                 case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
5136                         break;
5137
5138                 default:
5139                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
5140                         talloc_free(ret);
5141                         ret = NULL;
5142         }
5143
5144         return ret;
5145 }
5146
5147
5148 static PyObject *py_ExtendedErrorComputerName_get_present(PyObject *obj, void *closure)
5149 {
5150         struct ExtendedErrorComputerName *object = (struct ExtendedErrorComputerName *)py_talloc_get_ptr(obj);
5151         PyObject *py_present;
5152         py_present = PyInt_FromLong(object->present);
5153         return py_present;
5154 }
5155
5156 static int py_ExtendedErrorComputerName_set_present(PyObject *py_obj, PyObject *value, void *closure)
5157 {
5158         struct ExtendedErrorComputerName *object = (struct ExtendedErrorComputerName *)py_talloc_get_ptr(py_obj);
5159         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5160         object->present = PyInt_AsLong(value);
5161         return 0;
5162 }
5163
5164 static PyObject *py_ExtendedErrorComputerName_get_n(PyObject *obj, void *closure)
5165 {
5166         struct ExtendedErrorComputerName *object = (struct ExtendedErrorComputerName *)py_talloc_get_ptr(obj);
5167         PyObject *py_n;
5168         py_n = py_import_ExtendedErrorComputerNameU(py_talloc_get_mem_ctx(obj), object->present, &object->n);
5169         if (py_n == NULL) {
5170                 return NULL;
5171         }
5172         return py_n;
5173 }
5174
5175 static int py_ExtendedErrorComputerName_set_n(PyObject *py_obj, PyObject *value, void *closure)
5176 {
5177         struct ExtendedErrorComputerName *object = (struct ExtendedErrorComputerName *)py_talloc_get_ptr(py_obj);
5178         {
5179                 void *n_switch_0;
5180                 n_switch_0 = py_export_ExtendedErrorComputerNameU(py_talloc_get_mem_ctx(py_obj), object->present, value);
5181                 if (n_switch_0 == NULL) { return -1; }
5182                 memcpy(&object->n, n_switch_0, sizeof(object->n));
5183         }
5184         return 0;
5185 }
5186
5187 static PyGetSetDef py_ExtendedErrorComputerName_getsetters[] = {
5188         { discard_const_p(char, "present"), py_ExtendedErrorComputerName_get_present, py_ExtendedErrorComputerName_set_present },
5189         { discard_const_p(char, "n"), py_ExtendedErrorComputerName_get_n, py_ExtendedErrorComputerName_set_n },
5190         { NULL }
5191 };
5192
5193 static PyObject *py_ExtendedErrorComputerName_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5194 {
5195         return py_talloc_new(struct ExtendedErrorComputerName, type);
5196 }
5197
5198
5199 static PyTypeObject ExtendedErrorComputerName_Type = {
5200         PyObject_HEAD_INIT(NULL) 0,
5201         .tp_name = "drsblobs.ExtendedErrorComputerName",
5202         .tp_basicsize = sizeof(py_talloc_Object),
5203         .tp_dealloc = py_talloc_dealloc,
5204         .tp_getset = py_ExtendedErrorComputerName_getsetters,
5205         .tp_repr = py_talloc_default_repr,
5206         .tp_methods = NULL,
5207         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5208         .tp_new = py_ExtendedErrorComputerName_new,
5209 };
5210
5211 PyObject *py_import_ExtendedErrorParamU(TALLOC_CTX *mem_ctx, int level, union ExtendedErrorParamU *in)
5212 {
5213         PyObject *ret;
5214
5215         switch (level) {
5216                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
5217                         ret = py_talloc_reference_ex(&ExtendedErrorAString_Type, mem_ctx, &in->a_string);
5218                         return ret;
5219
5220                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
5221                         ret = py_talloc_reference_ex(&ExtendedErrorUString_Type, mem_ctx, &in->u_string);
5222                         return ret;
5223
5224                 case EXTENDED_ERROR_PARAM_TYPE_UINT32:
5225                         ret = PyInt_FromLong(in->uint32);
5226                         return ret;
5227
5228                 case EXTENDED_ERROR_PARAM_TYPE_UINT16:
5229                         ret = PyInt_FromLong(in->uint16);
5230                         return ret;
5231
5232                 case EXTENDED_ERROR_PARAM_TYPE_UINT64:
5233                         ret = PyLong_FromLongLong(in->uint64);
5234                         return ret;
5235
5236                 case EXTENDED_ERROR_PARAM_TYPE_NONE:
5237                         ret = Py_None;
5238                         Py_INCREF(ret);
5239                         return ret;
5240
5241                 case EXTENDED_ERROR_PARAM_TYPE_BLOB:
5242                         ret = py_talloc_reference_ex(&ExtendedErrorBlob_Type, mem_ctx, &in->blob);
5243                         return ret;
5244
5245         }
5246         PyErr_SetString(PyExc_TypeError, "unknown union level");
5247         return NULL;
5248 }
5249
5250 union ExtendedErrorParamU *py_export_ExtendedErrorParamU(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5251 {
5252         union ExtendedErrorParamU *ret = talloc_zero(mem_ctx, union ExtendedErrorParamU);
5253         switch (level) {
5254                 case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
5255                         PY_CHECK_TYPE(&ExtendedErrorAString_Type, in, talloc_free(ret); return NULL;);
5256                         memcpy(&ret->a_string, (struct ExtendedErrorAString *)py_talloc_get_ptr(in), sizeof(ret->a_string));
5257                         break;
5258
5259                 case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
5260                         PY_CHECK_TYPE(&ExtendedErrorUString_Type, in, talloc_free(ret); return NULL;);
5261                         memcpy(&ret->u_string, (struct ExtendedErrorUString *)py_talloc_get_ptr(in), sizeof(ret->u_string));
5262                         break;
5263
5264                 case EXTENDED_ERROR_PARAM_TYPE_UINT32:
5265                         PY_CHECK_TYPE(&PyInt_Type, in, talloc_free(ret); return NULL;);
5266                         ret->uint32 = PyInt_AsLong(in);
5267                         break;
5268
5269                 case EXTENDED_ERROR_PARAM_TYPE_UINT16:
5270                         PY_CHECK_TYPE(&PyInt_Type, in, talloc_free(ret); return NULL;);
5271                         ret->uint16 = PyInt_AsLong(in);
5272                         break;
5273
5274                 case EXTENDED_ERROR_PARAM_TYPE_UINT64:
5275                         if (PyObject_TypeCheck(in, &PyLong_Type)) {
5276                                 ret->uint64 = PyLong_AsLongLong(in);
5277                         } else {
5278                                 if (PyObject_TypeCheck(in, &PyInt_Type)) {
5279                                         ret->uint64 = PyInt_AsLong(in);
5280                                 } else {
5281                                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5282                                           PyInt_Type.tp_name, PyLong_Type.tp_name);
5283                                         talloc_free(ret); return NULL;
5284                                 }
5285                         }
5286                         break;
5287
5288                 case EXTENDED_ERROR_PARAM_TYPE_NONE:
5289                         break;
5290
5291                 case EXTENDED_ERROR_PARAM_TYPE_BLOB:
5292                         PY_CHECK_TYPE(&ExtendedErrorBlob_Type, in, talloc_free(ret); return NULL;);
5293                         memcpy(&ret->blob, (struct ExtendedErrorBlob *)py_talloc_get_ptr(in), sizeof(ret->blob));
5294                         break;
5295
5296                 default:
5297                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
5298                         talloc_free(ret);
5299                         ret = NULL;
5300         }
5301
5302         return ret;
5303 }
5304
5305
5306 static PyObject *py_ExtendedErrorParam_get_type(PyObject *obj, void *closure)
5307 {
5308         struct ExtendedErrorParam *object = (struct ExtendedErrorParam *)py_talloc_get_ptr(obj);
5309         PyObject *py_type;
5310         py_type = PyInt_FromLong(object->type);
5311         return py_type;
5312 }
5313
5314 static int py_ExtendedErrorParam_set_type(PyObject *py_obj, PyObject *value, void *closure)
5315 {
5316         struct ExtendedErrorParam *object = (struct ExtendedErrorParam *)py_talloc_get_ptr(py_obj);
5317         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5318         object->type = PyInt_AsLong(value);
5319         return 0;
5320 }
5321
5322 static PyObject *py_ExtendedErrorParam_get_p(PyObject *obj, void *closure)
5323 {
5324         struct ExtendedErrorParam *object = (struct ExtendedErrorParam *)py_talloc_get_ptr(obj);
5325         PyObject *py_p;
5326         py_p = py_import_ExtendedErrorParamU(py_talloc_get_mem_ctx(obj), object->type, &object->p);
5327         if (py_p == NULL) {
5328                 return NULL;
5329         }
5330         return py_p;
5331 }
5332
5333 static int py_ExtendedErrorParam_set_p(PyObject *py_obj, PyObject *value, void *closure)
5334 {
5335         struct ExtendedErrorParam *object = (struct ExtendedErrorParam *)py_talloc_get_ptr(py_obj);
5336         {
5337                 void *p_switch_0;
5338                 p_switch_0 = py_export_ExtendedErrorParamU(py_talloc_get_mem_ctx(py_obj), object->type, value);
5339                 if (p_switch_0 == NULL) { return -1; }
5340                 memcpy(&object->p, p_switch_0, sizeof(object->p));
5341         }
5342         return 0;
5343 }
5344
5345 static PyGetSetDef py_ExtendedErrorParam_getsetters[] = {
5346         { discard_const_p(char, "type"), py_ExtendedErrorParam_get_type, py_ExtendedErrorParam_set_type },
5347         { discard_const_p(char, "p"), py_ExtendedErrorParam_get_p, py_ExtendedErrorParam_set_p },
5348         { NULL }
5349 };
5350
5351 static PyObject *py_ExtendedErrorParam_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5352 {
5353         return py_talloc_new(struct ExtendedErrorParam, type);
5354 }
5355
5356
5357 static PyTypeObject ExtendedErrorParam_Type = {
5358         PyObject_HEAD_INIT(NULL) 0,
5359         .tp_name = "drsblobs.ExtendedErrorParam",
5360         .tp_basicsize = sizeof(py_talloc_Object),
5361         .tp_dealloc = py_talloc_dealloc,
5362         .tp_getset = py_ExtendedErrorParam_getsetters,
5363         .tp_repr = py_talloc_default_repr,
5364         .tp_methods = NULL,
5365         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5366         .tp_new = py_ExtendedErrorParam_new,
5367 };
5368
5369
5370 static PyObject *py_ExtendedErrorInfo_get_next(PyObject *obj, void *closure)
5371 {
5372         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5373         PyObject *py_next;
5374         if (object->next == NULL) {
5375                 py_next = Py_None;
5376                 Py_INCREF(py_next);
5377         } else {
5378                 py_next = py_talloc_reference_ex(&ExtendedErrorInfo_Type, object->next, object->next);
5379         }
5380         return py_next;
5381 }
5382
5383 static int py_ExtendedErrorInfo_set_next(PyObject *py_obj, PyObject *value, void *closure)
5384 {
5385         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5386         talloc_free(object->next);
5387         if (value == Py_None) {
5388                 object->next = NULL;
5389         } else {
5390                 object->next = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->next);
5391                 PY_CHECK_TYPE(&ExtendedErrorInfo_Type, value, return -1;);
5392                 object->next = (struct ExtendedErrorInfo *)py_talloc_get_ptr(value);
5393         }
5394         return 0;
5395 }
5396
5397 static PyObject *py_ExtendedErrorInfo_get_computer_name(PyObject *obj, void *closure)
5398 {
5399         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5400         PyObject *py_computer_name;
5401         py_computer_name = py_talloc_reference_ex(&ExtendedErrorComputerName_Type, py_talloc_get_mem_ctx(obj), &object->computer_name);
5402         return py_computer_name;
5403 }
5404
5405 static int py_ExtendedErrorInfo_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
5406 {
5407         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5408         PY_CHECK_TYPE(&ExtendedErrorComputerName_Type, value, return -1;);
5409         memcpy(&object->computer_name, (struct ExtendedErrorComputerName *)py_talloc_get_ptr(value), sizeof(object->computer_name));
5410         return 0;
5411 }
5412
5413 static PyObject *py_ExtendedErrorInfo_get_pid(PyObject *obj, void *closure)
5414 {
5415         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5416         PyObject *py_pid;
5417         py_pid = PyLong_FromLongLong(object->pid);
5418         return py_pid;
5419 }
5420
5421 static int py_ExtendedErrorInfo_set_pid(PyObject *py_obj, PyObject *value, void *closure)
5422 {
5423         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5424         if (PyObject_TypeCheck(value, &PyLong_Type)) {
5425                 object->pid = PyLong_AsLongLong(value);
5426         } else {
5427                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
5428                         object->pid = PyInt_AsLong(value);
5429                 } else {
5430                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5431                           PyInt_Type.tp_name, PyLong_Type.tp_name);
5432                         return -1;
5433                 }
5434         }
5435         return 0;
5436 }
5437
5438 static PyObject *py_ExtendedErrorInfo_get_time(PyObject *obj, void *closure)
5439 {
5440         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5441         PyObject *py_time;
5442         py_time = PyLong_FromLongLong(object->time);
5443         return py_time;
5444 }
5445
5446 static int py_ExtendedErrorInfo_set_time(PyObject *py_obj, PyObject *value, void *closure)
5447 {
5448         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5449         if (PyObject_TypeCheck(value, &PyLong_Type)) {
5450                 object->time = PyLong_AsLongLong(value);
5451         } else {
5452                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
5453                         object->time = PyInt_AsLong(value);
5454                 } else {
5455                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5456                           PyInt_Type.tp_name, PyLong_Type.tp_name);
5457                         return -1;
5458                 }
5459         }
5460         return 0;
5461 }
5462
5463 static PyObject *py_ExtendedErrorInfo_get_generating_component(PyObject *obj, void *closure)
5464 {
5465         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5466         PyObject *py_generating_component;
5467         py_generating_component = PyInt_FromLong(object->generating_component);
5468         return py_generating_component;
5469 }
5470
5471 static int py_ExtendedErrorInfo_set_generating_component(PyObject *py_obj, PyObject *value, void *closure)
5472 {
5473         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5474         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5475         object->generating_component = PyInt_AsLong(value);
5476         return 0;
5477 }
5478
5479 static PyObject *py_ExtendedErrorInfo_get_status(PyObject *obj, void *closure)
5480 {
5481         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5482         PyObject *py_status;
5483         py_status = PyErr_FromWERROR(object->status);
5484         return py_status;
5485 }
5486
5487 static int py_ExtendedErrorInfo_set_status(PyObject *py_obj, PyObject *value, void *closure)
5488 {
5489         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5490         object->status = W_ERROR(PyInt_AsLong(value));
5491         return 0;
5492 }
5493
5494 static PyObject *py_ExtendedErrorInfo_get_detection_location(PyObject *obj, void *closure)
5495 {
5496         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5497         PyObject *py_detection_location;
5498         py_detection_location = PyInt_FromLong(object->detection_location);
5499         return py_detection_location;
5500 }
5501
5502 static int py_ExtendedErrorInfo_set_detection_location(PyObject *py_obj, PyObject *value, void *closure)
5503 {
5504         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5505         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5506         object->detection_location = PyInt_AsLong(value);
5507         return 0;
5508 }
5509
5510 static PyObject *py_ExtendedErrorInfo_get_flags(PyObject *obj, void *closure)
5511 {
5512         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5513         PyObject *py_flags;
5514         py_flags = PyInt_FromLong(object->flags);
5515         return py_flags;
5516 }
5517
5518 static int py_ExtendedErrorInfo_set_flags(PyObject *py_obj, PyObject *value, void *closure)
5519 {
5520         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5521         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5522         object->flags = PyInt_AsLong(value);
5523         return 0;
5524 }
5525
5526 static PyObject *py_ExtendedErrorInfo_get_num_params(PyObject *obj, void *closure)
5527 {
5528         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5529         PyObject *py_num_params;
5530         py_num_params = PyInt_FromLong(object->num_params);
5531         return py_num_params;
5532 }
5533
5534 static int py_ExtendedErrorInfo_set_num_params(PyObject *py_obj, PyObject *value, void *closure)
5535 {
5536         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5537         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5538         object->num_params = PyInt_AsLong(value);
5539         return 0;
5540 }
5541
5542 static PyObject *py_ExtendedErrorInfo_get_params(PyObject *obj, void *closure)
5543 {
5544         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(obj);
5545         PyObject *py_params;
5546         py_params = PyList_New(object->num_params);
5547         if (py_params == NULL) {
5548                 return NULL;
5549         }
5550         {
5551                 int params_cntr_0;
5552                 for (params_cntr_0 = 0; params_cntr_0 < object->num_params; params_cntr_0++) {
5553                         PyObject *py_params_0;
5554                         py_params_0 = py_talloc_reference_ex(&ExtendedErrorParam_Type, object->params, &object->params[params_cntr_0]);
5555                         PyList_SetItem(py_params, params_cntr_0, py_params_0);
5556                 }
5557         }
5558         return py_params;
5559 }
5560
5561 static int py_ExtendedErrorInfo_set_params(PyObject *py_obj, PyObject *value, void *closure)
5562 {
5563         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5564         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5565         {
5566                 int params_cntr_0;
5567                 object->params = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->params, PyList_Size(value));
5568                 for (params_cntr_0 = 0; params_cntr_0 < PyList_Size(value); params_cntr_0++) {
5569                         PY_CHECK_TYPE(&ExtendedErrorParam_Type, PyList_GetItem(value, params_cntr_0), return -1;);
5570                         memcpy(&object->params[params_cntr_0], (struct ExtendedErrorParam *)py_talloc_get_ptr(PyList_GetItem(value, params_cntr_0)), sizeof(object->params[params_cntr_0]));
5571                 }
5572         }
5573         return 0;
5574 }
5575
5576 static PyGetSetDef py_ExtendedErrorInfo_getsetters[] = {
5577         { discard_const_p(char, "next"), py_ExtendedErrorInfo_get_next, py_ExtendedErrorInfo_set_next },
5578         { discard_const_p(char, "computer_name"), py_ExtendedErrorInfo_get_computer_name, py_ExtendedErrorInfo_set_computer_name },
5579         { discard_const_p(char, "pid"), py_ExtendedErrorInfo_get_pid, py_ExtendedErrorInfo_set_pid },
5580         { discard_const_p(char, "time"), py_ExtendedErrorInfo_get_time, py_ExtendedErrorInfo_set_time },
5581         { discard_const_p(char, "generating_component"), py_ExtendedErrorInfo_get_generating_component, py_ExtendedErrorInfo_set_generating_component },
5582         { discard_const_p(char, "status"), py_ExtendedErrorInfo_get_status, py_ExtendedErrorInfo_set_status },
5583         { discard_const_p(char, "detection_location"), py_ExtendedErrorInfo_get_detection_location, py_ExtendedErrorInfo_set_detection_location },
5584         { discard_const_p(char, "flags"), py_ExtendedErrorInfo_get_flags, py_ExtendedErrorInfo_set_flags },
5585         { discard_const_p(char, "num_params"), py_ExtendedErrorInfo_get_num_params, py_ExtendedErrorInfo_set_num_params },
5586         { discard_const_p(char, "params"), py_ExtendedErrorInfo_get_params, py_ExtendedErrorInfo_set_params },
5587         { NULL }
5588 };
5589
5590 static PyObject *py_ExtendedErrorInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5591 {
5592         return py_talloc_new(struct ExtendedErrorInfo, type);
5593 }
5594
5595 static PyObject *py_ExtendedErrorInfo_ndr_pack(PyObject *py_obj)
5596 {
5597         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5598         DATA_BLOB blob;
5599         enum ndr_err_code err;
5600         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ExtendedErrorInfo);
5601         if (err != NDR_ERR_SUCCESS) {
5602                 PyErr_SetNdrError(err);
5603                 return NULL;
5604         }
5605
5606         return PyString_FromStringAndSize((char *)blob.data, blob.length);
5607 }
5608
5609 static PyObject *py_ExtendedErrorInfo_ndr_unpack(PyObject *py_obj, PyObject *args)
5610 {
5611         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5612         DATA_BLOB blob;
5613         enum ndr_err_code err;
5614         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
5615                 return NULL;
5616
5617         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ExtendedErrorInfo);
5618         if (err != NDR_ERR_SUCCESS) {
5619                 PyErr_SetNdrError(err);
5620                 return NULL;
5621         }
5622
5623         Py_RETURN_NONE;
5624 }
5625
5626 static PyObject *py_ExtendedErrorInfo_ndr_print(PyObject *py_obj)
5627 {
5628         struct ExtendedErrorInfo *object = (struct ExtendedErrorInfo *)py_talloc_get_ptr(py_obj);
5629         char *retstr;
5630         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ExtendedErrorInfo, "ExtendedErrorInfo", object);
5631         return PyString_FromString(retstr);
5632 }
5633
5634 static PyMethodDef py_ExtendedErrorInfo_methods[] = {
5635         { "__ndr_pack__", (PyCFunction)py_ExtendedErrorInfo_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
5636         { "__ndr_unpack__", (PyCFunction)py_ExtendedErrorInfo_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
5637         { "__ndr_print__", (PyCFunction)py_ExtendedErrorInfo_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
5638         { NULL, NULL, 0, NULL }
5639 };
5640
5641
5642 static PyTypeObject ExtendedErrorInfo_Type = {
5643         PyObject_HEAD_INIT(NULL) 0,
5644         .tp_name = "drsblobs.ExtendedErrorInfo",
5645         .tp_basicsize = sizeof(py_talloc_Object),
5646         .tp_dealloc = py_talloc_dealloc,
5647         .tp_getset = py_ExtendedErrorInfo_getsetters,
5648         .tp_repr = py_talloc_default_repr,
5649         .tp_methods = py_ExtendedErrorInfo_methods,
5650         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5651         .tp_new = py_ExtendedErrorInfo_new,
5652 };
5653
5654
5655 static PyObject *py_ExtendedErrorInfoPtr_get_info(PyObject *obj, void *closure)
5656 {
5657         struct ExtendedErrorInfoPtr *object = (struct ExtendedErrorInfoPtr *)py_talloc_get_ptr(obj);
5658         PyObject *py_info;
5659         if (object->info == NULL) {
5660                 py_info = Py_None;
5661                 Py_INCREF(py_info);
5662         } else {
5663                 py_info = py_talloc_reference_ex(&ExtendedErrorInfo_Type, object->info, object->info);
5664         }
5665         return py_info;
5666 }
5667
5668 static int py_ExtendedErrorInfoPtr_set_info(PyObject *py_obj, PyObject *value, void *closure)
5669 {
5670         struct ExtendedErrorInfoPtr *object = (struct ExtendedErrorInfoPtr *)py_talloc_get_ptr(py_obj);
5671         talloc_free(object->info);
5672         if (value == Py_None) {
5673                 object->info = NULL;
5674         } else {
5675                 object->info = talloc_ptrtype(py_talloc_get_mem_ctx(py_obj), object->info);
5676                 PY_CHECK_TYPE(&ExtendedErrorInfo_Type, value, return -1;);
5677                 object->info = (struct ExtendedErrorInfo *)py_talloc_get_ptr(value);
5678         }
5679         return 0;
5680 }
5681
5682 static PyGetSetDef py_ExtendedErrorInfoPtr_getsetters[] = {
5683         { discard_const_p(char, "info"), py_ExtendedErrorInfoPtr_get_info, py_ExtendedErrorInfoPtr_set_info },
5684         { NULL }
5685 };
5686
5687 static PyObject *py_ExtendedErrorInfoPtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5688 {
5689         return py_talloc_new(struct ExtendedErrorInfoPtr, type);
5690 }
5691
5692
5693 static PyTypeObject ExtendedErrorInfoPtr_Type = {
5694         PyObject_HEAD_INIT(NULL) 0,
5695         .tp_name = "drsblobs.ExtendedErrorInfoPtr",
5696         .tp_basicsize = sizeof(py_talloc_Object),
5697         .tp_dealloc = py_talloc_dealloc,
5698         .tp_getset = py_ExtendedErrorInfoPtr_getsetters,
5699         .tp_repr = py_talloc_default_repr,
5700         .tp_methods = NULL,
5701         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5702         .tp_new = py_ExtendedErrorInfoPtr_new,
5703 };
5704
5705
5706 static PyObject *py_ForestTrustString_get_size(PyObject *obj, void *closure)
5707 {
5708         struct ForestTrustString *object = (struct ForestTrustString *)py_talloc_get_ptr(obj);
5709         PyObject *py_size;
5710         py_size = PyInt_FromLong(object->size);
5711         return py_size;
5712 }
5713
5714 static int py_ForestTrustString_set_size(PyObject *py_obj, PyObject *value, void *closure)
5715 {
5716         struct ForestTrustString *object = (struct ForestTrustString *)py_talloc_get_ptr(py_obj);
5717         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5718         object->size = PyInt_AsLong(value);
5719         return 0;
5720 }
5721
5722 static PyObject *py_ForestTrustString_get_string(PyObject *obj, void *closure)
5723 {
5724         struct ForestTrustString *object = (struct ForestTrustString *)py_talloc_get_ptr(obj);
5725         PyObject *py_string;
5726         py_string = PyUnicode_Decode(object->string, strlen(object->string), "utf-8", "ignore");
5727         return py_string;
5728 }
5729
5730 static int py_ForestTrustString_set_string(PyObject *py_obj, PyObject *value, void *closure)
5731 {
5732         struct ForestTrustString *object = (struct ForestTrustString *)py_talloc_get_ptr(py_obj);
5733         PY_CHECK_TYPE(&PyUnicode_Type, value, return -1;);
5734         object->string = PyString_AsString(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5735         return 0;
5736 }
5737
5738 static PyGetSetDef py_ForestTrustString_getsetters[] = {
5739         { discard_const_p(char, "size"), py_ForestTrustString_get_size, py_ForestTrustString_set_size },
5740         { discard_const_p(char, "string"), py_ForestTrustString_get_string, py_ForestTrustString_set_string },
5741         { NULL }
5742 };
5743
5744 static PyObject *py_ForestTrustString_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5745 {
5746         return py_talloc_new(struct ForestTrustString, type);
5747 }
5748
5749
5750 static PyTypeObject ForestTrustString_Type = {
5751         PyObject_HEAD_INIT(NULL) 0,
5752         .tp_name = "drsblobs.ForestTrustString",
5753         .tp_basicsize = sizeof(py_talloc_Object),
5754         .tp_dealloc = py_talloc_dealloc,
5755         .tp_getset = py_ForestTrustString_getsetters,
5756         .tp_repr = py_talloc_default_repr,
5757         .tp_methods = NULL,
5758         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5759         .tp_new = py_ForestTrustString_new,
5760 };
5761
5762
5763 static PyObject *py_ForestTrustDataDomainInfo_get_sid_size(PyObject *obj, void *closure)
5764 {
5765         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(obj);
5766         PyObject *py_sid_size;
5767         py_sid_size = PyInt_FromLong(object->sid_size);
5768         return py_sid_size;
5769 }
5770
5771 static int py_ForestTrustDataDomainInfo_set_sid_size(PyObject *py_obj, PyObject *value, void *closure)
5772 {
5773         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(py_obj);
5774         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5775         object->sid_size = PyInt_AsLong(value);
5776         return 0;
5777 }
5778
5779 static PyObject *py_ForestTrustDataDomainInfo_get_sid(PyObject *obj, void *closure)
5780 {
5781         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(obj);
5782         PyObject *py_sid;
5783         py_sid = py_talloc_reference_ex(dom_sid_Type, py_talloc_get_mem_ctx(obj), &object->sid);
5784         return py_sid;
5785 }
5786
5787 static int py_ForestTrustDataDomainInfo_set_sid(PyObject *py_obj, PyObject *value, void *closure)
5788 {
5789         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(py_obj);
5790         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
5791         memcpy(&object->sid, (struct dom_sid *)py_talloc_get_ptr(value), sizeof(object->sid));
5792         return 0;
5793 }
5794
5795 static PyObject *py_ForestTrustDataDomainInfo_get_dns_name(PyObject *obj, void *closure)
5796 {
5797         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(obj);
5798         PyObject *py_dns_name;
5799         py_dns_name = py_talloc_reference_ex(&ForestTrustString_Type, py_talloc_get_mem_ctx(obj), &object->dns_name);
5800         return py_dns_name;
5801 }
5802
5803 static int py_ForestTrustDataDomainInfo_set_dns_name(PyObject *py_obj, PyObject *value, void *closure)
5804 {
5805         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(py_obj);
5806         PY_CHECK_TYPE(&ForestTrustString_Type, value, return -1;);
5807         memcpy(&object->dns_name, (struct ForestTrustString *)py_talloc_get_ptr(value), sizeof(object->dns_name));
5808         return 0;
5809 }
5810
5811 static PyObject *py_ForestTrustDataDomainInfo_get_netbios_name(PyObject *obj, void *closure)
5812 {
5813         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(obj);
5814         PyObject *py_netbios_name;
5815         py_netbios_name = py_talloc_reference_ex(&ForestTrustString_Type, py_talloc_get_mem_ctx(obj), &object->netbios_name);
5816         return py_netbios_name;
5817 }
5818
5819 static int py_ForestTrustDataDomainInfo_set_netbios_name(PyObject *py_obj, PyObject *value, void *closure)
5820 {
5821         struct ForestTrustDataDomainInfo *object = (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(py_obj);
5822         PY_CHECK_TYPE(&ForestTrustString_Type, value, return -1;);
5823         memcpy(&object->netbios_name, (struct ForestTrustString *)py_talloc_get_ptr(value), sizeof(object->netbios_name));
5824         return 0;
5825 }
5826
5827 static PyGetSetDef py_ForestTrustDataDomainInfo_getsetters[] = {
5828         { discard_const_p(char, "sid_size"), py_ForestTrustDataDomainInfo_get_sid_size, py_ForestTrustDataDomainInfo_set_sid_size },
5829         { discard_const_p(char, "sid"), py_ForestTrustDataDomainInfo_get_sid, py_ForestTrustDataDomainInfo_set_sid },
5830         { discard_const_p(char, "dns_name"), py_ForestTrustDataDomainInfo_get_dns_name, py_ForestTrustDataDomainInfo_set_dns_name },
5831         { discard_const_p(char, "netbios_name"), py_ForestTrustDataDomainInfo_get_netbios_name, py_ForestTrustDataDomainInfo_set_netbios_name },
5832         { NULL }
5833 };
5834
5835 static PyObject *py_ForestTrustDataDomainInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5836 {
5837         return py_talloc_new(struct ForestTrustDataDomainInfo, type);
5838 }
5839
5840
5841 static PyTypeObject ForestTrustDataDomainInfo_Type = {
5842         PyObject_HEAD_INIT(NULL) 0,
5843         .tp_name = "drsblobs.ForestTrustDataDomainInfo",
5844         .tp_basicsize = sizeof(py_talloc_Object),
5845         .tp_dealloc = py_talloc_dealloc,
5846         .tp_getset = py_ForestTrustDataDomainInfo_getsetters,
5847         .tp_repr = py_talloc_default_repr,
5848         .tp_methods = NULL,
5849         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5850         .tp_new = py_ForestTrustDataDomainInfo_new,
5851 };
5852
5853
5854 static PyObject *py_ForestTrustDataBinaryData_get_size(PyObject *obj, void *closure)
5855 {
5856         struct ForestTrustDataBinaryData *object = (struct ForestTrustDataBinaryData *)py_talloc_get_ptr(obj);
5857         PyObject *py_size;
5858         py_size = PyInt_FromLong(object->size);
5859         return py_size;
5860 }
5861
5862 static int py_ForestTrustDataBinaryData_set_size(PyObject *py_obj, PyObject *value, void *closure)
5863 {
5864         struct ForestTrustDataBinaryData *object = (struct ForestTrustDataBinaryData *)py_talloc_get_ptr(py_obj);
5865         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5866         object->size = PyInt_AsLong(value);
5867         return 0;
5868 }
5869
5870 static PyObject *py_ForestTrustDataBinaryData_get_data(PyObject *obj, void *closure)
5871 {
5872         struct ForestTrustDataBinaryData *object = (struct ForestTrustDataBinaryData *)py_talloc_get_ptr(obj);
5873         PyObject *py_data;
5874         py_data = PyList_New(object->size);
5875         if (py_data == NULL) {
5876                 return NULL;
5877         }
5878         {
5879                 int data_cntr_0;
5880                 for (data_cntr_0 = 0; data_cntr_0 < object->size; data_cntr_0++) {
5881                         PyObject *py_data_0;
5882                         py_data_0 = PyInt_FromLong(object->data[data_cntr_0]);
5883                         PyList_SetItem(py_data, data_cntr_0, py_data_0);
5884                 }
5885         }
5886         return py_data;
5887 }
5888
5889 static int py_ForestTrustDataBinaryData_set_data(PyObject *py_obj, PyObject *value, void *closure)
5890 {
5891         struct ForestTrustDataBinaryData *object = (struct ForestTrustDataBinaryData *)py_talloc_get_ptr(py_obj);
5892         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5893         {
5894                 int data_cntr_0;
5895                 object->data = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->data, PyList_Size(value));
5896                 for (data_cntr_0 = 0; data_cntr_0 < PyList_Size(value); data_cntr_0++) {
5897                         PY_CHECK_TYPE(&PyInt_Type, PyList_GetItem(value, data_cntr_0), return -1;);
5898                         object->data[data_cntr_0] = PyInt_AsLong(PyList_GetItem(value, data_cntr_0));
5899                 }
5900         }
5901         return 0;
5902 }
5903
5904 static PyGetSetDef py_ForestTrustDataBinaryData_getsetters[] = {
5905         { discard_const_p(char, "size"), py_ForestTrustDataBinaryData_get_size, py_ForestTrustDataBinaryData_set_size },
5906         { discard_const_p(char, "data"), py_ForestTrustDataBinaryData_get_data, py_ForestTrustDataBinaryData_set_data },
5907         { NULL }
5908 };
5909
5910 static PyObject *py_ForestTrustDataBinaryData_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5911 {
5912         return py_talloc_new(struct ForestTrustDataBinaryData, type);
5913 }
5914
5915
5916 static PyTypeObject ForestTrustDataBinaryData_Type = {
5917         PyObject_HEAD_INIT(NULL) 0,
5918         .tp_name = "drsblobs.ForestTrustDataBinaryData",
5919         .tp_basicsize = sizeof(py_talloc_Object),
5920         .tp_dealloc = py_talloc_dealloc,
5921         .tp_getset = py_ForestTrustDataBinaryData_getsetters,
5922         .tp_repr = py_talloc_default_repr,
5923         .tp_methods = NULL,
5924         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5925         .tp_new = py_ForestTrustDataBinaryData_new,
5926 };
5927
5928 PyObject *py_import_ForestTrustData(TALLOC_CTX *mem_ctx, int level, union ForestTrustData *in)
5929 {
5930         PyObject *ret;
5931
5932         switch (level) {
5933                 case FOREST_TRUST_TOP_LEVEL_NAME:
5934                         ret = py_talloc_reference_ex(&ForestTrustString_Type, mem_ctx, &in->name);
5935                         return ret;
5936
5937                 case FOREST_TRUST_TOP_LEVEL_NAME_EX:
5938                         ret = py_talloc_reference_ex(&ForestTrustString_Type, mem_ctx, &in->name);
5939                         return ret;
5940
5941                 case FOREST_TRUST_DOMAIN_INFO:
5942                         ret = py_talloc_reference_ex(&ForestTrustDataDomainInfo_Type, mem_ctx, &in->info);
5943                         return ret;
5944
5945                 default:
5946                         ret = py_talloc_reference_ex(&ForestTrustDataBinaryData_Type, mem_ctx, &in->data);
5947                         return ret;
5948
5949         }
5950         PyErr_SetString(PyExc_TypeError, "unknown union level");
5951         return NULL;
5952 }
5953
5954 union ForestTrustData *py_export_ForestTrustData(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5955 {
5956         union ForestTrustData *ret = talloc_zero(mem_ctx, union ForestTrustData);
5957         switch (level) {
5958                 case FOREST_TRUST_TOP_LEVEL_NAME:
5959                         PY_CHECK_TYPE(&ForestTrustString_Type, in, talloc_free(ret); return NULL;);
5960                         memcpy(&ret->name, (struct ForestTrustString *)py_talloc_get_ptr(in), sizeof(ret->name));
5961                         break;
5962
5963                 case FOREST_TRUST_TOP_LEVEL_NAME_EX:
5964                         PY_CHECK_TYPE(&ForestTrustString_Type, in, talloc_free(ret); return NULL;);
5965                         memcpy(&ret->name, (struct ForestTrustString *)py_talloc_get_ptr(in), sizeof(ret->name));
5966                         break;
5967
5968                 case FOREST_TRUST_DOMAIN_INFO:
5969                         PY_CHECK_TYPE(&ForestTrustDataDomainInfo_Type, in, talloc_free(ret); return NULL;);
5970                         memcpy(&ret->info, (struct ForestTrustDataDomainInfo *)py_talloc_get_ptr(in), sizeof(ret->info));
5971                         break;
5972
5973                 default:
5974                         PY_CHECK_TYPE(&ForestTrustDataBinaryData_Type, in, talloc_free(ret); return NULL;);
5975                         memcpy(&ret->data, (struct ForestTrustDataBinaryData *)py_talloc_get_ptr(in), sizeof(ret->data));
5976                         break;
5977
5978         }
5979
5980         return ret;
5981 }
5982
5983
5984 static PyObject *py_ForestTrustInfoRecord_get_flags(PyObject *obj, void *closure)
5985 {
5986         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(obj);
5987         PyObject *py_flags;
5988         py_flags = PyInt_FromLong(object->flags);
5989         return py_flags;
5990 }
5991
5992 static int py_ForestTrustInfoRecord_set_flags(PyObject *py_obj, PyObject *value, void *closure)
5993 {
5994         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
5995         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5996         object->flags = PyInt_AsLong(value);
5997         return 0;
5998 }
5999
6000 static PyObject *py_ForestTrustInfoRecord_get_timestamp(PyObject *obj, void *closure)
6001 {
6002         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(obj);
6003         PyObject *py_timestamp;
6004         py_timestamp = PyLong_FromLongLong(object->timestamp);
6005         return py_timestamp;
6006 }
6007
6008 static int py_ForestTrustInfoRecord_set_timestamp(PyObject *py_obj, PyObject *value, void *closure)
6009 {
6010         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6011         if (PyObject_TypeCheck(value, &PyLong_Type)) {
6012                 object->timestamp = PyLong_AsLongLong(value);
6013         } else {
6014                 if (PyObject_TypeCheck(value, &PyInt_Type)) {
6015                         object->timestamp = PyInt_AsLong(value);
6016                 } else {
6017                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6018                           PyInt_Type.tp_name, PyLong_Type.tp_name);
6019                         return -1;
6020                 }
6021         }
6022         return 0;
6023 }
6024
6025 static PyObject *py_ForestTrustInfoRecord_get_type(PyObject *obj, void *closure)
6026 {
6027         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(obj);
6028         PyObject *py_type;
6029         py_type = PyInt_FromLong(object->type);
6030         return py_type;
6031 }
6032
6033 static int py_ForestTrustInfoRecord_set_type(PyObject *py_obj, PyObject *value, void *closure)
6034 {
6035         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6036         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6037         object->type = PyInt_AsLong(value);
6038         return 0;
6039 }
6040
6041 static PyObject *py_ForestTrustInfoRecord_get_data(PyObject *obj, void *closure)
6042 {
6043         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(obj);
6044         PyObject *py_data;
6045         py_data = py_import_ForestTrustData(py_talloc_get_mem_ctx(obj), object->type, &object->data);
6046         if (py_data == NULL) {
6047                 return NULL;
6048         }
6049         return py_data;
6050 }
6051
6052 static int py_ForestTrustInfoRecord_set_data(PyObject *py_obj, PyObject *value, void *closure)
6053 {
6054         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6055         {
6056                 void *data_switch_0;
6057                 data_switch_0 = py_export_ForestTrustData(py_talloc_get_mem_ctx(py_obj), object->type, value);
6058                 if (data_switch_0 == NULL) { return -1; }
6059                 memcpy(&object->data, data_switch_0, sizeof(object->data));
6060         }
6061         return 0;
6062 }
6063
6064 static PyGetSetDef py_ForestTrustInfoRecord_getsetters[] = {
6065         { discard_const_p(char, "flags"), py_ForestTrustInfoRecord_get_flags, py_ForestTrustInfoRecord_set_flags },
6066         { discard_const_p(char, "timestamp"), py_ForestTrustInfoRecord_get_timestamp, py_ForestTrustInfoRecord_set_timestamp },
6067         { discard_const_p(char, "type"), py_ForestTrustInfoRecord_get_type, py_ForestTrustInfoRecord_set_type },
6068         { discard_const_p(char, "data"), py_ForestTrustInfoRecord_get_data, py_ForestTrustInfoRecord_set_data },
6069         { NULL }
6070 };
6071
6072 static PyObject *py_ForestTrustInfoRecord_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6073 {
6074         return py_talloc_new(struct ForestTrustInfoRecord, type);
6075 }
6076
6077 static PyObject *py_ForestTrustInfoRecord_ndr_pack(PyObject *py_obj)
6078 {
6079         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6080         DATA_BLOB blob;
6081         enum ndr_err_code err;
6082         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ForestTrustInfoRecord);
6083         if (err != NDR_ERR_SUCCESS) {
6084                 PyErr_SetNdrError(err);
6085                 return NULL;
6086         }
6087
6088         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6089 }
6090
6091 static PyObject *py_ForestTrustInfoRecord_ndr_unpack(PyObject *py_obj, PyObject *args)
6092 {
6093         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6094         DATA_BLOB blob;
6095         enum ndr_err_code err;
6096         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
6097                 return NULL;
6098
6099         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ForestTrustInfoRecord);
6100         if (err != NDR_ERR_SUCCESS) {
6101                 PyErr_SetNdrError(err);
6102                 return NULL;
6103         }
6104
6105         Py_RETURN_NONE;
6106 }
6107
6108 static PyObject *py_ForestTrustInfoRecord_ndr_print(PyObject *py_obj)
6109 {
6110         struct ForestTrustInfoRecord *object = (struct ForestTrustInfoRecord *)py_talloc_get_ptr(py_obj);
6111         char *retstr;
6112         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ForestTrustInfoRecord, "ForestTrustInfoRecord", object);
6113         return PyString_FromString(retstr);
6114 }
6115
6116 static PyMethodDef py_ForestTrustInfoRecord_methods[] = {
6117         { "__ndr_pack__", (PyCFunction)py_ForestTrustInfoRecord_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6118         { "__ndr_unpack__", (PyCFunction)py_ForestTrustInfoRecord_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
6119         { "__ndr_print__", (PyCFunction)py_ForestTrustInfoRecord_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6120         { NULL, NULL, 0, NULL }
6121 };
6122
6123
6124 static PyTypeObject ForestTrustInfoRecord_Type = {
6125         PyObject_HEAD_INIT(NULL) 0,
6126         .tp_name = "drsblobs.ForestTrustInfoRecord",
6127         .tp_basicsize = sizeof(py_talloc_Object),
6128         .tp_dealloc = py_talloc_dealloc,
6129         .tp_getset = py_ForestTrustInfoRecord_getsetters,
6130         .tp_repr = py_talloc_default_repr,
6131         .tp_methods = py_ForestTrustInfoRecord_methods,
6132         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6133         .tp_new = py_ForestTrustInfoRecord_new,
6134 };
6135
6136
6137 static PyObject *py_ForestTrustInfoRecordArmor_get_record_size(PyObject *obj, void *closure)
6138 {
6139         struct ForestTrustInfoRecordArmor *object = (struct ForestTrustInfoRecordArmor *)py_talloc_get_ptr(obj);
6140         PyObject *py_record_size;
6141         py_record_size = PyInt_FromLong(object->record_size);
6142         return py_record_size;
6143 }
6144
6145 static int py_ForestTrustInfoRecordArmor_set_record_size(PyObject *py_obj, PyObject *value, void *closure)
6146 {
6147         struct ForestTrustInfoRecordArmor *object = (struct ForestTrustInfoRecordArmor *)py_talloc_get_ptr(py_obj);
6148         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6149         object->record_size = PyInt_AsLong(value);
6150         return 0;
6151 }
6152
6153 static PyObject *py_ForestTrustInfoRecordArmor_get_record(PyObject *obj, void *closure)
6154 {
6155         struct ForestTrustInfoRecordArmor *object = (struct ForestTrustInfoRecordArmor *)py_talloc_get_ptr(obj);
6156         PyObject *py_record;
6157         py_record = py_talloc_reference_ex(&ForestTrustInfoRecord_Type, py_talloc_get_mem_ctx(obj), &object->record);
6158         return py_record;
6159 }
6160
6161 static int py_ForestTrustInfoRecordArmor_set_record(PyObject *py_obj, PyObject *value, void *closure)
6162 {
6163         struct ForestTrustInfoRecordArmor *object = (struct ForestTrustInfoRecordArmor *)py_talloc_get_ptr(py_obj);
6164         PY_CHECK_TYPE(&ForestTrustInfoRecord_Type, value, return -1;);
6165         memcpy(&object->record, (struct ForestTrustInfoRecord *)py_talloc_get_ptr(value), sizeof(object->record));
6166         return 0;
6167 }
6168
6169 static PyGetSetDef py_ForestTrustInfoRecordArmor_getsetters[] = {
6170         { discard_const_p(char, "record_size"), py_ForestTrustInfoRecordArmor_get_record_size, py_ForestTrustInfoRecordArmor_set_record_size },
6171         { discard_const_p(char, "record"), py_ForestTrustInfoRecordArmor_get_record, py_ForestTrustInfoRecordArmor_set_record },
6172         { NULL }
6173 };
6174
6175 static PyObject *py_ForestTrustInfoRecordArmor_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6176 {
6177         return py_talloc_new(struct ForestTrustInfoRecordArmor, type);
6178 }
6179
6180
6181 static PyTypeObject ForestTrustInfoRecordArmor_Type = {
6182         PyObject_HEAD_INIT(NULL) 0,
6183         .tp_name = "drsblobs.ForestTrustInfoRecordArmor",
6184         .tp_basicsize = sizeof(py_talloc_Object),
6185         .tp_dealloc = py_talloc_dealloc,
6186         .tp_getset = py_ForestTrustInfoRecordArmor_getsetters,
6187         .tp_repr = py_talloc_default_repr,
6188         .tp_methods = NULL,
6189         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6190         .tp_new = py_ForestTrustInfoRecordArmor_new,
6191 };
6192
6193
6194 static PyObject *py_ForestTrustInfo_get_version(PyObject *obj, void *closure)
6195 {
6196         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(obj);
6197         PyObject *py_version;
6198         py_version = PyInt_FromLong(object->version);
6199         return py_version;
6200 }
6201
6202 static int py_ForestTrustInfo_set_version(PyObject *py_obj, PyObject *value, void *closure)
6203 {
6204         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6205         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6206         object->version = PyInt_AsLong(value);
6207         return 0;
6208 }
6209
6210 static PyObject *py_ForestTrustInfo_get_count(PyObject *obj, void *closure)
6211 {
6212         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(obj);
6213         PyObject *py_count;
6214         py_count = PyInt_FromLong(object->count);
6215         return py_count;
6216 }
6217
6218 static int py_ForestTrustInfo_set_count(PyObject *py_obj, PyObject *value, void *closure)
6219 {
6220         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6221         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6222         object->count = PyInt_AsLong(value);
6223         return 0;
6224 }
6225
6226 static PyObject *py_ForestTrustInfo_get_records(PyObject *obj, void *closure)
6227 {
6228         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(obj);
6229         PyObject *py_records;
6230         py_records = PyList_New(object->count);
6231         if (py_records == NULL) {
6232                 return NULL;
6233         }
6234         {
6235                 int records_cntr_0;
6236                 for (records_cntr_0 = 0; records_cntr_0 < object->count; records_cntr_0++) {
6237                         PyObject *py_records_0;
6238                         py_records_0 = py_talloc_reference_ex(&ForestTrustInfoRecordArmor_Type, object->records, &object->records[records_cntr_0]);
6239                         PyList_SetItem(py_records, records_cntr_0, py_records_0);
6240                 }
6241         }
6242         return py_records;
6243 }
6244
6245 static int py_ForestTrustInfo_set_records(PyObject *py_obj, PyObject *value, void *closure)
6246 {
6247         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6248         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
6249         {
6250                 int records_cntr_0;
6251                 object->records = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->records, PyList_Size(value));
6252                 for (records_cntr_0 = 0; records_cntr_0 < PyList_Size(value); records_cntr_0++) {
6253                         PY_CHECK_TYPE(&ForestTrustInfoRecordArmor_Type, PyList_GetItem(value, records_cntr_0), return -1;);
6254                         memcpy(&object->records[records_cntr_0], (struct ForestTrustInfoRecordArmor *)py_talloc_get_ptr(PyList_GetItem(value, records_cntr_0)), sizeof(object->records[records_cntr_0]));
6255                 }
6256         }
6257         return 0;
6258 }
6259
6260 static PyGetSetDef py_ForestTrustInfo_getsetters[] = {
6261         { discard_const_p(char, "version"), py_ForestTrustInfo_get_version, py_ForestTrustInfo_set_version },
6262         { discard_const_p(char, "count"), py_ForestTrustInfo_get_count, py_ForestTrustInfo_set_count },
6263         { discard_const_p(char, "records"), py_ForestTrustInfo_get_records, py_ForestTrustInfo_set_records },
6264         { NULL }
6265 };
6266
6267 static PyObject *py_ForestTrustInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6268 {
6269         return py_talloc_new(struct ForestTrustInfo, type);
6270 }
6271
6272 static PyObject *py_ForestTrustInfo_ndr_pack(PyObject *py_obj)
6273 {
6274         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6275         DATA_BLOB blob;
6276         enum ndr_err_code err;
6277         err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ForestTrustInfo);
6278         if (err != NDR_ERR_SUCCESS) {
6279                 PyErr_SetNdrError(err);
6280                 return NULL;
6281         }
6282
6283         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6284 }
6285
6286 static PyObject *py_ForestTrustInfo_ndr_unpack(PyObject *py_obj, PyObject *args)
6287 {
6288         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6289         DATA_BLOB blob;
6290         enum ndr_err_code err;
6291         if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
6292                 return NULL;
6293
6294         err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ForestTrustInfo);
6295         if (err != NDR_ERR_SUCCESS) {
6296                 PyErr_SetNdrError(err);
6297                 return NULL;
6298         }
6299
6300         Py_RETURN_NONE;
6301 }
6302
6303 static PyObject *py_ForestTrustInfo_ndr_print(PyObject *py_obj)
6304 {
6305         struct ForestTrustInfo *object = (struct ForestTrustInfo *)py_talloc_get_ptr(py_obj);
6306         char *retstr;
6307         retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ForestTrustInfo, "ForestTrustInfo", object);
6308         return PyString_FromString(retstr);
6309 }
6310
6311 static PyMethodDef py_ForestTrustInfo_methods[] = {
6312         { "__ndr_pack__", (PyCFunction)py_ForestTrustInfo_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6313         { "__ndr_unpack__", (PyCFunction)py_ForestTrustInfo_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
6314         { "__ndr_print__", (PyCFunction)py_ForestTrustInfo_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6315         { NULL, NULL, 0, NULL }
6316 };
6317
6318
6319 static PyTypeObject ForestTrustInfo_Type = {
6320         PyObject_HEAD_INIT(NULL) 0,
6321         .tp_name = "drsblobs.ForestTrustInfo",
6322         .tp_basicsize = sizeof(py_talloc_Object),
6323         .tp_dealloc = py_talloc_dealloc,
6324         .tp_getset = py_ForestTrustInfo_getsetters,
6325         .tp_repr = py_talloc_default_repr,
6326         .tp_methods = py_ForestTrustInfo_methods,
6327         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6328         .tp_new = py_ForestTrustInfo_new,
6329 };
6330
6331
6332 static bool pack_py_decode_replPropertyMetaData_args_in(PyObject *args, PyObject *kwargs, struct decode_replPropertyMetaData *r)
6333 {
6334         PyObject *py_blob;
6335         const char *kwnames[] = {
6336                 "blob", NULL
6337         };
6338
6339         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_replPropertyMetaData", discard_const_p(char *, kwnames), &py_blob)) {
6340                 return false;
6341         }
6342
6343         PY_CHECK_TYPE(&replPropertyMetaDataBlob_Type, py_blob, return false;);
6344         memcpy(&r->in.blob, (struct replPropertyMetaDataBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6345         return true;
6346 }
6347
6348 static PyObject *unpack_py_decode_replPropertyMetaData_args_out(struct decode_replPropertyMetaData *r)
6349 {
6350         PyObject *result;
6351         result = Py_None;
6352         Py_INCREF(result);
6353         return result;
6354 }
6355
6356 static bool pack_py_decode_replUpToDateVector_args_in(PyObject *args, PyObject *kwargs, struct decode_replUpToDateVector *r)
6357 {
6358         PyObject *py_blob;
6359         const char *kwnames[] = {
6360                 "blob", NULL
6361         };
6362
6363         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_replUpToDateVector", discard_const_p(char *, kwnames), &py_blob)) {
6364                 return false;
6365         }
6366
6367         PY_CHECK_TYPE(&replUpToDateVectorBlob_Type, py_blob, return false;);
6368         memcpy(&r->in.blob, (struct replUpToDateVectorBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6369         return true;
6370 }
6371
6372 static PyObject *unpack_py_decode_replUpToDateVector_args_out(struct decode_replUpToDateVector *r)
6373 {
6374         PyObject *result;
6375         result = Py_None;
6376         Py_INCREF(result);
6377         return result;
6378 }
6379
6380 static bool pack_py_decode_repsFromTo_args_in(PyObject *args, PyObject *kwargs, struct decode_repsFromTo *r)
6381 {
6382         PyObject *py_blob;
6383         const char *kwnames[] = {
6384                 "blob", NULL
6385         };
6386
6387         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_repsFromTo", discard_const_p(char *, kwnames), &py_blob)) {
6388                 return false;
6389         }
6390
6391         PY_CHECK_TYPE(&repsFromToBlob_Type, py_blob, return false;);
6392         memcpy(&r->in.blob, (struct repsFromToBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6393         return true;
6394 }
6395
6396 static PyObject *unpack_py_decode_repsFromTo_args_out(struct decode_repsFromTo *r)
6397 {
6398         PyObject *result;
6399         result = Py_None;
6400         Py_INCREF(result);
6401         return result;
6402 }
6403
6404 static bool pack_py_decode_partialAttributeSet_args_in(PyObject *args, PyObject *kwargs, struct decode_partialAttributeSet *r)
6405 {
6406         PyObject *py_blob;
6407         const char *kwnames[] = {
6408                 "blob", NULL
6409         };
6410
6411         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_partialAttributeSet", discard_const_p(char *, kwnames), &py_blob)) {
6412                 return false;
6413         }
6414
6415         PY_CHECK_TYPE(&partialAttributeSetBlob_Type, py_blob, return false;);
6416         memcpy(&r->in.blob, (struct partialAttributeSetBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6417         return true;
6418 }
6419
6420 static PyObject *unpack_py_decode_partialAttributeSet_args_out(struct decode_partialAttributeSet *r)
6421 {
6422         PyObject *result;
6423         result = Py_None;
6424         Py_INCREF(result);
6425         return result;
6426 }
6427
6428 static bool pack_py_decode_prefixMap_args_in(PyObject *args, PyObject *kwargs, struct decode_prefixMap *r)
6429 {
6430         PyObject *py_blob;
6431         const char *kwnames[] = {
6432                 "blob", NULL
6433         };
6434
6435         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_prefixMap", discard_const_p(char *, kwnames), &py_blob)) {
6436                 return false;
6437         }
6438
6439         PY_CHECK_TYPE(&prefixMapBlob_Type, py_blob, return false;);
6440         memcpy(&r->in.blob, (struct prefixMapBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6441         return true;
6442 }
6443
6444 static PyObject *unpack_py_decode_prefixMap_args_out(struct decode_prefixMap *r)
6445 {
6446         PyObject *result;
6447         result = Py_None;
6448         Py_INCREF(result);
6449         return result;
6450 }
6451
6452 static bool pack_py_decode_ldapControlDirSync_args_in(PyObject *args, PyObject *kwargs, struct decode_ldapControlDirSync *r)
6453 {
6454         PyObject *py_cookie;
6455         const char *kwnames[] = {
6456                 "cookie", NULL
6457         };
6458
6459         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_ldapControlDirSync", discard_const_p(char *, kwnames), &py_cookie)) {
6460                 return false;
6461         }
6462
6463         PY_CHECK_TYPE(&ldapControlDirSyncCookie_Type, py_cookie, return false;);
6464         memcpy(&r->in.cookie, (struct ldapControlDirSyncCookie *)py_talloc_get_ptr(py_cookie), sizeof(r->in.cookie));
6465         return true;
6466 }
6467
6468 static PyObject *unpack_py_decode_ldapControlDirSync_args_out(struct decode_ldapControlDirSync *r)
6469 {
6470         PyObject *result;
6471         result = Py_None;
6472         Py_INCREF(result);
6473         return result;
6474 }
6475
6476 static bool pack_py_decode_supplementalCredentials_args_in(PyObject *args, PyObject *kwargs, struct decode_supplementalCredentials *r)
6477 {
6478         PyObject *py_blob;
6479         const char *kwnames[] = {
6480                 "blob", NULL
6481         };
6482
6483         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_supplementalCredentials", discard_const_p(char *, kwnames), &py_blob)) {
6484                 return false;
6485         }
6486
6487         PY_CHECK_TYPE(&supplementalCredentialsBlob_Type, py_blob, return false;);
6488         memcpy(&r->in.blob, (struct supplementalCredentialsBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6489         return true;
6490 }
6491
6492 static PyObject *unpack_py_decode_supplementalCredentials_args_out(struct decode_supplementalCredentials *r)
6493 {
6494         PyObject *result;
6495         result = Py_None;
6496         Py_INCREF(result);
6497         return result;
6498 }
6499
6500 static bool pack_py_decode_Packages_args_in(PyObject *args, PyObject *kwargs, struct decode_Packages *r)
6501 {
6502         PyObject *py_blob;
6503         const char *kwnames[] = {
6504                 "blob", NULL
6505         };
6506
6507         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_Packages", discard_const_p(char *, kwnames), &py_blob)) {
6508                 return false;
6509         }
6510
6511         PY_CHECK_TYPE(&package_PackagesBlob_Type, py_blob, return false;);
6512         memcpy(&r->in.blob, (struct package_PackagesBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6513         return true;
6514 }
6515
6516 static PyObject *unpack_py_decode_Packages_args_out(struct decode_Packages *r)
6517 {
6518         PyObject *result;
6519         result = Py_None;
6520         Py_INCREF(result);
6521         return result;
6522 }
6523
6524 static bool pack_py_decode_PrimaryCLEARTEXT_args_in(PyObject *args, PyObject *kwargs, struct decode_PrimaryCLEARTEXT *r)
6525 {
6526         PyObject *py_blob;
6527         const char *kwnames[] = {
6528                 "blob", NULL
6529         };
6530
6531         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_PrimaryCLEARTEXT", discard_const_p(char *, kwnames), &py_blob)) {
6532                 return false;
6533         }
6534
6535         PY_CHECK_TYPE(&package_PrimaryCLEARTEXTBlob_Type, py_blob, return false;);
6536         memcpy(&r->in.blob, (struct package_PrimaryCLEARTEXTBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6537         return true;
6538 }
6539
6540 static PyObject *unpack_py_decode_PrimaryCLEARTEXT_args_out(struct decode_PrimaryCLEARTEXT *r)
6541 {
6542         PyObject *result;
6543         result = Py_None;
6544         Py_INCREF(result);
6545         return result;
6546 }
6547
6548 static bool pack_py_decode_PrimaryWDigest_args_in(PyObject *args, PyObject *kwargs, struct decode_PrimaryWDigest *r)
6549 {
6550         PyObject *py_blob;
6551         const char *kwnames[] = {
6552                 "blob", NULL
6553         };
6554
6555         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_PrimaryWDigest", discard_const_p(char *, kwnames), &py_blob)) {
6556                 return false;
6557         }
6558
6559         PY_CHECK_TYPE(&package_PrimaryWDigestBlob_Type, py_blob, return false;);
6560         memcpy(&r->in.blob, (struct package_PrimaryWDigestBlob *)py_talloc_get_ptr(py_blob), sizeof(r->in.blob));
6561         return true;
6562 }
6563
6564 static PyObject *unpack_py_decode_PrimaryWDigest_args_out(struct decode_PrimaryWDigest *r)
6565 {
6566         PyObject *result;
6567         result = Py_None;
6568         Py_INCREF(result);
6569         return result;
6570 }
6571
6572 const struct PyNdrRpcMethodDef py_ndr_drsblobs_methods[] = {
6573         { "decode_replPropertyMetaData", "S.decode_replPropertyMetaData(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_replPropertyMetaData_r, (py_data_pack_fn)pack_py_decode_replPropertyMetaData_args_in, (py_data_unpack_fn)unpack_py_decode_replPropertyMetaData_args_out, 0, &ndr_table_drsblobs },
6574         { "decode_replUpToDateVector", "S.decode_replUpToDateVector(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_replUpToDateVector_r, (py_data_pack_fn)pack_py_decode_replUpToDateVector_args_in, (py_data_unpack_fn)unpack_py_decode_replUpToDateVector_args_out, 1, &ndr_table_drsblobs },
6575         { "decode_repsFromTo", "S.decode_repsFromTo(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_repsFromTo_r, (py_data_pack_fn)pack_py_decode_repsFromTo_args_in, (py_data_unpack_fn)unpack_py_decode_repsFromTo_args_out, 2, &ndr_table_drsblobs },
6576         { "decode_partialAttributeSet", "S.decode_partialAttributeSet(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_partialAttributeSet_r, (py_data_pack_fn)pack_py_decode_partialAttributeSet_args_in, (py_data_unpack_fn)unpack_py_decode_partialAttributeSet_args_out, 3, &ndr_table_drsblobs },
6577         { "decode_prefixMap", "S.decode_prefixMap(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_prefixMap_r, (py_data_pack_fn)pack_py_decode_prefixMap_args_in, (py_data_unpack_fn)unpack_py_decode_prefixMap_args_out, 4, &ndr_table_drsblobs },
6578         { "decode_ldapControlDirSync", "S.decode_ldapControlDirSync(cookie) -> None", (py_dcerpc_call_fn)dcerpc_decode_ldapControlDirSync_r, (py_data_pack_fn)pack_py_decode_ldapControlDirSync_args_in, (py_data_unpack_fn)unpack_py_decode_ldapControlDirSync_args_out, 5, &ndr_table_drsblobs },
6579         { "decode_supplementalCredentials", "S.decode_supplementalCredentials(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_supplementalCredentials_r, (py_data_pack_fn)pack_py_decode_supplementalCredentials_args_in, (py_data_unpack_fn)unpack_py_decode_supplementalCredentials_args_out, 6, &ndr_table_drsblobs },
6580         { "decode_Packages", "S.decode_Packages(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_Packages_r, (py_data_pack_fn)pack_py_decode_Packages_args_in, (py_data_unpack_fn)unpack_py_decode_Packages_args_out, 7, &ndr_table_drsblobs },
6581         { "decode_PrimaryCLEARTEXT", "S.decode_PrimaryCLEARTEXT(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_PrimaryCLEARTEXT_r, (py_data_pack_fn)pack_py_decode_PrimaryCLEARTEXT_args_in, (py_data_unpack_fn)unpack_py_decode_PrimaryCLEARTEXT_args_out, 9, &ndr_table_drsblobs },
6582         { "decode_PrimaryWDigest", "S.decode_PrimaryWDigest(blob) -> None", (py_dcerpc_call_fn)dcerpc_decode_PrimaryWDigest_r, (py_data_pack_fn)pack_py_decode_PrimaryWDigest_args_in, (py_data_unpack_fn)unpack_py_decode_PrimaryWDigest_args_out, 10, &ndr_table_drsblobs },
6583         { NULL }
6584 };
6585
6586 static PyObject *interface_drsblobs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6587 {
6588         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_drsblobs);
6589 }
6590
6591 #define PY_DOC_DRSBLOBS "Active Directory Replication LDAP Blobs"
6592 static PyTypeObject drsblobs_InterfaceType = {
6593         PyObject_HEAD_INIT(NULL) 0,
6594         .tp_name = "drsblobs.drsblobs",
6595         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
6596         .tp_base = &dcerpc_InterfaceType,
6597         .tp_doc = "drsblobs(binding, lp_ctx=None, credentials=None) -> connection\n"
6598 "\n"
6599 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
6600 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
6601 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_DRSBLOBS,
6602         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6603         .tp_new = interface_drsblobs_new,
6604 };
6605
6606 static PyMethodDef drsblobs_methods[] = {
6607         { NULL, NULL, 0, NULL }
6608 };
6609
6610 void initdrsblobs(void)
6611 {
6612         PyObject *m;
6613         PyObject *dep_drsuapi;
6614         PyObject *dep_misc;
6615         PyObject *dep_samr;
6616         PyObject *dep_lsa;
6617         PyObject *dep_security;
6618
6619         dep_drsuapi = PyImport_ImportModule("samba.dcerpc.drsuapi");
6620         if (dep_drsuapi == NULL)
6621                 return;
6622
6623         dep_misc = PyImport_ImportModule("samba.dcerpc.misc");
6624         if (dep_misc == NULL)
6625                 return;
6626
6627         dep_samr = PyImport_ImportModule("samba.dcerpc.samr");
6628         if (dep_samr == NULL)
6629                 return;
6630
6631         dep_lsa = PyImport_ImportModule("samba.dcerpc.lsa");
6632         if (dep_lsa == NULL)
6633                 return;
6634
6635         dep_security = PyImport_ImportModule("samba.dcerpc.security");
6636         if (dep_security == NULL)
6637                 return;
6638
6639         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_security, "dom_sid");
6640         if (dom_sid_Type == NULL)
6641                 return;
6642
6643         drsuapi_DsReplicaOIDMapping_Ctr_Type = (PyTypeObject *)PyObject_GetAttrString(dep_drsuapi, "DsReplicaOIDMapping_Ctr");
6644         if (drsuapi_DsReplicaOIDMapping_Ctr_Type == NULL)
6645                 return;
6646
6647         samr_Password_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samr, "Password");
6648         if (samr_Password_Type == NULL)
6649                 return;
6650
6651         drsuapi_DsReplicaCursor_Type = (PyTypeObject *)PyObject_GetAttrString(dep_drsuapi, "DsReplicaCursor");
6652         if (drsuapi_DsReplicaCursor_Type == NULL)
6653                 return;
6654
6655         drsuapi_DsReplicaHighWaterMark_Type = (PyTypeObject *)PyObject_GetAttrString(dep_drsuapi, "DsReplicaHighWaterMark");
6656         if (drsuapi_DsReplicaHighWaterMark_Type == NULL)
6657                 return;
6658
6659         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_misc, "GUID");
6660         if (GUID_Type == NULL)
6661                 return;
6662
6663         drsuapi_DsReplicaCursor2_Type = (PyTypeObject *)PyObject_GetAttrString(dep_drsuapi, "DsReplicaCursor2");
6664         if (drsuapi_DsReplicaCursor2_Type == NULL)
6665                 return;
6666
6667         if (PyType_Ready(&replPropertyMetaData1_Type) < 0)
6668                 return;
6669         if (PyType_Ready(&replPropertyMetaDataCtr1_Type) < 0)
6670                 return;
6671         if (PyType_Ready(&replPropertyMetaDataBlob_Type) < 0)
6672                 return;
6673         if (PyType_Ready(&replUpToDateVectorCtr1_Type) < 0)
6674                 return;
6675         if (PyType_Ready(&replUpToDateVectorCtr2_Type) < 0)
6676                 return;
6677         if (PyType_Ready(&replUpToDateVectorBlob_Type) < 0)
6678                 return;
6679         if (PyType_Ready(&repsFromTo1OtherInfo_Type) < 0)
6680                 return;
6681         if (PyType_Ready(&repsFromTo1_Type) < 0)
6682                 return;
6683         if (PyType_Ready(&repsFromTo2OtherInfo_Type) < 0)
6684                 return;
6685         if (PyType_Ready(&repsFromTo2_Type) < 0)
6686                 return;
6687         if (PyType_Ready(&repsFromToBlob_Type) < 0)
6688                 return;
6689         if (PyType_Ready(&partialAttributeSetCtr1_Type) < 0)
6690                 return;
6691         if (PyType_Ready(&partialAttributeSetBlob_Type) < 0)
6692                 return;
6693         if (PyType_Ready(&schemaInfoBlob_Type) < 0)
6694                 return;
6695         if (PyType_Ready(&drsuapi_MSPrefixMap_Entry_Type) < 0)
6696                 return;
6697         if (PyType_Ready(&drsuapi_MSPrefixMap_Ctr_Type) < 0)
6698                 return;
6699         if (PyType_Ready(&prefixMapBlob_Type) < 0)
6700                 return;
6701         if (PyType_Ready(&ldapControlDirSyncBlob_Type) < 0)
6702                 return;
6703         if (PyType_Ready(&ldapControlDirSyncCookie_Type) < 0)
6704                 return;
6705         if (PyType_Ready(&supplementalCredentialsPackage_Type) < 0)
6706                 return;
6707         if (PyType_Ready(&supplementalCredentialsSubBlob_Type) < 0)
6708                 return;
6709         if (PyType_Ready(&supplementalCredentialsBlob_Type) < 0)
6710                 return;
6711         if (PyType_Ready(&package_PackagesBlob_Type) < 0)
6712                 return;
6713         if (PyType_Ready(&package_PrimaryCLEARTEXTBlob_Type) < 0)
6714                 return;
6715         if (PyType_Ready(&package_PrimaryWDigestHash_Type) < 0)
6716                 return;
6717         if (PyType_Ready(&package_PrimaryWDigestBlob_Type) < 0)
6718                 return;
6719         if (PyType_Ready(&AuthInfoNone_Type) < 0)
6720                 return;
6721         if (PyType_Ready(&AuthInfoNT4Owf_Type) < 0)
6722                 return;
6723         if (PyType_Ready(&AuthInfoClear_Type) < 0)
6724                 return;
6725         if (PyType_Ready(&AuthInfoVersion_Type) < 0)
6726                 return;
6727         if (PyType_Ready(&AuthenticationInformation_Type) < 0)
6728                 return;
6729         if (PyType_Ready(&AuthenticationInformationArray_Type) < 0)
6730                 return;
6731         if (PyType_Ready(&trustAuthInOutBlob_Type) < 0)
6732                 return;
6733         if (PyType_Ready(&trustCurrentPasswords_Type) < 0)
6734                 return;
6735         if (PyType_Ready(&trustDomainPasswords_Type) < 0)
6736                 return;
6737         if (PyType_Ready(&DsCompressedChunk_Type) < 0)
6738                 return;
6739         if (PyType_Ready(&ExtendedErrorAString_Type) < 0)
6740                 return;
6741         if (PyType_Ready(&ExtendedErrorUString_Type) < 0)
6742                 return;
6743         if (PyType_Ready(&ExtendedErrorBlob_Type) < 0)
6744                 return;
6745         if (PyType_Ready(&ExtendedErrorComputerName_Type) < 0)
6746                 return;
6747         if (PyType_Ready(&ExtendedErrorParam_Type) < 0)
6748                 return;
6749         if (PyType_Ready(&ExtendedErrorInfo_Type) < 0)
6750                 return;
6751         if (PyType_Ready(&ExtendedErrorInfoPtr_Type) < 0)
6752                 return;
6753         if (PyType_Ready(&ForestTrustString_Type) < 0)
6754                 return;
6755         if (PyType_Ready(&ForestTrustDataDomainInfo_Type) < 0)
6756                 return;
6757         if (PyType_Ready(&ForestTrustDataBinaryData_Type) < 0)
6758                 return;
6759         if (PyType_Ready(&ForestTrustInfoRecord_Type) < 0)
6760                 return;
6761         if (PyType_Ready(&ForestTrustInfoRecordArmor_Type) < 0)
6762                 return;
6763         if (PyType_Ready(&ForestTrustInfo_Type) < 0)
6764                 return;
6765         if (PyType_Ready(&drsblobs_InterfaceType) < 0)
6766                 return;
6767         if (!PyInterface_AddNdrRpcMethods(&drsblobs_InterfaceType, py_ndr_drsblobs_methods))
6768                 return;
6769
6770 #ifdef PY_REPLPROPERTYMETADATA1_PATCH
6771         PY_REPLPROPERTYMETADATA1_PATCH(&replPropertyMetaData1_Type);
6772 #endif
6773 #ifdef PY_REPLPROPERTYMETADATACTR1_PATCH
6774         PY_REPLPROPERTYMETADATACTR1_PATCH(&replPropertyMetaDataCtr1_Type);
6775 #endif
6776 #ifdef PY_REPLPROPERTYMETADATABLOB_PATCH
6777         PY_REPLPROPERTYMETADATABLOB_PATCH(&replPropertyMetaDataBlob_Type);
6778 #endif
6779 #ifdef PY_REPLUPTODATEVECTORCTR1_PATCH
6780         PY_REPLUPTODATEVECTORCTR1_PATCH(&replUpToDateVectorCtr1_Type);
6781 #endif
6782 #ifdef PY_REPLUPTODATEVECTORCTR2_PATCH
6783         PY_REPLUPTODATEVECTORCTR2_PATCH(&replUpToDateVectorCtr2_Type);
6784 #endif
6785 #ifdef PY_REPLUPTODATEVECTORBLOB_PATCH
6786         PY_REPLUPTODATEVECTORBLOB_PATCH(&replUpToDateVectorBlob_Type);
6787 #endif
6788 #ifdef PY_REPSFROMTO1OTHERINFO_PATCH
6789         PY_REPSFROMTO1OTHERINFO_PATCH(&repsFromTo1OtherInfo_Type);
6790 #endif
6791 #ifdef PY_REPSFROMTO1_PATCH
6792         PY_REPSFROMTO1_PATCH(&repsFromTo1_Type);
6793 #endif
6794 #ifdef PY_REPSFROMTO2OTHERINFO_PATCH
6795         PY_REPSFROMTO2OTHERINFO_PATCH(&repsFromTo2OtherInfo_Type);
6796 #endif
6797 #ifdef PY_REPSFROMTO2_PATCH
6798         PY_REPSFROMTO2_PATCH(&repsFromTo2_Type);
6799 #endif
6800 #ifdef PY_REPSFROMTOBLOB_PATCH
6801         PY_REPSFROMTOBLOB_PATCH(&repsFromToBlob_Type);
6802 #endif
6803 #ifdef PY_PARTIALATTRIBUTESETCTR1_PATCH
6804         PY_PARTIALATTRIBUTESETCTR1_PATCH(&partialAttributeSetCtr1_Type);
6805 #endif
6806 #ifdef PY_PARTIALATTRIBUTESETBLOB_PATCH
6807         PY_PARTIALATTRIBUTESETBLOB_PATCH(&partialAttributeSetBlob_Type);
6808 #endif
6809 #ifdef PY_SCHEMAINFOBLOB_PATCH
6810         PY_SCHEMAINFOBLOB_PATCH(&schemaInfoBlob_Type);
6811 #endif
6812 #ifdef PY_DRSUAPI_MSPREFIXMAP_ENTRY_PATCH
6813         PY_DRSUAPI_MSPREFIXMAP_ENTRY_PATCH(&drsuapi_MSPrefixMap_Entry_Type);
6814 #endif
6815 #ifdef PY_DRSUAPI_MSPREFIXMAP_CTR_PATCH
6816         PY_DRSUAPI_MSPREFIXMAP_CTR_PATCH(&drsuapi_MSPrefixMap_Ctr_Type);
6817 #endif
6818 #ifdef PY_PREFIXMAPBLOB_PATCH
6819         PY_PREFIXMAPBLOB_PATCH(&prefixMapBlob_Type);
6820 #endif
6821 #ifdef PY_LDAPCONTROLDIRSYNCBLOB_PATCH
6822         PY_LDAPCONTROLDIRSYNCBLOB_PATCH(&ldapControlDirSyncBlob_Type);
6823 #endif
6824 #ifdef PY_LDAPCONTROLDIRSYNCCOOKIE_PATCH
6825         PY_LDAPCONTROLDIRSYNCCOOKIE_PATCH(&ldapControlDirSyncCookie_Type);
6826 #endif
6827 #ifdef PY_SUPPLEMENTALCREDENTIALSPACKAGE_PATCH
6828         PY_SUPPLEMENTALCREDENTIALSPACKAGE_PATCH(&supplementalCredentialsPackage_Type);
6829 #endif
6830 #ifdef PY_SUPPLEMENTALCREDENTIALSSUBBLOB_PATCH
6831         PY_SUPPLEMENTALCREDENTIALSSUBBLOB_PATCH(&supplementalCredentialsSubBlob_Type);
6832 #endif
6833 #ifdef PY_SUPPLEMENTALCREDENTIALSBLOB_PATCH
6834         PY_SUPPLEMENTALCREDENTIALSBLOB_PATCH(&supplementalCredentialsBlob_Type);
6835 #endif
6836 #ifdef PY_PACKAGE_PACKAGESBLOB_PATCH
6837         PY_PACKAGE_PACKAGESBLOB_PATCH(&package_PackagesBlob_Type);
6838 #endif
6839 #ifdef PY_PACKAGE_PRIMARYCLEARTEXTBLOB_PATCH
6840         PY_PACKAGE_PRIMARYCLEARTEXTBLOB_PATCH(&package_PrimaryCLEARTEXTBlob_Type);
6841 #endif
6842 #ifdef PY_PACKAGE_PRIMARYWDIGESTHASH_PATCH
6843         PY_PACKAGE_PRIMARYWDIGESTHASH_PATCH(&package_PrimaryWDigestHash_Type);
6844 #endif
6845 #ifdef PY_PACKAGE_PRIMARYWDIGESTBLOB_PATCH
6846         PY_PACKAGE_PRIMARYWDIGESTBLOB_PATCH(&package_PrimaryWDigestBlob_Type);
6847 #endif
6848 #ifdef PY_AUTHINFONONE_PATCH
6849         PY_AUTHINFONONE_PATCH(&AuthInfoNone_Type);
6850 #endif
6851 #ifdef PY_AUTHINFONT4OWF_PATCH
6852         PY_AUTHINFONT4OWF_PATCH(&AuthInfoNT4Owf_Type);
6853 #endif
6854 #ifdef PY_AUTHINFOCLEAR_PATCH
6855         PY_AUTHINFOCLEAR_PATCH(&AuthInfoClear_Type);
6856 #endif
6857 #ifdef PY_AUTHINFOVERSION_PATCH
6858         PY_AUTHINFOVERSION_PATCH(&AuthInfoVersion_Type);
6859 #endif
6860 #ifdef PY_AUTHENTICATIONINFORMATION_PATCH
6861         PY_AUTHENTICATIONINFORMATION_PATCH(&AuthenticationInformation_Type);
6862 #endif
6863 #ifdef PY_AUTHENTICATIONINFORMATIONARRAY_PATCH
6864         PY_AUTHENTICATIONINFORMATIONARRAY_PATCH(&AuthenticationInformationArray_Type);
6865 #endif
6866 #ifdef PY_TRUSTAUTHINOUTBLOB_PATCH
6867         PY_TRUSTAUTHINOUTBLOB_PATCH(&trustAuthInOutBlob_Type);
6868 #endif
6869 #ifdef PY_TRUSTCURRENTPASSWORDS_PATCH
6870         PY_TRUSTCURRENTPASSWORDS_PATCH(&trustCurrentPasswords_Type);
6871 #endif
6872 #ifdef PY_TRUSTDOMAINPASSWORDS_PATCH
6873         PY_TRUSTDOMAINPASSWORDS_PATCH(&trustDomainPasswords_Type);
6874 #endif
6875 #ifdef PY_DSCOMPRESSEDCHUNK_PATCH
6876         PY_DSCOMPRESSEDCHUNK_PATCH(&DsCompressedChunk_Type);
6877 #endif
6878 #ifdef PY_EXTENDEDERRORASTRING_PATCH
6879         PY_EXTENDEDERRORASTRING_PATCH(&ExtendedErrorAString_Type);
6880 #endif
6881 #ifdef PY_EXTENDEDERRORUSTRING_PATCH
6882         PY_EXTENDEDERRORUSTRING_PATCH(&ExtendedErrorUString_Type);
6883 #endif
6884 #ifdef PY_EXTENDEDERRORBLOB_PATCH
6885         PY_EXTENDEDERRORBLOB_PATCH(&ExtendedErrorBlob_Type);
6886 #endif
6887 #ifdef PY_EXTENDEDERRORCOMPUTERNAME_PATCH
6888         PY_EXTENDEDERRORCOMPUTERNAME_PATCH(&ExtendedErrorComputerName_Type);
6889 #endif
6890 #ifdef PY_EXTENDEDERRORPARAM_PATCH
6891         PY_EXTENDEDERRORPARAM_PATCH(&ExtendedErrorParam_Type);
6892 #endif
6893 #ifdef PY_EXTENDEDERRORINFO_PATCH
6894         PY_EXTENDEDERRORINFO_PATCH(&ExtendedErrorInfo_Type);
6895 #endif
6896 #ifdef PY_EXTENDEDERRORINFOPTR_PATCH
6897         PY_EXTENDEDERRORINFOPTR_PATCH(&ExtendedErrorInfoPtr_Type);
6898 #endif
6899 #ifdef PY_FORESTTRUSTSTRING_PATCH
6900         PY_FORESTTRUSTSTRING_PATCH(&ForestTrustString_Type);
6901 #endif
6902 #ifdef PY_FORESTTRUSTDATADOMAININFO_PATCH
6903         PY_FORESTTRUSTDATADOMAININFO_PATCH(&ForestTrustDataDomainInfo_Type);
6904 #endif
6905 #ifdef PY_FORESTTRUSTDATABINARYDATA_PATCH
6906         PY_FORESTTRUSTDATABINARYDATA_PATCH(&ForestTrustDataBinaryData_Type);
6907 #endif
6908 #ifdef PY_FORESTTRUSTINFORECORD_PATCH
6909         PY_FORESTTRUSTINFORECORD_PATCH(&ForestTrustInfoRecord_Type);
6910 #endif
6911 #ifdef PY_FORESTTRUSTINFORECORDARMOR_PATCH
6912         PY_FORESTTRUSTINFORECORDARMOR_PATCH(&ForestTrustInfoRecordArmor_Type);
6913 #endif
6914 #ifdef PY_FORESTTRUSTINFO_PATCH
6915         PY_FORESTTRUSTINFO_PATCH(&ForestTrustInfo_Type);
6916 #endif
6917 #ifdef PY_DRSBLOBS_PATCH
6918         PY_DRSBLOBS_PATCH(&drsblobs_InterfaceType);
6919 #endif
6920
6921         m = Py_InitModule3("drsblobs", drsblobs_methods, "drsblobs DCE/RPC");
6922         if (m == NULL)
6923                 return;
6924
6925         PyModule_AddObject(m, "FOREST_TRUST_TOP_LEVEL_NAME_EX", PyInt_FromLong(FOREST_TRUST_TOP_LEVEL_NAME_EX));
6926         PyModule_AddObject(m, "EXTENDED_ERROR_COMPUTER_NAME_PRESENT", PyInt_FromLong(EXTENDED_ERROR_COMPUTER_NAME_PRESENT));
6927         PyModule_AddObject(m, "PREFIX_MAP_VERSION_DSDB", PyInt_FromLong(PREFIX_MAP_VERSION_DSDB));
6928         PyModule_AddObject(m, "FOREST_TRUST_DOMAIN_INFO", PyInt_FromLong(FOREST_TRUST_DOMAIN_INFO));
6929         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING));
6930         PyModule_AddObject(m, "SUPPLEMENTAL_CREDENTIALS_SIGNATURE", PyInt_FromLong(SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
6931         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_UINT16", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_UINT16));
6932         PyModule_AddObject(m, "FOREST_TRUST_TOP_LEVEL_NAME", PyInt_FromLong(FOREST_TRUST_TOP_LEVEL_NAME));
6933         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_NONE", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_NONE));
6934         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_UINT64", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_UINT64));
6935         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_UINT32", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_UINT32));
6936         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_BLOB", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_BLOB));
6937         PyModule_AddObject(m, "EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT", PyInt_FromLong(EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT));
6938         PyModule_AddObject(m, "EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING", PyInt_FromLong(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING));
6939         PyModule_AddObject(m, "SUPPLEMENTAL_CREDENTIALS_PREFIX", PyString_FromString("                                                "));
6940         Py_INCREF((PyObject *)(void *)&replPropertyMetaData1_Type);
6941         PyModule_AddObject(m, "replPropertyMetaData1", (PyObject *)(void *)&replPropertyMetaData1_Type);
6942         Py_INCREF((PyObject *)(void *)&replPropertyMetaDataCtr1_Type);
6943         PyModule_AddObject(m, "replPropertyMetaDataCtr1", (PyObject *)(void *)&replPropertyMetaDataCtr1_Type);
6944         Py_INCREF((PyObject *)(void *)&replPropertyMetaDataBlob_Type);
6945         PyModule_AddObject(m, "replPropertyMetaDataBlob", (PyObject *)(void *)&replPropertyMetaDataBlob_Type);
6946         Py_INCREF((PyObject *)(void *)&replUpToDateVectorCtr1_Type);
6947         PyModule_AddObject(m, "replUpToDateVectorCtr1", (PyObject *)(void *)&replUpToDateVectorCtr1_Type);
6948         Py_INCREF((PyObject *)(void *)&replUpToDateVectorCtr2_Type);
6949         PyModule_AddObject(m, "replUpToDateVectorCtr2", (PyObject *)(void *)&replUpToDateVectorCtr2_Type);
6950         Py_INCREF((PyObject *)(void *)&replUpToDateVectorBlob_Type);
6951         PyModule_AddObject(m, "replUpToDateVectorBlob", (PyObject *)(void *)&replUpToDateVectorBlob_Type);
6952         Py_INCREF((PyObject *)(void *)&repsFromTo1OtherInfo_Type);
6953         PyModule_AddObject(m, "repsFromTo1OtherInfo", (PyObject *)(void *)&repsFromTo1OtherInfo_Type);
6954         Py_INCREF((PyObject *)(void *)&repsFromTo1_Type);
6955         PyModule_AddObject(m, "repsFromTo1", (PyObject *)(void *)&repsFromTo1_Type);
6956         Py_INCREF((PyObject *)(void *)&repsFromTo2OtherInfo_Type);
6957         PyModule_AddObject(m, "repsFromTo2OtherInfo", (PyObject *)(void *)&repsFromTo2OtherInfo_Type);
6958         Py_INCREF((PyObject *)(void *)&repsFromTo2_Type);
6959         PyModule_AddObject(m, "repsFromTo2", (PyObject *)(void *)&repsFromTo2_Type);
6960         Py_INCREF((PyObject *)(void *)&repsFromToBlob_Type);
6961         PyModule_AddObject(m, "repsFromToBlob", (PyObject *)(void *)&repsFromToBlob_Type);
6962         Py_INCREF((PyObject *)(void *)&partialAttributeSetCtr1_Type);
6963         PyModule_AddObject(m, "partialAttributeSetCtr1", (PyObject *)(void *)&partialAttributeSetCtr1_Type);
6964         Py_INCREF((PyObject *)(void *)&partialAttributeSetBlob_Type);
6965         PyModule_AddObject(m, "partialAttributeSetBlob", (PyObject *)(void *)&partialAttributeSetBlob_Type);
6966         Py_INCREF((PyObject *)(void *)&schemaInfoBlob_Type);
6967         PyModule_AddObject(m, "schemaInfoBlob", (PyObject *)(void *)&schemaInfoBlob_Type);
6968         Py_INCREF((PyObject *)(void *)&drsuapi_MSPrefixMap_Entry_Type);
6969         PyModule_AddObject(m, "drsuapi_MSPrefixMap_Entry", (PyObject *)(void *)&drsuapi_MSPrefixMap_Entry_Type);
6970         Py_INCREF((PyObject *)(void *)&drsuapi_MSPrefixMap_Ctr_Type);
6971         PyModule_AddObject(m, "drsuapi_MSPrefixMap_Ctr", (PyObject *)(void *)&drsuapi_MSPrefixMap_Ctr_Type);
6972         Py_INCREF((PyObject *)(void *)&prefixMapBlob_Type);
6973         PyModule_AddObject(m, "prefixMapBlob", (PyObject *)(void *)&prefixMapBlob_Type);
6974         Py_INCREF((PyObject *)(void *)&ldapControlDirSyncBlob_Type);
6975         PyModule_AddObject(m, "ldapControlDirSyncBlob", (PyObject *)(void *)&ldapControlDirSyncBlob_Type);
6976         Py_INCREF((PyObject *)(void *)&ldapControlDirSyncCookie_Type);
6977         PyModule_AddObject(m, "ldapControlDirSyncCookie", (PyObject *)(void *)&ldapControlDirSyncCookie_Type);
6978         Py_INCREF((PyObject *)(void *)&supplementalCredentialsPackage_Type);
6979         PyModule_AddObject(m, "supplementalCredentialsPackage", (PyObject *)(void *)&supplementalCredentialsPackage_Type);
6980         Py_INCREF((PyObject *)(void *)&supplementalCredentialsSubBlob_Type);
6981         PyModule_AddObject(m, "supplementalCredentialsSubBlob", (PyObject *)(void *)&supplementalCredentialsSubBlob_Type);
6982         Py_INCREF((PyObject *)(void *)&supplementalCredentialsBlob_Type);
6983         PyModule_AddObject(m, "supplementalCredentialsBlob", (PyObject *)(void *)&supplementalCredentialsBlob_Type);
6984         Py_INCREF((PyObject *)(void *)&package_PackagesBlob_Type);
6985         PyModule_AddObject(m, "package_PackagesBlob", (PyObject *)(void *)&package_PackagesBlob_Type);
6986         Py_INCREF((PyObject *)(void *)&package_PrimaryCLEARTEXTBlob_Type);
6987         PyModule_AddObject(m, "package_PrimaryCLEARTEXTBlob", (PyObject *)(void *)&package_PrimaryCLEARTEXTBlob_Type);
6988         Py_INCREF((PyObject *)(void *)&package_PrimaryWDigestHash_Type);
6989         PyModule_AddObject(m, "package_PrimaryWDigestHash", (PyObject *)(void *)&package_PrimaryWDigestHash_Type);
6990         Py_INCREF((PyObject *)(void *)&package_PrimaryWDigestBlob_Type);
6991         PyModule_AddObject(m, "package_PrimaryWDigestBlob", (PyObject *)(void *)&package_PrimaryWDigestBlob_Type);
6992         Py_INCREF((PyObject *)(void *)&AuthInfoNone_Type);
6993         PyModule_AddObject(m, "AuthInfoNone", (PyObject *)(void *)&AuthInfoNone_Type);
6994         Py_INCREF((PyObject *)(void *)&AuthInfoNT4Owf_Type);
6995         PyModule_AddObject(m, "AuthInfoNT4Owf", (PyObject *)(void *)&AuthInfoNT4Owf_Type);
6996         Py_INCREF((PyObject *)(void *)&AuthInfoClear_Type);
6997         PyModule_AddObject(m, "AuthInfoClear", (PyObject *)(void *)&AuthInfoClear_Type);
6998         Py_INCREF((PyObject *)(void *)&AuthInfoVersion_Type);
6999         PyModule_AddObject(m, "AuthInfoVersion", (PyObject *)(void *)&AuthInfoVersion_Type);
7000         Py_INCREF((PyObject *)(void *)&AuthenticationInformation_Type);
7001         PyModule_AddObject(m, "AuthenticationInformation", (PyObject *)(void *)&AuthenticationInformation_Type);
7002         Py_INCREF((PyObject *)(void *)&AuthenticationInformationArray_Type);
7003         PyModule_AddObject(m, "AuthenticationInformationArray", (PyObject *)(void *)&AuthenticationInformationArray_Type);
7004         Py_INCREF((PyObject *)(void *)&trustAuthInOutBlob_Type);
7005         PyModule_AddObject(m, "trustAuthInOutBlob", (PyObject *)(void *)&trustAuthInOutBlob_Type);
7006         Py_INCREF((PyObject *)(void *)&trustCurrentPasswords_Type);
7007         PyModule_AddObject(m, "trustCurrentPasswords", (PyObject *)(void *)&trustCurrentPasswords_Type);
7008         Py_INCREF((PyObject *)(void *)&trustDomainPasswords_Type);
7009         PyModule_AddObject(m, "trustDomainPasswords", (PyObject *)(void *)&trustDomainPasswords_Type);
7010         Py_INCREF((PyObject *)(void *)&DsCompressedChunk_Type);
7011         PyModule_AddObject(m, "DsCompressedChunk", (PyObject *)(void *)&DsCompressedChunk_Type);
7012         Py_INCREF((PyObject *)(void *)&ExtendedErrorAString_Type);
7013         PyModule_AddObject(m, "ExtendedErrorAString", (PyObject *)(void *)&ExtendedErrorAString_Type);
7014         Py_INCREF((PyObject *)(void *)&ExtendedErrorUString_Type);
7015         PyModule_AddObject(m, "ExtendedErrorUString", (PyObject *)(void *)&ExtendedErrorUString_Type);
7016         Py_INCREF((PyObject *)(void *)&ExtendedErrorBlob_Type);
7017         PyModule_AddObject(m, "ExtendedErrorBlob", (PyObject *)(void *)&ExtendedErrorBlob_Type);
7018         Py_INCREF((PyObject *)(void *)&ExtendedErrorComputerName_Type);
7019         PyModule_AddObject(m, "ExtendedErrorComputerName", (PyObject *)(void *)&ExtendedErrorComputerName_Type);
7020         Py_INCREF((PyObject *)(void *)&ExtendedErrorParam_Type);
7021         PyModule_AddObject(m, "ExtendedErrorParam", (PyObject *)(void *)&ExtendedErrorParam_Type);
7022         Py_INCREF((PyObject *)(void *)&ExtendedErrorInfo_Type);
7023         PyModule_AddObject(m, "ExtendedErrorInfo", (PyObject *)(void *)&ExtendedErrorInfo_Type);
7024         Py_INCREF((PyObject *)(void *)&ExtendedErrorInfoPtr_Type);
7025         PyModule_AddObject(m, "ExtendedErrorInfoPtr", (PyObject *)(void *)&ExtendedErrorInfoPtr_Type);
7026         Py_INCREF((PyObject *)(void *)&ForestTrustString_Type);
7027         PyModule_AddObject(m, "ForestTrustString", (PyObject *)(void *)&ForestTrustString_Type);
7028         Py_INCREF((PyObject *)(void *)&ForestTrustDataDomainInfo_Type);
7029         PyModule_AddObject(m, "ForestTrustDataDomainInfo", (PyObject *)(void *)&ForestTrustDataDomainInfo_Type);
7030         Py_INCREF((PyObject *)(void *)&ForestTrustDataBinaryData_Type);
7031         PyModule_AddObject(m, "ForestTrustDataBinaryData", (PyObject *)(void *)&ForestTrustDataBinaryData_Type);
7032         Py_INCREF((PyObject *)(void *)&ForestTrustInfoRecord_Type);
7033         PyModule_AddObject(m, "ForestTrustInfoRecord", (PyObject *)(void *)&ForestTrustInfoRecord_Type);
7034         Py_INCREF((PyObject *)(void *)&ForestTrustInfoRecordArmor_Type);
7035         PyModule_AddObject(m, "ForestTrustInfoRecordArmor", (PyObject *)(void *)&ForestTrustInfoRecordArmor_Type);
7036         Py_INCREF((PyObject *)(void *)&ForestTrustInfo_Type);
7037         PyModule_AddObject(m, "ForestTrustInfo", (PyObject *)(void *)&ForestTrustInfo_Type);
7038         Py_INCREF((PyObject *)(void *)&drsblobs_InterfaceType);
7039         PyModule_AddObject(m, "drsblobs", (PyObject *)(void *)&drsblobs_InterfaceType);
7040 #ifdef PY_MOD_DRSBLOBS_PATCH
7041         PY_MOD_DRSBLOBS_PATCH(m);
7042 #endif
7043
7044 }