bin.gen_ndr/default/librpc/gen_ndr/py_dfsblobs.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #include <Python.h>
   4 #include "includes.h"
   5 #include <pytalloc.h>
   6 #include "librpc/rpc/pyrpc.h"
   7 #include "librpc/rpc/pyrpc_util.h"
   8 #include "bin/default/librpc/gen_ndr/ndr_dfsblobs.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_dfsblobs_c.h"
  10
  11 #include "librpc/gen_ndr/misc.h"
  12 staticforward PyTypeObject dfs_referral_v1_Type;
  13 staticforward PyTypeObject dfs_referral_v2_Type;
  14 staticforward PyTypeObject dfs_normal_referral_Type;
  15 staticforward PyTypeObject dfs_domain_referral_Type;
  16 staticforward PyTypeObject dfs_referral_v3_Type;
  17 staticforward PyTypeObject dfs_referral_type_Type;
  18 staticforward PyTypeObject dfs_referral_resp_Type;
  19 staticforward PyTypeObject dfs_GetDFSReferral_in_Type;
  20 staticforward PyTypeObject dfsblobs_InterfaceType;
  21
  22 void initdfsblobs(void);static PyTypeObject *Object_Type;
  23 static PyTypeObject *ClientConnection_Type;
  24
  25 static PyObject *py_dfs_referral_v1_get_size(PyObject *obj, void *closure)
  26 {
  27         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj);
  28         PyObject *py_size;
  29         py_size = PyInt_FromLong(object->size);
  30         return py_size;
  31 }
  32
  33 static int py_dfs_referral_v1_set_size(PyObject *py_obj, PyObject *value, void *closure)
  34 {
  35         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj);
  36         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  37         object->size = PyInt_AsLong(value);
  38         return 0;
  39 }
  40
  41 static PyObject *py_dfs_referral_v1_get_server_type(PyObject *obj, void *closure)
  42 {
  43         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj);
  44         PyObject *py_server_type;
  45         py_server_type = PyInt_FromLong(object->server_type);
  46         return py_server_type;
  47 }
  48
  49 static int py_dfs_referral_v1_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
  50 {
  51         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj);
  52         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  53         object->server_type = PyInt_AsLong(value);
  54         return 0;
  55 }
  56
  57 static PyObject *py_dfs_referral_v1_get_entry_flags(PyObject *obj, void *closure)
  58 {
  59         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj);
  60         PyObject *py_entry_flags;
  61         py_entry_flags = PyInt_FromLong(object->entry_flags);
  62         return py_entry_flags;
  63 }
  64
  65 static int py_dfs_referral_v1_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure)
  66 {
  67         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj);
  68         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  69         object->entry_flags = PyInt_AsLong(value);
  70         return 0;
  71 }
  72
  73 static PyObject *py_dfs_referral_v1_get_share_name(PyObject *obj, void *closure)
  74 {
  75         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj);
  76         PyObject *py_share_name;
  77         if (object->share_name == NULL) {
  78                 py_share_name = Py_None;
  79                 Py_INCREF(py_share_name);
  80         } else {
  81                 py_share_name = PyString_FromStringOrNULL(object->share_name);
  82         }
  83         return py_share_name;
  84 }
  85
  86 static int py_dfs_referral_v1_set_share_name(PyObject *py_obj, PyObject *value, void *closure)
  87 {
  88         struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj);
  89         if (value == Py_None) {
  90                 object->share_name = NULL;
  91         } else {
  92                 object->share_name = NULL;
  93                 object->share_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
  94         }
  95         return 0;
  96 }
  97
  98 static PyGetSetDef py_dfs_referral_v1_getsetters[] = {
  99         { discard_const_p(char, "size"), py_dfs_referral_v1_get_size, py_dfs_referral_v1_set_size },
 100         { discard_const_p(char, "server_type"), py_dfs_referral_v1_get_server_type, py_dfs_referral_v1_set_server_type },
 101         { discard_const_p(char, "entry_flags"), py_dfs_referral_v1_get_entry_flags, py_dfs_referral_v1_set_entry_flags },
 102         { discard_const_p(char, "share_name"), py_dfs_referral_v1_get_share_name, py_dfs_referral_v1_set_share_name },
 103         { NULL }
 104 };
 105
 106 static PyObject *py_dfs_referral_v1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 107 {
 108         return pytalloc_new(struct dfs_referral_v1, type);
 109 }
 110
 111
 112 static PyTypeObject dfs_referral_v1_Type = {
 113         PyObject_HEAD_INIT(NULL) 0,
 114         .tp_name = "dfsblobs.dfs_referral_v1",
 115         .tp_getset = py_dfs_referral_v1_getsetters,
 116         .tp_methods = NULL,
 117         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 118         .tp_basicsize = sizeof(pytalloc_Object),
 119         .tp_new = py_dfs_referral_v1_new,
 120 };
 121
 122
 123 static PyObject *py_dfs_referral_v2_get_size(PyObject *obj, void *closure)
 124 {
 125         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 126         PyObject *py_size;
 127         py_size = PyInt_FromLong(object->size);
 128         return py_size;
 129 }
 130
 131 static int py_dfs_referral_v2_set_size(PyObject *py_obj, PyObject *value, void *closure)
 132 {
 133         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 134         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 135         object->size = PyInt_AsLong(value);
 136         return 0;
 137 }
 138
 139 static PyObject *py_dfs_referral_v2_get_server_type(PyObject *obj, void *closure)
 140 {
 141         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 142         PyObject *py_server_type;
 143         py_server_type = PyInt_FromLong(object->server_type);
 144         return py_server_type;
 145 }
 146
 147 static int py_dfs_referral_v2_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
 148 {
 149         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 150         if (PyLong_Check(value)) {
 151                 object->server_type = PyLong_AsLongLong(value);
 152         } else if (PyInt_Check(value)) {
 153                 object->server_type = PyInt_AsLong(value);
 154         } else {
 155                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 156                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 157                 return -1;
 158         }
 159         return 0;
 160 }
 161
 162 static PyObject *py_dfs_referral_v2_get_entry_flags(PyObject *obj, void *closure)
 163 {
 164         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 165         PyObject *py_entry_flags;
 166         py_entry_flags = PyInt_FromLong(object->entry_flags);
 167         return py_entry_flags;
 168 }
 169
 170 static int py_dfs_referral_v2_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure)
 171 {
 172         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 173         if (PyLong_Check(value)) {
 174                 object->entry_flags = PyLong_AsLongLong(value);
 175         } else if (PyInt_Check(value)) {
 176                 object->entry_flags = PyInt_AsLong(value);
 177         } else {
 178                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 179                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 180                 return -1;
 181         }
 182         return 0;
 183 }
 184
 185 static PyObject *py_dfs_referral_v2_get_proximity(PyObject *obj, void *closure)
 186 {
 187         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 188         PyObject *py_proximity;
 189         py_proximity = PyInt_FromLong(object->proximity);
 190         return py_proximity;
 191 }
 192
 193 static int py_dfs_referral_v2_set_proximity(PyObject *py_obj, PyObject *value, void *closure)
 194 {
 195         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 196         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 197         object->proximity = PyInt_AsLong(value);
 198         return 0;
 199 }
 200
 201 static PyObject *py_dfs_referral_v2_get_ttl(PyObject *obj, void *closure)
 202 {
 203         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 204         PyObject *py_ttl;
 205         py_ttl = PyInt_FromLong(object->ttl);
 206         return py_ttl;
 207 }
 208
 209 static int py_dfs_referral_v2_set_ttl(PyObject *py_obj, PyObject *value, void *closure)
 210 {
 211         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 212         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 213         object->ttl = PyInt_AsLong(value);
 214         return 0;
 215 }
 216
 217 static PyObject *py_dfs_referral_v2_get_DFS_path(PyObject *obj, void *closure)
 218 {
 219         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 220         PyObject *py_DFS_path;
 221         if (object->DFS_path == NULL) {
 222                 py_DFS_path = Py_None;
 223                 Py_INCREF(py_DFS_path);
 224         } else {
 225                 py_DFS_path = PyString_FromStringOrNULL(object->DFS_path);
 226         }
 227         return py_DFS_path;
 228 }
 229
 230 static int py_dfs_referral_v2_set_DFS_path(PyObject *py_obj, PyObject *value, void *closure)
 231 {
 232         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 233         if (value == Py_None) {
 234                 object->DFS_path = NULL;
 235         } else {
 236                 object->DFS_path = NULL;
 237                 object->DFS_path = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 238         }
 239         return 0;
 240 }
 241
 242 static PyObject *py_dfs_referral_v2_get_DFS_alt_path(PyObject *obj, void *closure)
 243 {
 244         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 245         PyObject *py_DFS_alt_path;
 246         if (object->DFS_alt_path == NULL) {
 247                 py_DFS_alt_path = Py_None;
 248                 Py_INCREF(py_DFS_alt_path);
 249         } else {
 250                 py_DFS_alt_path = PyString_FromStringOrNULL(object->DFS_alt_path);
 251         }
 252         return py_DFS_alt_path;
 253 }
 254
 255 static int py_dfs_referral_v2_set_DFS_alt_path(PyObject *py_obj, PyObject *value, void *closure)
 256 {
 257         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 258         if (value == Py_None) {
 259                 object->DFS_alt_path = NULL;
 260         } else {
 261                 object->DFS_alt_path = NULL;
 262                 object->DFS_alt_path = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 263         }
 264         return 0;
 265 }
 266
 267 static PyObject *py_dfs_referral_v2_get_netw_address(PyObject *obj, void *closure)
 268 {
 269         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj);
 270         PyObject *py_netw_address;
 271         if (object->netw_address == NULL) {
 272                 py_netw_address = Py_None;
 273                 Py_INCREF(py_netw_address);
 274         } else {
 275                 py_netw_address = PyString_FromStringOrNULL(object->netw_address);
 276         }
 277         return py_netw_address;
 278 }
 279
 280 static int py_dfs_referral_v2_set_netw_address(PyObject *py_obj, PyObject *value, void *closure)
 281 {
 282         struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj);
 283         if (value == Py_None) {
 284                 object->netw_address = NULL;
 285         } else {
 286                 object->netw_address = NULL;
 287                 object->netw_address = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 288         }
 289         return 0;
 290 }
 291
 292 static PyGetSetDef py_dfs_referral_v2_getsetters[] = {
 293         { discard_const_p(char, "size"), py_dfs_referral_v2_get_size, py_dfs_referral_v2_set_size },
 294         { discard_const_p(char, "server_type"), py_dfs_referral_v2_get_server_type, py_dfs_referral_v2_set_server_type },
 295         { discard_const_p(char, "entry_flags"), py_dfs_referral_v2_get_entry_flags, py_dfs_referral_v2_set_entry_flags },
 296         { discard_const_p(char, "proximity"), py_dfs_referral_v2_get_proximity, py_dfs_referral_v2_set_proximity },
 297         { discard_const_p(char, "ttl"), py_dfs_referral_v2_get_ttl, py_dfs_referral_v2_set_ttl },
 298         { discard_const_p(char, "DFS_path"), py_dfs_referral_v2_get_DFS_path, py_dfs_referral_v2_set_DFS_path },
 299         { discard_const_p(char, "DFS_alt_path"), py_dfs_referral_v2_get_DFS_alt_path, py_dfs_referral_v2_set_DFS_alt_path },
 300         { discard_const_p(char, "netw_address"), py_dfs_referral_v2_get_netw_address, py_dfs_referral_v2_set_netw_address },
 301         { NULL }
 302 };
 303
 304 static PyObject *py_dfs_referral_v2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 305 {
 306         return pytalloc_new(struct dfs_referral_v2, type);
 307 }
 308
 309
 310 static PyTypeObject dfs_referral_v2_Type = {
 311         PyObject_HEAD_INIT(NULL) 0,
 312         .tp_name = "dfsblobs.dfs_referral_v2",
 313         .tp_getset = py_dfs_referral_v2_getsetters,
 314         .tp_methods = NULL,
 315         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 316         .tp_basicsize = sizeof(pytalloc_Object),
 317         .tp_new = py_dfs_referral_v2_new,
 318 };
 319
 320
 321 static PyObject *py_dfs_normal_referral_get_DFS_path(PyObject *obj, void *closure)
 322 {
 323         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj);
 324         PyObject *py_DFS_path;
 325         if (object->DFS_path == NULL) {
 326                 py_DFS_path = Py_None;
 327                 Py_INCREF(py_DFS_path);
 328         } else {
 329                 py_DFS_path = PyString_FromStringOrNULL(object->DFS_path);
 330         }
 331         return py_DFS_path;
 332 }
 333
 334 static int py_dfs_normal_referral_set_DFS_path(PyObject *py_obj, PyObject *value, void *closure)
 335 {
 336         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj);
 337         if (value == Py_None) {
 338                 object->DFS_path = NULL;
 339         } else {
 340                 object->DFS_path = NULL;
 341                 object->DFS_path = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 342         }
 343         return 0;
 344 }
 345
 346 static PyObject *py_dfs_normal_referral_get_DFS_alt_path(PyObject *obj, void *closure)
 347 {
 348         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj);
 349         PyObject *py_DFS_alt_path;
 350         if (object->DFS_alt_path == NULL) {
 351                 py_DFS_alt_path = Py_None;
 352                 Py_INCREF(py_DFS_alt_path);
 353         } else {
 354                 py_DFS_alt_path = PyString_FromStringOrNULL(object->DFS_alt_path);
 355         }
 356         return py_DFS_alt_path;
 357 }
 358
 359 static int py_dfs_normal_referral_set_DFS_alt_path(PyObject *py_obj, PyObject *value, void *closure)
 360 {
 361         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj);
 362         if (value == Py_None) {
 363                 object->DFS_alt_path = NULL;
 364         } else {
 365                 object->DFS_alt_path = NULL;
 366                 object->DFS_alt_path = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 367         }
 368         return 0;
 369 }
 370
 371 static PyObject *py_dfs_normal_referral_get_netw_address(PyObject *obj, void *closure)
 372 {
 373         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj);
 374         PyObject *py_netw_address;
 375         if (object->netw_address == NULL) {
 376                 py_netw_address = Py_None;
 377                 Py_INCREF(py_netw_address);
 378         } else {
 379                 py_netw_address = PyString_FromStringOrNULL(object->netw_address);
 380         }
 381         return py_netw_address;
 382 }
 383
 384 static int py_dfs_normal_referral_set_netw_address(PyObject *py_obj, PyObject *value, void *closure)
 385 {
 386         struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj);
 387         if (value == Py_None) {
 388                 object->netw_address = NULL;
 389         } else {
 390                 object->netw_address = NULL;
 391                 object->netw_address = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 392         }
 393         return 0;
 394 }
 395
 396 static PyGetSetDef py_dfs_normal_referral_getsetters[] = {
 397         { discard_const_p(char, "DFS_path"), py_dfs_normal_referral_get_DFS_path, py_dfs_normal_referral_set_DFS_path },
 398         { discard_const_p(char, "DFS_alt_path"), py_dfs_normal_referral_get_DFS_alt_path, py_dfs_normal_referral_set_DFS_alt_path },
 399         { discard_const_p(char, "netw_address"), py_dfs_normal_referral_get_netw_address, py_dfs_normal_referral_set_netw_address },
 400         { NULL }
 401 };
 402
 403 static PyObject *py_dfs_normal_referral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 404 {
 405         return pytalloc_new(struct dfs_normal_referral, type);
 406 }
 407
 408
 409 static PyTypeObject dfs_normal_referral_Type = {
 410         PyObject_HEAD_INIT(NULL) 0,
 411         .tp_name = "dfsblobs.dfs_normal_referral",
 412         .tp_getset = py_dfs_normal_referral_getsetters,
 413         .tp_methods = NULL,
 414         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 415         .tp_basicsize = sizeof(pytalloc_Object),
 416         .tp_new = py_dfs_normal_referral_new,
 417 };
 418
 419
 420 static PyObject *py_dfs_domain_referral_get_special_name(PyObject *obj, void *closure)
 421 {
 422         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj);
 423         PyObject *py_special_name;
 424         if (object->special_name == NULL) {
 425                 py_special_name = Py_None;
 426                 Py_INCREF(py_special_name);
 427         } else {
 428                 py_special_name = PyString_FromStringOrNULL(object->special_name);
 429         }
 430         return py_special_name;
 431 }
 432
 433 static int py_dfs_domain_referral_set_special_name(PyObject *py_obj, PyObject *value, void *closure)
 434 {
 435         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj);
 436         if (value == Py_None) {
 437                 object->special_name = NULL;
 438         } else {
 439                 object->special_name = NULL;
 440                 object->special_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 441         }
 442         return 0;
 443 }
 444
 445 static PyObject *py_dfs_domain_referral_get_nb_expanded_names(PyObject *obj, void *closure)
 446 {
 447         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj);
 448         PyObject *py_nb_expanded_names;
 449         py_nb_expanded_names = PyInt_FromLong(object->nb_expanded_names);
 450         return py_nb_expanded_names;
 451 }
 452
 453 static int py_dfs_domain_referral_set_nb_expanded_names(PyObject *py_obj, PyObject *value, void *closure)
 454 {
 455         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj);
 456         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 457         object->nb_expanded_names = PyInt_AsLong(value);
 458         return 0;
 459 }
 460
 461 static PyObject *py_dfs_domain_referral_get_expanded_names(PyObject *obj, void *closure)
 462 {
 463         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj);
 464         PyObject *py_expanded_names;
 465         if (object->expanded_names == NULL) {
 466                 py_expanded_names = Py_None;
 467                 Py_INCREF(py_expanded_names);
 468         } else {
 469                 py_expanded_names = pytalloc_CObject_FromTallocPtr(object->expanded_names);
 470         }
 471         return py_expanded_names;
 472 }
 473
 474 static int py_dfs_domain_referral_set_expanded_names(PyObject *py_obj, PyObject *value, void *closure)
 475 {
 476         struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj);
 477         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->expanded_names);
 478         if (value == Py_None) {
 479                 object->expanded_names = NULL;
 480         } else {
 481                 object->expanded_names = NULL;
 482                 object->expanded_names = PyCObject_AsVoidPtr(value);
 483         }
 484         return 0;
 485 }
 486
 487 static PyGetSetDef py_dfs_domain_referral_getsetters[] = {
 488         { discard_const_p(char, "special_name"), py_dfs_domain_referral_get_special_name, py_dfs_domain_referral_set_special_name },
 489         { discard_const_p(char, "nb_expanded_names"), py_dfs_domain_referral_get_nb_expanded_names, py_dfs_domain_referral_set_nb_expanded_names },
 490         { discard_const_p(char, "expanded_names"), py_dfs_domain_referral_get_expanded_names, py_dfs_domain_referral_set_expanded_names },
 491         { NULL }
 492 };
 493
 494 static PyObject *py_dfs_domain_referral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 495 {
 496         return pytalloc_new(struct dfs_domain_referral, type);
 497 }
 498
 499
 500 static PyTypeObject dfs_domain_referral_Type = {
 501         PyObject_HEAD_INIT(NULL) 0,
 502         .tp_name = "dfsblobs.dfs_domain_referral",
 503         .tp_getset = py_dfs_domain_referral_getsetters,
 504         .tp_methods = NULL,
 505         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 506         .tp_basicsize = sizeof(pytalloc_Object),
 507         .tp_new = py_dfs_domain_referral_new,
 508 };
 509
 510 PyObject *py_import_dfs_referral(TALLOC_CTX *mem_ctx, int level, union dfs_referral *in)
 511 {
 512         PyObject *ret;
 513
 514         switch (level) {
 515                 case 0:
 516                         ret = pytalloc_reference_ex(&dfs_normal_referral_Type, mem_ctx, &in->r1);
 517                         return ret;
 518
 519                 case 2:
 520                         ret = pytalloc_reference_ex(&dfs_domain_referral_Type, mem_ctx, &in->r2);
 521                         return ret;
 522
 523                 default:
 524                         ret = Py_None;
 525                         Py_INCREF(ret);
 526                         return ret;
 527
 528         }
 529         PyErr_SetString(PyExc_TypeError, "unknown union level");
 530         return NULL;
 531 }
 532
 533 union dfs_referral *py_export_dfs_referral(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 534 {
 535         union dfs_referral *ret = talloc_zero(mem_ctx, union dfs_referral);
 536         switch (level) {
 537                 case 0:
 538                         PY_CHECK_TYPE(&dfs_normal_referral_Type, in, talloc_free(ret); return NULL;);
 539                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 540                                 PyErr_NoMemory();
 541                                 talloc_free(ret); return NULL;
 542                         }
 543                         ret->r1 = *(struct dfs_normal_referral *)pytalloc_get_ptr(in);
 544                         break;
 545
 546                 case 2:
 547                         PY_CHECK_TYPE(&dfs_domain_referral_Type, in, talloc_free(ret); return NULL;);
 548                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 549                                 PyErr_NoMemory();
 550                                 talloc_free(ret); return NULL;
 551                         }
 552                         ret->r2 = *(struct dfs_domain_referral *)pytalloc_get_ptr(in);
 553                         break;
 554
 555                 default:
 556                         break;
 557
 558         }
 559
 560         return ret;
 561 }
 562
 563 PyObject *py_import_dfs_padding(TALLOC_CTX *mem_ctx, int level, union dfs_padding *in)
 564 {
 565         PyObject *ret;
 566
 567         switch (level) {
 568                 case 16:
 569                         ret = PyList_New(16);
 570                         if (ret == NULL) {
 571                                 return NULL;
 572                         }
 573                         {
 574                                 int value_cntr_0;
 575                                 for (value_cntr_0 = 0; value_cntr_0 < 16; value_cntr_0++) {
 576                                         PyObject *py_value_0;
 577                                         py_value_0 = PyInt_FromLong(in->value[value_cntr_0]);
 578                                         PyList_SetItem(ret, value_cntr_0, py_value_0);
 579                                 }
 580                         }
 581                         return ret;
 582
 583                 default:
 584                         ret = Py_None;
 585                         Py_INCREF(ret);
 586                         return ret;
 587
 588         }
 589         PyErr_SetString(PyExc_TypeError, "unknown union level");
 590         return NULL;
 591 }
 592
 593 union dfs_padding *py_export_dfs_padding(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 594 {
 595         union dfs_padding *ret = talloc_zero(mem_ctx, union dfs_padding);
 596         switch (level) {
 597                 case 16:
 598                         PY_CHECK_TYPE(&PyList_Type, in, talloc_free(ret); return NULL;);
 599                         {
 600                                 int value_cntr_0;
 601                                 for (value_cntr_0 = 0; value_cntr_0 < PyList_GET_SIZE(in); value_cntr_0++) {
 602                                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(in, value_cntr_0), talloc_free(ret); return NULL;);
 603                                         ret->value[value_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(in, value_cntr_0));
 604                                 }
 605                         }
 606                         break;
 607
 608                 default:
 609                         break;
 610
 611         }
 612
 613         return ret;
 614 }
 615
 616
 617 static PyObject *py_dfs_referral_v3_get_size(PyObject *obj, void *closure)
 618 {
 619         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 620         PyObject *py_size;
 621         py_size = PyInt_FromLong(object->size);
 622         return py_size;
 623 }
 624
 625 static int py_dfs_referral_v3_set_size(PyObject *py_obj, PyObject *value, void *closure)
 626 {
 627         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 628         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 629         object->size = PyInt_AsLong(value);
 630         return 0;
 631 }
 632
 633 static PyObject *py_dfs_referral_v3_get_server_type(PyObject *obj, void *closure)
 634 {
 635         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 636         PyObject *py_server_type;
 637         py_server_type = PyInt_FromLong(object->server_type);
 638         return py_server_type;
 639 }
 640
 641 static int py_dfs_referral_v3_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
 642 {
 643         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 644         if (PyLong_Check(value)) {
 645                 object->server_type = PyLong_AsLongLong(value);
 646         } else if (PyInt_Check(value)) {
 647                 object->server_type = PyInt_AsLong(value);
 648         } else {
 649                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 650                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 651                 return -1;
 652         }
 653         return 0;
 654 }
 655
 656 static PyObject *py_dfs_referral_v3_get_entry_flags(PyObject *obj, void *closure)
 657 {
 658         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 659         PyObject *py_entry_flags;
 660         py_entry_flags = PyInt_FromLong(object->entry_flags);
 661         return py_entry_flags;
 662 }
 663
 664 static int py_dfs_referral_v3_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure)
 665 {
 666         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 667         if (PyLong_Check(value)) {
 668                 object->entry_flags = PyLong_AsLongLong(value);
 669         } else if (PyInt_Check(value)) {
 670                 object->entry_flags = PyInt_AsLong(value);
 671         } else {
 672                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 673                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 674                 return -1;
 675         }
 676         return 0;
 677 }
 678
 679 static PyObject *py_dfs_referral_v3_get_ttl(PyObject *obj, void *closure)
 680 {
 681         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 682         PyObject *py_ttl;
 683         py_ttl = PyInt_FromLong(object->ttl);
 684         return py_ttl;
 685 }
 686
 687 static int py_dfs_referral_v3_set_ttl(PyObject *py_obj, PyObject *value, void *closure)
 688 {
 689         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 690         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 691         object->ttl = PyInt_AsLong(value);
 692         return 0;
 693 }
 694
 695 static PyObject *py_dfs_referral_v3_get_referrals(PyObject *obj, void *closure)
 696 {
 697         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 698         PyObject *py_referrals;
 699         py_referrals = py_import_dfs_referral(pytalloc_get_mem_ctx(obj), object->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP, &object->referrals);
 700         if (py_referrals == NULL) {
 701                 return NULL;
 702         }
 703         return py_referrals;
 704 }
 705
 706 static int py_dfs_referral_v3_set_referrals(PyObject *py_obj, PyObject *value, void *closure)
 707 {
 708         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 709         {
 710                 union dfs_referral *referrals_switch_0;
 711                 referrals_switch_0 = py_export_dfs_referral(pytalloc_get_mem_ctx(py_obj), object->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP, value);
 712                 if (referrals_switch_0 == NULL) {
 713                         return -1;
 714                 }
 715                 object->referrals = *referrals_switch_0;
 716         }
 717         return 0;
 718 }
 719
 720 static PyObject *py_dfs_referral_v3_get_service_site_guid(PyObject *obj, void *closure)
 721 {
 722         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj);
 723         PyObject *py_service_site_guid;
 724         py_service_site_guid = py_import_dfs_padding(pytalloc_get_mem_ctx(obj), object->size - 18, &object->service_site_guid);
 725         if (py_service_site_guid == NULL) {
 726                 return NULL;
 727         }
 728         return py_service_site_guid;
 729 }
 730
 731 static int py_dfs_referral_v3_set_service_site_guid(PyObject *py_obj, PyObject *value, void *closure)
 732 {
 733         struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj);
 734         {
 735                 union dfs_padding *service_site_guid_switch_0;
 736                 service_site_guid_switch_0 = py_export_dfs_padding(pytalloc_get_mem_ctx(py_obj), object->size - 18, value);
 737                 if (service_site_guid_switch_0 == NULL) {
 738                         return -1;
 739                 }
 740                 object->service_site_guid = *service_site_guid_switch_0;
 741         }
 742         return 0;
 743 }
 744
 745 static PyGetSetDef py_dfs_referral_v3_getsetters[] = {
 746         { discard_const_p(char, "size"), py_dfs_referral_v3_get_size, py_dfs_referral_v3_set_size },
 747         { discard_const_p(char, "server_type"), py_dfs_referral_v3_get_server_type, py_dfs_referral_v3_set_server_type },
 748         { discard_const_p(char, "entry_flags"), py_dfs_referral_v3_get_entry_flags, py_dfs_referral_v3_set_entry_flags },
 749         { discard_const_p(char, "ttl"), py_dfs_referral_v3_get_ttl, py_dfs_referral_v3_set_ttl },
 750         { discard_const_p(char, "referrals"), py_dfs_referral_v3_get_referrals, py_dfs_referral_v3_set_referrals },
 751         { discard_const_p(char, "service_site_guid"), py_dfs_referral_v3_get_service_site_guid, py_dfs_referral_v3_set_service_site_guid },
 752         { NULL }
 753 };
 754
 755 static PyObject *py_dfs_referral_v3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 756 {
 757         return pytalloc_new(struct dfs_referral_v3, type);
 758 }
 759
 760
 761 static PyTypeObject dfs_referral_v3_Type = {
 762         PyObject_HEAD_INIT(NULL) 0,
 763         .tp_name = "dfsblobs.dfs_referral_v3",
 764         .tp_getset = py_dfs_referral_v3_getsetters,
 765         .tp_methods = NULL,
 766         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 767         .tp_basicsize = sizeof(pytalloc_Object),
 768         .tp_new = py_dfs_referral_v3_new,
 769 };
 770
 771 PyObject *py_import_dfs_referral_version(TALLOC_CTX *mem_ctx, int level, union dfs_referral_version *in)
 772 {
 773         PyObject *ret;
 774
 775         switch (level) {
 776                 case 1:
 777                         ret = pytalloc_reference_ex(&dfs_referral_v1_Type, mem_ctx, &in->v1);
 778                         return ret;
 779
 780                 case 2:
 781                         ret = pytalloc_reference_ex(&dfs_referral_v2_Type, mem_ctx, &in->v2);
 782                         return ret;
 783
 784                 case 3:
 785                         ret = pytalloc_reference_ex(&dfs_referral_v3_Type, mem_ctx, &in->v3);
 786                         return ret;
 787
 788                 case 4:
 789                         ret = pytalloc_reference_ex(&dfs_referral_v3_Type, mem_ctx, &in->v4);
 790                         return ret;
 791
 792                 default:
 793                         ret = Py_None;
 794                         Py_INCREF(ret);
 795                         return ret;
 796
 797         }
 798         PyErr_SetString(PyExc_TypeError, "unknown union level");
 799         return NULL;
 800 }
 801
 802 union dfs_referral_version *py_export_dfs_referral_version(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 803 {
 804         union dfs_referral_version *ret = talloc_zero(mem_ctx, union dfs_referral_version);
 805         switch (level) {
 806                 case 1:
 807                         PY_CHECK_TYPE(&dfs_referral_v1_Type, in, talloc_free(ret); return NULL;);
 808                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 809                                 PyErr_NoMemory();
 810                                 talloc_free(ret); return NULL;
 811                         }
 812                         ret->v1 = *(struct dfs_referral_v1 *)pytalloc_get_ptr(in);
 813                         break;
 814
 815                 case 2:
 816                         PY_CHECK_TYPE(&dfs_referral_v2_Type, in, talloc_free(ret); return NULL;);
 817                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 818                                 PyErr_NoMemory();
 819                                 talloc_free(ret); return NULL;
 820                         }
 821                         ret->v2 = *(struct dfs_referral_v2 *)pytalloc_get_ptr(in);
 822                         break;
 823
 824                 case 3:
 825                         PY_CHECK_TYPE(&dfs_referral_v3_Type, in, talloc_free(ret); return NULL;);
 826                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 827                                 PyErr_NoMemory();
 828                                 talloc_free(ret); return NULL;
 829                         }
 830                         ret->v3 = *(struct dfs_referral_v3 *)pytalloc_get_ptr(in);
 831                         break;
 832
 833                 case 4:
 834                         PY_CHECK_TYPE(&dfs_referral_v3_Type, in, talloc_free(ret); return NULL;);
 835                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 836                                 PyErr_NoMemory();
 837                                 talloc_free(ret); return NULL;
 838                         }
 839                         ret->v4 = *(struct dfs_referral_v3 *)pytalloc_get_ptr(in);
 840                         break;
 841
 842                 default:
 843                         break;
 844
 845         }
 846
 847         return ret;
 848 }
 849
 850
 851 static PyObject *py_dfs_referral_type_get_version(PyObject *obj, void *closure)
 852 {
 853         struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(obj);
 854         PyObject *py_version;
 855         py_version = PyInt_FromLong(object->version);
 856         return py_version;
 857 }
 858
 859 static int py_dfs_referral_type_set_version(PyObject *py_obj, PyObject *value, void *closure)
 860 {
 861         struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(py_obj);
 862         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 863         object->version = PyInt_AsLong(value);
 864         return 0;
 865 }
 866
 867 static PyObject *py_dfs_referral_type_get_referral(PyObject *obj, void *closure)
 868 {
 869         struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(obj);
 870         PyObject *py_referral;
 871         py_referral = py_import_dfs_referral_version(pytalloc_get_mem_ctx(obj), object->version, &object->referral);
 872         if (py_referral == NULL) {
 873                 return NULL;
 874         }
 875         return py_referral;
 876 }
 877
 878 static int py_dfs_referral_type_set_referral(PyObject *py_obj, PyObject *value, void *closure)
 879 {
 880         struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(py_obj);
 881         {
 882                 union dfs_referral_version *referral_switch_0;
 883                 referral_switch_0 = py_export_dfs_referral_version(pytalloc_get_mem_ctx(py_obj), object->version, value);
 884                 if (referral_switch_0 == NULL) {
 885                         return -1;
 886                 }
 887                 object->referral = *referral_switch_0;
 888         }
 889         return 0;
 890 }
 891
 892 static PyGetSetDef py_dfs_referral_type_getsetters[] = {
 893         { discard_const_p(char, "version"), py_dfs_referral_type_get_version, py_dfs_referral_type_set_version },
 894         { discard_const_p(char, "referral"), py_dfs_referral_type_get_referral, py_dfs_referral_type_set_referral },
 895         { NULL }
 896 };
 897
 898 static PyObject *py_dfs_referral_type_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 899 {
 900         return pytalloc_new(struct dfs_referral_type, type);
 901 }
 902
 903
 904 static PyTypeObject dfs_referral_type_Type = {
 905         PyObject_HEAD_INIT(NULL) 0,
 906         .tp_name = "dfsblobs.dfs_referral_type",
 907         .tp_getset = py_dfs_referral_type_getsetters,
 908         .tp_methods = NULL,
 909         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 910         .tp_basicsize = sizeof(pytalloc_Object),
 911         .tp_new = py_dfs_referral_type_new,
 912 };
 913
 914
 915 static PyObject *py_dfs_referral_resp_get_path_consumed(PyObject *obj, void *closure)
 916 {
 917         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj);
 918         PyObject *py_path_consumed;
 919         py_path_consumed = PyInt_FromLong(object->path_consumed);
 920         return py_path_consumed;
 921 }
 922
 923 static int py_dfs_referral_resp_set_path_consumed(PyObject *py_obj, PyObject *value, void *closure)
 924 {
 925         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
 926         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 927         object->path_consumed = PyInt_AsLong(value);
 928         return 0;
 929 }
 930
 931 static PyObject *py_dfs_referral_resp_get_nb_referrals(PyObject *obj, void *closure)
 932 {
 933         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj);
 934         PyObject *py_nb_referrals;
 935         py_nb_referrals = PyInt_FromLong(object->nb_referrals);
 936         return py_nb_referrals;
 937 }
 938
 939 static int py_dfs_referral_resp_set_nb_referrals(PyObject *py_obj, PyObject *value, void *closure)
 940 {
 941         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
 942         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 943         object->nb_referrals = PyInt_AsLong(value);
 944         return 0;
 945 }
 946
 947 static PyObject *py_dfs_referral_resp_get_header_flags(PyObject *obj, void *closure)
 948 {
 949         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj);
 950         PyObject *py_header_flags;
 951         py_header_flags = PyInt_FromLong(object->header_flags);
 952         return py_header_flags;
 953 }
 954
 955 static int py_dfs_referral_resp_set_header_flags(PyObject *py_obj, PyObject *value, void *closure)
 956 {
 957         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
 958         if (PyLong_Check(value)) {
 959                 object->header_flags = PyLong_AsLongLong(value);
 960         } else if (PyInt_Check(value)) {
 961                 object->header_flags = PyInt_AsLong(value);
 962         } else {
 963                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 964                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 965                 return -1;
 966         }
 967         return 0;
 968 }
 969
 970 static PyObject *py_dfs_referral_resp_get_referral_entries(PyObject *obj, void *closure)
 971 {
 972         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj);
 973         PyObject *py_referral_entries;
 974         py_referral_entries = PyList_New(object->nb_referrals);
 975         if (py_referral_entries == NULL) {
 976                 return NULL;
 977         }
 978         {
 979                 int referral_entries_cntr_0;
 980                 for (referral_entries_cntr_0 = 0; referral_entries_cntr_0 < object->nb_referrals; referral_entries_cntr_0++) {
 981                         PyObject *py_referral_entries_0;
 982                         py_referral_entries_0 = pytalloc_reference_ex(&dfs_referral_type_Type, object->referral_entries, &object->referral_entries[referral_entries_cntr_0]);
 983                         PyList_SetItem(py_referral_entries, referral_entries_cntr_0, py_referral_entries_0);
 984                 }
 985         }
 986         return py_referral_entries;
 987 }
 988
 989 static int py_dfs_referral_resp_set_referral_entries(PyObject *py_obj, PyObject *value, void *closure)
 990 {
 991         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
 992         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 993         {
 994                 int referral_entries_cntr_0;
 995                 object->referral_entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->referral_entries, PyList_GET_SIZE(value));
 996                 if (!object->referral_entries) { return -1;; }
 997                 talloc_set_name_const(object->referral_entries, "ARRAY: object->referral_entries");
 998                 for (referral_entries_cntr_0 = 0; referral_entries_cntr_0 < PyList_GET_SIZE(value); referral_entries_cntr_0++) {
 999                         PY_CHECK_TYPE(&dfs_referral_type_Type, PyList_GET_ITEM(value, referral_entries_cntr_0), return -1;);
1000                         if (talloc_reference(object->referral_entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, referral_entries_cntr_0))) == NULL) {
1001                                 PyErr_NoMemory();
1002                                 return -1;
1003                         }
1004                         object->referral_entries[referral_entries_cntr_0] = *(struct dfs_referral_type *)pytalloc_get_ptr(PyList_GET_ITEM(value, referral_entries_cntr_0));
1005                 }
1006         }
1007         return 0;
1008 }
1009
1010 static PyGetSetDef py_dfs_referral_resp_getsetters[] = {
1011         { discard_const_p(char, "path_consumed"), py_dfs_referral_resp_get_path_consumed, py_dfs_referral_resp_set_path_consumed },
1012         { discard_const_p(char, "nb_referrals"), py_dfs_referral_resp_get_nb_referrals, py_dfs_referral_resp_set_nb_referrals },
1013         { discard_const_p(char, "header_flags"), py_dfs_referral_resp_get_header_flags, py_dfs_referral_resp_set_header_flags },
1014         { discard_const_p(char, "referral_entries"), py_dfs_referral_resp_get_referral_entries, py_dfs_referral_resp_set_referral_entries },
1015         { NULL }
1016 };
1017
1018 static PyObject *py_dfs_referral_resp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1019 {
1020         return pytalloc_new(struct dfs_referral_resp, type);
1021 }
1022
1023 static PyObject *py_dfs_referral_resp_ndr_pack(PyObject *py_obj)
1024 {
1025         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
1026         DATA_BLOB blob;
1027         enum ndr_err_code err;
1028         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_dfs_referral_resp);
1029         if (err != NDR_ERR_SUCCESS) {
1030                 PyErr_SetNdrError(err);
1031                 return NULL;
1032         }
1033
1034         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1035 }
1036
1037 static PyObject *py_dfs_referral_resp_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
1038 {
1039         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
1040         DATA_BLOB blob;
1041         int blob_length = 0;
1042         enum ndr_err_code err;
1043         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
1044         PyObject *allow_remaining_obj = NULL;
1045         bool allow_remaining = false;
1046
1047         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
1048                 discard_const_p(char *, kwnames),
1049                 &blob.data, &blob_length,
1050                 &allow_remaining_obj)) {
1051                 return NULL;
1052         }
1053         blob.length = blob_length;
1054
1055         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
1056                 allow_remaining = true;
1057         }
1058
1059         if (allow_remaining) {
1060                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_referral_resp);
1061         } else {
1062                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_referral_resp);
1063         }
1064         if (err != NDR_ERR_SUCCESS) {
1065                 PyErr_SetNdrError(err);
1066                 return NULL;
1067         }
1068
1069         Py_RETURN_NONE;
1070 }
1071
1072 static PyObject *py_dfs_referral_resp_ndr_print(PyObject *py_obj)
1073 {
1074         struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj);
1075         PyObject *ret;
1076         char *retstr;
1077
1078         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_dfs_referral_resp, "dfs_referral_resp", object);
1079         ret = PyString_FromString(retstr);
1080         talloc_free(retstr);
1081
1082         return ret;
1083 }
1084
1085 static PyMethodDef py_dfs_referral_resp_methods[] = {
1086         { "__ndr_pack__", (PyCFunction)py_dfs_referral_resp_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1087         { "__ndr_unpack__", (PyCFunction)py_dfs_referral_resp_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
1088         { "__ndr_print__", (PyCFunction)py_dfs_referral_resp_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1089         { NULL, NULL, 0, NULL }
1090 };
1091
1092
1093 static PyTypeObject dfs_referral_resp_Type = {
1094         PyObject_HEAD_INIT(NULL) 0,
1095         .tp_name = "dfsblobs.dfs_referral_resp",
1096         .tp_getset = py_dfs_referral_resp_getsetters,
1097         .tp_methods = py_dfs_referral_resp_methods,
1098         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1099         .tp_basicsize = sizeof(pytalloc_Object),
1100         .tp_new = py_dfs_referral_resp_new,
1101 };
1102
1103
1104 static PyObject *py_dfs_GetDFSReferral_in_get_max_referral_level(PyObject *obj, void *closure)
1105 {
1106         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(obj);
1107         PyObject *py_max_referral_level;
1108         py_max_referral_level = PyInt_FromLong(object->max_referral_level);
1109         return py_max_referral_level;
1110 }
1111
1112 static int py_dfs_GetDFSReferral_in_set_max_referral_level(PyObject *py_obj, PyObject *value, void *closure)
1113 {
1114         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj);
1115         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1116         object->max_referral_level = PyInt_AsLong(value);
1117         return 0;
1118 }
1119
1120 static PyObject *py_dfs_GetDFSReferral_in_get_servername(PyObject *obj, void *closure)
1121 {
1122         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(obj);
1123         PyObject *py_servername;
1124         py_servername = PyString_FromStringOrNULL(object->servername);
1125         return py_servername;
1126 }
1127
1128 static int py_dfs_GetDFSReferral_in_set_servername(PyObject *py_obj, PyObject *value, void *closure)
1129 {
1130         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj);
1131         object->servername = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
1132         return 0;
1133 }
1134
1135 static PyGetSetDef py_dfs_GetDFSReferral_in_getsetters[] = {
1136         { discard_const_p(char, "max_referral_level"), py_dfs_GetDFSReferral_in_get_max_referral_level, py_dfs_GetDFSReferral_in_set_max_referral_level },
1137         { discard_const_p(char, "servername"), py_dfs_GetDFSReferral_in_get_servername, py_dfs_GetDFSReferral_in_set_servername },
1138         { NULL }
1139 };
1140
1141 static PyObject *py_dfs_GetDFSReferral_in_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1142 {
1143         return pytalloc_new(struct dfs_GetDFSReferral_in, type);
1144 }
1145
1146 static PyObject *py_dfs_GetDFSReferral_in_ndr_pack(PyObject *py_obj)
1147 {
1148         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj);
1149         DATA_BLOB blob;
1150         enum ndr_err_code err;
1151         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_dfs_GetDFSReferral_in);
1152         if (err != NDR_ERR_SUCCESS) {
1153                 PyErr_SetNdrError(err);
1154                 return NULL;
1155         }
1156
1157         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1158 }
1159
1160 static PyObject *py_dfs_GetDFSReferral_in_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
1161 {
1162         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj);
1163         DATA_BLOB blob;
1164         int blob_length = 0;
1165         enum ndr_err_code err;
1166         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
1167         PyObject *allow_remaining_obj = NULL;
1168         bool allow_remaining = false;
1169
1170         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
1171                 discard_const_p(char *, kwnames),
1172                 &blob.data, &blob_length,
1173                 &allow_remaining_obj)) {
1174                 return NULL;
1175         }
1176         blob.length = blob_length;
1177
1178         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
1179                 allow_remaining = true;
1180         }
1181
1182         if (allow_remaining) {
1183                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetDFSReferral_in);
1184         } else {
1185                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetDFSReferral_in);
1186         }
1187         if (err != NDR_ERR_SUCCESS) {
1188                 PyErr_SetNdrError(err);
1189                 return NULL;
1190         }
1191
1192         Py_RETURN_NONE;
1193 }
1194
1195 static PyObject *py_dfs_GetDFSReferral_in_ndr_print(PyObject *py_obj)
1196 {
1197         struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj);
1198         PyObject *ret;
1199         char *retstr;
1200
1201         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_dfs_GetDFSReferral_in, "dfs_GetDFSReferral_in", object);
1202         ret = PyString_FromString(retstr);
1203         talloc_free(retstr);
1204
1205         return ret;
1206 }
1207
1208 static PyMethodDef py_dfs_GetDFSReferral_in_methods[] = {
1209         { "__ndr_pack__", (PyCFunction)py_dfs_GetDFSReferral_in_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1210         { "__ndr_unpack__", (PyCFunction)py_dfs_GetDFSReferral_in_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
1211         { "__ndr_print__", (PyCFunction)py_dfs_GetDFSReferral_in_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1212         { NULL, NULL, 0, NULL }
1213 };
1214
1215
1216 static PyTypeObject dfs_GetDFSReferral_in_Type = {
1217         PyObject_HEAD_INIT(NULL) 0,
1218         .tp_name = "dfsblobs.dfs_GetDFSReferral_in",
1219         .tp_getset = py_dfs_GetDFSReferral_in_getsetters,
1220         .tp_methods = py_dfs_GetDFSReferral_in_methods,
1221         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1222         .tp_basicsize = sizeof(pytalloc_Object),
1223         .tp_new = py_dfs_GetDFSReferral_in_new,
1224 };
1225
1226
1227 static bool pack_py_dfs_GetDFSReferral_args_in(PyObject *args, PyObject *kwargs, struct dfs_GetDFSReferral *r)
1228 {
1229         PyObject *py_req;
1230         const char *kwnames[] = {
1231                 "req", NULL
1232         };
1233
1234         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:dfs_GetDFSReferral", discard_const_p(char *, kwnames), &py_req)) {
1235                 return false;
1236         }
1237
1238         PY_CHECK_TYPE(&dfs_GetDFSReferral_in_Type, py_req, return false;);
1239         if (talloc_reference(r, pytalloc_get_mem_ctx(py_req)) == NULL) {
1240                 PyErr_NoMemory();
1241                 return false;
1242         }
1243         r->in.req = *(struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_req);
1244         return true;
1245 }
1246
1247 static PyObject *unpack_py_dfs_GetDFSReferral_args_out(struct dfs_GetDFSReferral *r)
1248 {
1249         PyObject *result;
1250         PyObject *py_resp;
1251         py_resp = pytalloc_reference_ex(&dfs_referral_resp_Type, r->out.resp, r->out.resp);
1252         result = py_resp;
1253         return result;
1254 }
1255
1256 const struct PyNdrRpcMethodDef py_ndr_dfsblobs_methods[] = {
1257         { "dfs_GetDFSReferral", "S.dfs_GetDFSReferral(req) -> resp", (py_dcerpc_call_fn)dcerpc_dfs_GetDFSReferral_r, (py_data_pack_fn)pack_py_dfs_GetDFSReferral_args_in, (py_data_unpack_fn)unpack_py_dfs_GetDFSReferral_args_out, 0, &ndr_table_dfsblobs },
1258         { NULL }
1259 };
1260
1261 static PyObject *interface_dfsblobs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1262 {
1263         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_dfsblobs);
1264 }
1265
1266 #define PY_DOC_DFSBLOBS "dfs referral blobs"
1267 static PyTypeObject dfsblobs_InterfaceType = {
1268         PyObject_HEAD_INIT(NULL) 0,
1269         .tp_name = "dfsblobs.dfsblobs",
1270         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
1271         .tp_doc = "dfsblobs(binding, lp_ctx=None, credentials=None) -> connection\n"
1272 "\n"
1273 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
1274 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
1275 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_DFSBLOBS,
1276         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1277         .tp_new = interface_dfsblobs_new,
1278 };
1279
1280 static PyMethodDef dfsblobs_methods[] = {
1281         { NULL, NULL, 0, NULL }
1282 };
1283
1284 void initdfsblobs(void)
1285 {
1286         PyObject *m;
1287         PyObject *dep_talloc;
1288         PyObject *dep_samba_dcerpc_misc;
1289         PyObject *dep_samba_dcerpc_base;
1290
1291         dep_talloc = PyImport_ImportModule("talloc");
1292         if (dep_talloc == NULL)
1293                 return;
1294
1295         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
1296         if (dep_samba_dcerpc_misc == NULL)
1297                 return;
1298
1299         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
1300         if (dep_samba_dcerpc_base == NULL)
1301                 return;
1302
1303         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
1304         if (Object_Type == NULL)
1305                 return;
1306
1307         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
1308         if (ClientConnection_Type == NULL)
1309                 return;
1310
1311         dfs_referral_v1_Type.tp_base = Object_Type;
1312
1313         dfs_referral_v2_Type.tp_base = Object_Type;
1314
1315         dfs_normal_referral_Type.tp_base = Object_Type;
1316
1317         dfs_domain_referral_Type.tp_base = Object_Type;
1318
1319         dfs_referral_v3_Type.tp_base = Object_Type;
1320
1321         dfs_referral_type_Type.tp_base = Object_Type;
1322
1323         dfs_referral_resp_Type.tp_base = Object_Type;
1324
1325         dfs_GetDFSReferral_in_Type.tp_base = Object_Type;
1326
1327         dfsblobs_InterfaceType.tp_base = ClientConnection_Type;
1328
1329         if (PyType_Ready(&dfs_referral_v1_Type) < 0)
1330                 return;
1331         if (PyType_Ready(&dfs_referral_v2_Type) < 0)
1332                 return;
1333         if (PyType_Ready(&dfs_normal_referral_Type) < 0)
1334                 return;
1335         if (PyType_Ready(&dfs_domain_referral_Type) < 0)
1336                 return;
1337         if (PyType_Ready(&dfs_referral_v3_Type) < 0)
1338                 return;
1339         if (PyType_Ready(&dfs_referral_type_Type) < 0)
1340                 return;
1341         if (PyType_Ready(&dfs_referral_resp_Type) < 0)
1342                 return;
1343         if (PyType_Ready(&dfs_GetDFSReferral_in_Type) < 0)
1344                 return;
1345         if (PyType_Ready(&dfsblobs_InterfaceType) < 0)
1346                 return;
1347         if (!PyInterface_AddNdrRpcMethods(&dfsblobs_InterfaceType, py_ndr_dfsblobs_methods))
1348                 return;
1349
1350 #ifdef PY_DFS_REFERRAL_V1_PATCH
1351         PY_DFS_REFERRAL_V1_PATCH(&dfs_referral_v1_Type);
1352 #endif
1353 #ifdef PY_DFS_REFERRAL_V2_PATCH
1354         PY_DFS_REFERRAL_V2_PATCH(&dfs_referral_v2_Type);
1355 #endif
1356 #ifdef PY_DFS_NORMAL_REFERRAL_PATCH
1357         PY_DFS_NORMAL_REFERRAL_PATCH(&dfs_normal_referral_Type);
1358 #endif
1359 #ifdef PY_DFS_DOMAIN_REFERRAL_PATCH
1360         PY_DFS_DOMAIN_REFERRAL_PATCH(&dfs_domain_referral_Type);
1361 #endif
1362 #ifdef PY_DFS_REFERRAL_V3_PATCH
1363         PY_DFS_REFERRAL_V3_PATCH(&dfs_referral_v3_Type);
1364 #endif
1365 #ifdef PY_DFS_REFERRAL_TYPE_PATCH
1366         PY_DFS_REFERRAL_TYPE_PATCH(&dfs_referral_type_Type);
1367 #endif
1368 #ifdef PY_DFS_REFERRAL_RESP_PATCH
1369         PY_DFS_REFERRAL_RESP_PATCH(&dfs_referral_resp_Type);
1370 #endif
1371 #ifdef PY_DFS_GETDFSREFERRAL_IN_PATCH
1372         PY_DFS_GETDFSREFERRAL_IN_PATCH(&dfs_GetDFSReferral_in_Type);
1373 #endif
1374 #ifdef PY_DFSBLOBS_PATCH
1375         PY_DFSBLOBS_PATCH(&dfsblobs_InterfaceType);
1376 #endif
1377
1378         m = Py_InitModule3("dfsblobs", dfsblobs_methods, "dfsblobs DCE/RPC");
1379         if (m == NULL)
1380                 return;
1381
1382         PyModule_AddObject(m, "DFS_SERVER_ROOT", PyInt_FromLong(DFS_SERVER_ROOT));
1383         PyModule_AddObject(m, "DFS_SERVER_NON_ROOT", PyInt_FromLong(DFS_SERVER_NON_ROOT));
1384         PyModule_AddObject(m, "DFS_HEADER_FLAG_TARGET_BCK", PyInt_FromLong(DFS_HEADER_FLAG_TARGET_BCK));
1385         PyModule_AddObject(m, "DFS_FLAG_REFERRAL_DOMAIN_RESP", PyInt_FromLong(DFS_FLAG_REFERRAL_DOMAIN_RESP));
1386         PyModule_AddObject(m, "DFS_FLAG_REFERRAL_FIRST_TARGET_SET", PyInt_FromLong(DFS_FLAG_REFERRAL_FIRST_TARGET_SET));
1387         PyModule_AddObject(m, "DFS_HEADER_FLAG_STORAGE_SVR", PyInt_FromLong(DFS_HEADER_FLAG_STORAGE_SVR));
1388         PyModule_AddObject(m, "DFS_HEADER_FLAG_REFERAL_SVR", PyInt_FromLong(DFS_HEADER_FLAG_REFERAL_SVR));
1389         Py_INCREF((PyObject *)(void *)&dfs_referral_v1_Type);
1390         PyModule_AddObject(m, "dfs_referral_v1", (PyObject *)(void *)&dfs_referral_v1_Type);
1391         Py_INCREF((PyObject *)(void *)&dfs_referral_v2_Type);
1392         PyModule_AddObject(m, "dfs_referral_v2", (PyObject *)(void *)&dfs_referral_v2_Type);
1393         Py_INCREF((PyObject *)(void *)&dfs_normal_referral_Type);
1394         PyModule_AddObject(m, "dfs_normal_referral", (PyObject *)(void *)&dfs_normal_referral_Type);
1395         Py_INCREF((PyObject *)(void *)&dfs_domain_referral_Type);
1396         PyModule_AddObject(m, "dfs_domain_referral", (PyObject *)(void *)&dfs_domain_referral_Type);
1397         Py_INCREF((PyObject *)(void *)&dfs_referral_v3_Type);
1398         PyModule_AddObject(m, "dfs_referral_v3", (PyObject *)(void *)&dfs_referral_v3_Type);
1399         Py_INCREF((PyObject *)(void *)&dfs_referral_type_Type);
1400         PyModule_AddObject(m, "dfs_referral_type", (PyObject *)(void *)&dfs_referral_type_Type);
1401         Py_INCREF((PyObject *)(void *)&dfs_referral_resp_Type);
1402         PyModule_AddObject(m, "dfs_referral_resp", (PyObject *)(void *)&dfs_referral_resp_Type);
1403         Py_INCREF((PyObject *)(void *)&dfs_GetDFSReferral_in_Type);
1404         PyModule_AddObject(m, "dfs_GetDFSReferral_in", (PyObject *)(void *)&dfs_GetDFSReferral_in_Type);
1405         Py_INCREF((PyObject *)(void *)&dfsblobs_InterfaceType);
1406         PyModule_AddObject(m, "dfsblobs", (PyObject *)(void *)&dfsblobs_InterfaceType);
1407 #ifdef PY_MOD_DFSBLOBS_PATCH
1408         PY_MOD_DFSBLOBS_PATCH(m);
1409 #endif
1410
1411 }