bin.gen_ndr/default/source4/librpc/gen_ndr/py_irpc.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/source4/librpc/gen_ndr/ndr_irpc.h"
   9 #include "bin/default/source4/librpc/gen_ndr/ndr_irpc_c.h"
  10
  11 #include "librpc/gen_ndr/misc.h"
  12 #include "librpc/gen_ndr/security.h"
  13 #include "librpc/gen_ndr/nbt.h"
  14 #include "librpc/gen_ndr/netlogon.h"
  15 #include "librpc/gen_ndr/server_id.h"
  16 staticforward PyTypeObject irpc_creds_Type;
  17 staticforward PyTypeObject irpc_header_Type;
  18 staticforward PyTypeObject irpc_name_record_Type;
  19 staticforward PyTypeObject irpc_name_records_Type;
  20 staticforward PyTypeObject nbtd_statistics_Type;
  21 staticforward PyTypeObject nbtd_proxy_wins_addr_Type;
  22 staticforward PyTypeObject smbsrv_session_info_Type;
  23 staticforward PyTypeObject smbsrv_sessions_Type;
  24 staticforward PyTypeObject smbsrv_tcon_info_Type;
  25 staticforward PyTypeObject smbsrv_tcons_Type;
  26 staticforward PyTypeObject irpc_InterfaceType;
  27
  28 void initirpc(void);static PyTypeObject *dom_sid_Type;
  29 static PyTypeObject *GUID_Type;
  30 static PyTypeObject *ClientConnection_Type;
  31 static PyTypeObject *security_token_Type;
  32 static PyTypeObject *server_id_Type;
  33 static PyTypeObject *NL_DNS_NAME_INFO_ARRAY_Type;
  34 static PyTypeObject *Object_Type;
  35 static PyTypeObject *nbt_name_Type;
  36
  37 static PyObject *py_irpc_creds_get_token(PyObject *obj, void *closure)
  38 {
  39         struct irpc_creds *object = (struct irpc_creds *)pytalloc_get_ptr(obj);
  40         PyObject *py_token;
  41         if (object->token == NULL) {
  42                 py_token = Py_None;
  43                 Py_INCREF(py_token);
  44         } else {
  45                 py_token = pytalloc_reference_ex(security_token_Type, object->token, object->token);
  46         }
  47         return py_token;
  48 }
  49
  50 static int py_irpc_creds_set_token(PyObject *py_obj, PyObject *value, void *closure)
  51 {
  52         struct irpc_creds *object = (struct irpc_creds *)pytalloc_get_ptr(py_obj);
  53         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->token);
  54         if (value == Py_None) {
  55                 object->token = NULL;
  56         } else {
  57                 object->token = NULL;
  58                 PY_CHECK_TYPE(security_token_Type, value, return -1;);
  59                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
  60                         PyErr_NoMemory();
  61                         return -1;
  62                 }
  63                 object->token = (struct security_token *)pytalloc_get_ptr(value);
  64         }
  65         return 0;
  66 }
  67
  68 static PyGetSetDef py_irpc_creds_getsetters[] = {
  69         { discard_const_p(char, "token"), py_irpc_creds_get_token, py_irpc_creds_set_token },
  70         { NULL }
  71 };
  72
  73 static PyObject *py_irpc_creds_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
  74 {
  75         return pytalloc_new(struct irpc_creds, type);
  76 }
  77
  78
  79 static PyTypeObject irpc_creds_Type = {
  80         PyObject_HEAD_INIT(NULL) 0,
  81         .tp_name = "irpc.creds",
  82         .tp_getset = py_irpc_creds_getsetters,
  83         .tp_methods = NULL,
  84         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  85         .tp_basicsize = sizeof(pytalloc_Object),
  86         .tp_new = py_irpc_creds_new,
  87 };
  88
  89
  90 static PyObject *py_irpc_header_get_uuid(PyObject *obj, void *closure)
  91 {
  92         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
  93         PyObject *py_uuid;
  94         py_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->uuid);
  95         return py_uuid;
  96 }
  97
  98 static int py_irpc_header_set_uuid(PyObject *py_obj, PyObject *value, void *closure)
  99 {
 100         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 101         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 102         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 103                 PyErr_NoMemory();
 104                 return -1;
 105         }
 106         object->uuid = *(struct GUID *)pytalloc_get_ptr(value);
 107         return 0;
 108 }
 109
 110 static PyObject *py_irpc_header_get_if_version(PyObject *obj, void *closure)
 111 {
 112         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 113         PyObject *py_if_version;
 114         py_if_version = PyInt_FromLong(object->if_version);
 115         return py_if_version;
 116 }
 117
 118 static int py_irpc_header_set_if_version(PyObject *py_obj, PyObject *value, void *closure)
 119 {
 120         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 121         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 122         object->if_version = PyInt_AsLong(value);
 123         return 0;
 124 }
 125
 126 static PyObject *py_irpc_header_get_callnum(PyObject *obj, void *closure)
 127 {
 128         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 129         PyObject *py_callnum;
 130         py_callnum = PyInt_FromLong(object->callnum);
 131         return py_callnum;
 132 }
 133
 134 static int py_irpc_header_set_callnum(PyObject *py_obj, PyObject *value, void *closure)
 135 {
 136         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 137         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 138         object->callnum = PyInt_AsLong(value);
 139         return 0;
 140 }
 141
 142 static PyObject *py_irpc_header_get_callid(PyObject *obj, void *closure)
 143 {
 144         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 145         PyObject *py_callid;
 146         py_callid = PyInt_FromLong(object->callid);
 147         return py_callid;
 148 }
 149
 150 static int py_irpc_header_set_callid(PyObject *py_obj, PyObject *value, void *closure)
 151 {
 152         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 153         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 154         object->callid = PyInt_AsLong(value);
 155         return 0;
 156 }
 157
 158 static PyObject *py_irpc_header_get_flags(PyObject *obj, void *closure)
 159 {
 160         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 161         PyObject *py_flags;
 162         py_flags = PyInt_FromLong(object->flags);
 163         return py_flags;
 164 }
 165
 166 static int py_irpc_header_set_flags(PyObject *py_obj, PyObject *value, void *closure)
 167 {
 168         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 169         if (PyLong_Check(value)) {
 170                 object->flags = PyLong_AsLongLong(value);
 171         } else if (PyInt_Check(value)) {
 172                 object->flags = PyInt_AsLong(value);
 173         } else {
 174                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 175                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 176                 return -1;
 177         }
 178         return 0;
 179 }
 180
 181 static PyObject *py_irpc_header_get_status(PyObject *obj, void *closure)
 182 {
 183         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 184         PyObject *py_status;
 185         py_status = PyErr_FromNTSTATUS(object->status);
 186         return py_status;
 187 }
 188
 189 static int py_irpc_header_set_status(PyObject *py_obj, PyObject *value, void *closure)
 190 {
 191         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 192         object->status = NT_STATUS(PyInt_AsLong(value));
 193         return 0;
 194 }
 195
 196 static PyObject *py_irpc_header_get_creds(PyObject *obj, void *closure)
 197 {
 198         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 199         PyObject *py_creds;
 200         py_creds = pytalloc_reference_ex(&irpc_creds_Type, pytalloc_get_mem_ctx(obj), &object->creds);
 201         return py_creds;
 202 }
 203
 204 static int py_irpc_header_set_creds(PyObject *py_obj, PyObject *value, void *closure)
 205 {
 206         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 207         PY_CHECK_TYPE(&irpc_creds_Type, value, return -1;);
 208         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 209                 PyErr_NoMemory();
 210                 return -1;
 211         }
 212         object->creds = *(struct irpc_creds *)pytalloc_get_ptr(value);
 213         return 0;
 214 }
 215
 216 static PyObject *py_irpc_header_get__pad(PyObject *obj, void *closure)
 217 {
 218         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(obj);
 219         PyObject *py__pad;
 220         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
 221         return py__pad;
 222 }
 223
 224 static int py_irpc_header_set__pad(PyObject *py_obj, PyObject *value, void *closure)
 225 {
 226         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 227         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
 228         return 0;
 229 }
 230
 231 static PyGetSetDef py_irpc_header_getsetters[] = {
 232         { discard_const_p(char, "uuid"), py_irpc_header_get_uuid, py_irpc_header_set_uuid },
 233         { discard_const_p(char, "if_version"), py_irpc_header_get_if_version, py_irpc_header_set_if_version },
 234         { discard_const_p(char, "callnum"), py_irpc_header_get_callnum, py_irpc_header_set_callnum },
 235         { discard_const_p(char, "callid"), py_irpc_header_get_callid, py_irpc_header_set_callid },
 236         { discard_const_p(char, "flags"), py_irpc_header_get_flags, py_irpc_header_set_flags },
 237         { discard_const_p(char, "status"), py_irpc_header_get_status, py_irpc_header_set_status },
 238         { discard_const_p(char, "creds"), py_irpc_header_get_creds, py_irpc_header_set_creds },
 239         { discard_const_p(char, "_pad"), py_irpc_header_get__pad, py_irpc_header_set__pad },
 240         { NULL }
 241 };
 242
 243 static PyObject *py_irpc_header_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 244 {
 245         return pytalloc_new(struct irpc_header, type);
 246 }
 247
 248 static PyObject *py_irpc_header_ndr_pack(PyObject *py_obj)
 249 {
 250         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 251         DATA_BLOB blob;
 252         enum ndr_err_code err;
 253         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_irpc_header);
 254         if (err != NDR_ERR_SUCCESS) {
 255                 PyErr_SetNdrError(err);
 256                 return NULL;
 257         }
 258
 259         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 260 }
 261
 262 static PyObject *py_irpc_header_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 263 {
 264         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 265         DATA_BLOB blob;
 266         int blob_length = 0;
 267         enum ndr_err_code err;
 268         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 269         PyObject *allow_remaining_obj = NULL;
 270         bool allow_remaining = false;
 271
 272         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 273                 discard_const_p(char *, kwnames),
 274                 &blob.data, &blob_length,
 275                 &allow_remaining_obj)) {
 276                 return NULL;
 277         }
 278         blob.length = blob_length;
 279
 280         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 281                 allow_remaining = true;
 282         }
 283
 284         if (allow_remaining) {
 285                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_header);
 286         } else {
 287                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_header);
 288         }
 289         if (err != NDR_ERR_SUCCESS) {
 290                 PyErr_SetNdrError(err);
 291                 return NULL;
 292         }
 293
 294         Py_RETURN_NONE;
 295 }
 296
 297 static PyObject *py_irpc_header_ndr_print(PyObject *py_obj)
 298 {
 299         struct irpc_header *object = (struct irpc_header *)pytalloc_get_ptr(py_obj);
 300         PyObject *ret;
 301         char *retstr;
 302
 303         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_header, "irpc_header", object);
 304         ret = PyString_FromString(retstr);
 305         talloc_free(retstr);
 306
 307         return ret;
 308 }
 309
 310 static PyMethodDef py_irpc_header_methods[] = {
 311         { "__ndr_pack__", (PyCFunction)py_irpc_header_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 312         { "__ndr_unpack__", (PyCFunction)py_irpc_header_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 313         { "__ndr_print__", (PyCFunction)py_irpc_header_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 314         { NULL, NULL, 0, NULL }
 315 };
 316
 317
 318 static PyTypeObject irpc_header_Type = {
 319         PyObject_HEAD_INIT(NULL) 0,
 320         .tp_name = "irpc.header",
 321         .tp_getset = py_irpc_header_getsetters,
 322         .tp_methods = py_irpc_header_methods,
 323         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 324         .tp_basicsize = sizeof(pytalloc_Object),
 325         .tp_new = py_irpc_header_new,
 326 };
 327
 328
 329 static PyObject *py_irpc_name_record_get_name(PyObject *obj, void *closure)
 330 {
 331         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(obj);
 332         PyObject *py_name;
 333         py_name = PyString_FromStringOrNULL(object->name);
 334         return py_name;
 335 }
 336
 337 static int py_irpc_name_record_set_name(PyObject *py_obj, PyObject *value, void *closure)
 338 {
 339         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 340         object->name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 341         return 0;
 342 }
 343
 344 static PyObject *py_irpc_name_record_get_count(PyObject *obj, void *closure)
 345 {
 346         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(obj);
 347         PyObject *py_count;
 348         py_count = PyInt_FromLong(object->count);
 349         return py_count;
 350 }
 351
 352 static int py_irpc_name_record_set_count(PyObject *py_obj, PyObject *value, void *closure)
 353 {
 354         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 355         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 356         object->count = PyInt_AsLong(value);
 357         return 0;
 358 }
 359
 360 static PyObject *py_irpc_name_record_get_ids(PyObject *obj, void *closure)
 361 {
 362         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(obj);
 363         PyObject *py_ids;
 364         py_ids = PyList_New(object->count);
 365         if (py_ids == NULL) {
 366                 return NULL;
 367         }
 368         {
 369                 int ids_cntr_0;
 370                 for (ids_cntr_0 = 0; ids_cntr_0 < object->count; ids_cntr_0++) {
 371                         PyObject *py_ids_0;
 372                         py_ids_0 = pytalloc_reference_ex(server_id_Type, object->ids, &object->ids[ids_cntr_0]);
 373                         PyList_SetItem(py_ids, ids_cntr_0, py_ids_0);
 374                 }
 375         }
 376         return py_ids;
 377 }
 378
 379 static int py_irpc_name_record_set_ids(PyObject *py_obj, PyObject *value, void *closure)
 380 {
 381         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 382         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 383         {
 384                 int ids_cntr_0;
 385                 object->ids = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->ids, PyList_GET_SIZE(value));
 386                 if (!object->ids) { return -1;; }
 387                 talloc_set_name_const(object->ids, "ARRAY: object->ids");
 388                 for (ids_cntr_0 = 0; ids_cntr_0 < PyList_GET_SIZE(value); ids_cntr_0++) {
 389                         PY_CHECK_TYPE(server_id_Type, PyList_GET_ITEM(value, ids_cntr_0), return -1;);
 390                         if (talloc_reference(object->ids, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, ids_cntr_0))) == NULL) {
 391                                 PyErr_NoMemory();
 392                                 return -1;
 393                         }
 394                         object->ids[ids_cntr_0] = *(struct server_id *)pytalloc_get_ptr(PyList_GET_ITEM(value, ids_cntr_0));
 395                 }
 396         }
 397         return 0;
 398 }
 399
 400 static PyGetSetDef py_irpc_name_record_getsetters[] = {
 401         { discard_const_p(char, "name"), py_irpc_name_record_get_name, py_irpc_name_record_set_name },
 402         { discard_const_p(char, "count"), py_irpc_name_record_get_count, py_irpc_name_record_set_count },
 403         { discard_const_p(char, "ids"), py_irpc_name_record_get_ids, py_irpc_name_record_set_ids },
 404         { NULL }
 405 };
 406
 407 static PyObject *py_irpc_name_record_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 408 {
 409         return pytalloc_new(struct irpc_name_record, type);
 410 }
 411
 412 static PyObject *py_irpc_name_record_ndr_pack(PyObject *py_obj)
 413 {
 414         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 415         DATA_BLOB blob;
 416         enum ndr_err_code err;
 417         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_irpc_name_record);
 418         if (err != NDR_ERR_SUCCESS) {
 419                 PyErr_SetNdrError(err);
 420                 return NULL;
 421         }
 422
 423         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 424 }
 425
 426 static PyObject *py_irpc_name_record_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 427 {
 428         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 429         DATA_BLOB blob;
 430         int blob_length = 0;
 431         enum ndr_err_code err;
 432         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 433         PyObject *allow_remaining_obj = NULL;
 434         bool allow_remaining = false;
 435
 436         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 437                 discard_const_p(char *, kwnames),
 438                 &blob.data, &blob_length,
 439                 &allow_remaining_obj)) {
 440                 return NULL;
 441         }
 442         blob.length = blob_length;
 443
 444         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 445                 allow_remaining = true;
 446         }
 447
 448         if (allow_remaining) {
 449                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_record);
 450         } else {
 451                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_record);
 452         }
 453         if (err != NDR_ERR_SUCCESS) {
 454                 PyErr_SetNdrError(err);
 455                 return NULL;
 456         }
 457
 458         Py_RETURN_NONE;
 459 }
 460
 461 static PyObject *py_irpc_name_record_ndr_print(PyObject *py_obj)
 462 {
 463         struct irpc_name_record *object = (struct irpc_name_record *)pytalloc_get_ptr(py_obj);
 464         PyObject *ret;
 465         char *retstr;
 466
 467         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_name_record, "irpc_name_record", object);
 468         ret = PyString_FromString(retstr);
 469         talloc_free(retstr);
 470
 471         return ret;
 472 }
 473
 474 static PyMethodDef py_irpc_name_record_methods[] = {
 475         { "__ndr_pack__", (PyCFunction)py_irpc_name_record_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 476         { "__ndr_unpack__", (PyCFunction)py_irpc_name_record_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 477         { "__ndr_print__", (PyCFunction)py_irpc_name_record_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 478         { NULL, NULL, 0, NULL }
 479 };
 480
 481
 482 static PyTypeObject irpc_name_record_Type = {
 483         PyObject_HEAD_INIT(NULL) 0,
 484         .tp_name = "irpc.name_record",
 485         .tp_getset = py_irpc_name_record_getsetters,
 486         .tp_methods = py_irpc_name_record_methods,
 487         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 488         .tp_basicsize = sizeof(pytalloc_Object),
 489         .tp_new = py_irpc_name_record_new,
 490 };
 491
 492
 493 static PyObject *py_irpc_name_records_get_names(PyObject *obj, void *closure)
 494 {
 495         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(obj);
 496         PyObject *py_names;
 497         py_names = PyList_New(object->num_records);
 498         if (py_names == NULL) {
 499                 return NULL;
 500         }
 501         {
 502                 int names_cntr_0;
 503                 for (names_cntr_0 = 0; names_cntr_0 < object->num_records; names_cntr_0++) {
 504                         PyObject *py_names_0;
 505                         if (object->names[names_cntr_0] == NULL) {
 506                                 py_names_0 = Py_None;
 507                                 Py_INCREF(py_names_0);
 508                         } else {
 509                                 py_names_0 = pytalloc_reference_ex(&irpc_name_record_Type, object->names[names_cntr_0], object->names[names_cntr_0]);
 510                         }
 511                         PyList_SetItem(py_names, names_cntr_0, py_names_0);
 512                 }
 513         }
 514         return py_names;
 515 }
 516
 517 static int py_irpc_name_records_set_names(PyObject *py_obj, PyObject *value, void *closure)
 518 {
 519         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(py_obj);
 520         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 521         {
 522                 int names_cntr_0;
 523                 object->names = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->names, PyList_GET_SIZE(value));
 524                 if (!object->names) { return -1;; }
 525                 talloc_set_name_const(object->names, "ARRAY: object->names");
 526                 for (names_cntr_0 = 0; names_cntr_0 < PyList_GET_SIZE(value); names_cntr_0++) {
 527                         if (PyList_GET_ITEM(value, names_cntr_0) == Py_None) {
 528                                 object->names[names_cntr_0] = NULL;
 529                         } else {
 530                                 object->names[names_cntr_0] = NULL;
 531                                 PY_CHECK_TYPE(&irpc_name_record_Type, PyList_GET_ITEM(value, names_cntr_0), return -1;);
 532                                 if (talloc_reference(object->names, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, names_cntr_0))) == NULL) {
 533                                         PyErr_NoMemory();
 534                                         return -1;
 535                                 }
 536                                 object->names[names_cntr_0] = (struct irpc_name_record *)pytalloc_get_ptr(PyList_GET_ITEM(value, names_cntr_0));
 537                         }
 538                 }
 539         }
 540         return 0;
 541 }
 542
 543 static PyObject *py_irpc_name_records_get_num_records(PyObject *obj, void *closure)
 544 {
 545         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(obj);
 546         PyObject *py_num_records;
 547         py_num_records = PyInt_FromLong(object->num_records);
 548         return py_num_records;
 549 }
 550
 551 static int py_irpc_name_records_set_num_records(PyObject *py_obj, PyObject *value, void *closure)
 552 {
 553         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(py_obj);
 554         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 555         object->num_records = PyInt_AsLong(value);
 556         return 0;
 557 }
 558
 559 static PyGetSetDef py_irpc_name_records_getsetters[] = {
 560         { discard_const_p(char, "names"), py_irpc_name_records_get_names, py_irpc_name_records_set_names },
 561         { discard_const_p(char, "num_records"), py_irpc_name_records_get_num_records, py_irpc_name_records_set_num_records },
 562         { NULL }
 563 };
 564
 565 static PyObject *py_irpc_name_records_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 566 {
 567         return pytalloc_new(struct irpc_name_records, type);
 568 }
 569
 570 static PyObject *py_irpc_name_records_ndr_pack(PyObject *py_obj)
 571 {
 572         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(py_obj);
 573         DATA_BLOB blob;
 574         enum ndr_err_code err;
 575         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_irpc_name_records);
 576         if (err != NDR_ERR_SUCCESS) {
 577                 PyErr_SetNdrError(err);
 578                 return NULL;
 579         }
 580
 581         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 582 }
 583
 584 static PyObject *py_irpc_name_records_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 585 {
 586         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(py_obj);
 587         DATA_BLOB blob;
 588         int blob_length = 0;
 589         enum ndr_err_code err;
 590         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 591         PyObject *allow_remaining_obj = NULL;
 592         bool allow_remaining = false;
 593
 594         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 595                 discard_const_p(char *, kwnames),
 596                 &blob.data, &blob_length,
 597                 &allow_remaining_obj)) {
 598                 return NULL;
 599         }
 600         blob.length = blob_length;
 601
 602         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 603                 allow_remaining = true;
 604         }
 605
 606         if (allow_remaining) {
 607                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_records);
 608         } else {
 609                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_records);
 610         }
 611         if (err != NDR_ERR_SUCCESS) {
 612                 PyErr_SetNdrError(err);
 613                 return NULL;
 614         }
 615
 616         Py_RETURN_NONE;
 617 }
 618
 619 static PyObject *py_irpc_name_records_ndr_print(PyObject *py_obj)
 620 {
 621         struct irpc_name_records *object = (struct irpc_name_records *)pytalloc_get_ptr(py_obj);
 622         PyObject *ret;
 623         char *retstr;
 624
 625         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_name_records, "irpc_name_records", object);
 626         ret = PyString_FromString(retstr);
 627         talloc_free(retstr);
 628
 629         return ret;
 630 }
 631
 632 static PyMethodDef py_irpc_name_records_methods[] = {
 633         { "__ndr_pack__", (PyCFunction)py_irpc_name_records_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 634         { "__ndr_unpack__", (PyCFunction)py_irpc_name_records_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 635         { "__ndr_print__", (PyCFunction)py_irpc_name_records_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 636         { NULL, NULL, 0, NULL }
 637 };
 638
 639
 640 static PyTypeObject irpc_name_records_Type = {
 641         PyObject_HEAD_INIT(NULL) 0,
 642         .tp_name = "irpc.name_records",
 643         .tp_getset = py_irpc_name_records_getsetters,
 644         .tp_methods = py_irpc_name_records_methods,
 645         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 646         .tp_basicsize = sizeof(pytalloc_Object),
 647         .tp_new = py_irpc_name_records_new,
 648 };
 649
 650
 651 static PyObject *py_nbtd_statistics_get_total_received(PyObject *obj, void *closure)
 652 {
 653         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(obj);
 654         PyObject *py_total_received;
 655         py_total_received = PyLong_FromLongLong(object->total_received);
 656         return py_total_received;
 657 }
 658
 659 static int py_nbtd_statistics_set_total_received(PyObject *py_obj, PyObject *value, void *closure)
 660 {
 661         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(py_obj);
 662         if (PyLong_Check(value)) {
 663                 object->total_received = PyLong_AsLongLong(value);
 664         } else if (PyInt_Check(value)) {
 665                 object->total_received = PyInt_AsLong(value);
 666         } else {
 667                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 668                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 669                 return -1;
 670         }
 671         return 0;
 672 }
 673
 674 static PyObject *py_nbtd_statistics_get_total_sent(PyObject *obj, void *closure)
 675 {
 676         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(obj);
 677         PyObject *py_total_sent;
 678         py_total_sent = PyLong_FromLongLong(object->total_sent);
 679         return py_total_sent;
 680 }
 681
 682 static int py_nbtd_statistics_set_total_sent(PyObject *py_obj, PyObject *value, void *closure)
 683 {
 684         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(py_obj);
 685         if (PyLong_Check(value)) {
 686                 object->total_sent = PyLong_AsLongLong(value);
 687         } else if (PyInt_Check(value)) {
 688                 object->total_sent = PyInt_AsLong(value);
 689         } else {
 690                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 691                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 692                 return -1;
 693         }
 694         return 0;
 695 }
 696
 697 static PyObject *py_nbtd_statistics_get_query_count(PyObject *obj, void *closure)
 698 {
 699         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(obj);
 700         PyObject *py_query_count;
 701         py_query_count = PyLong_FromLongLong(object->query_count);
 702         return py_query_count;
 703 }
 704
 705 static int py_nbtd_statistics_set_query_count(PyObject *py_obj, PyObject *value, void *closure)
 706 {
 707         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(py_obj);
 708         if (PyLong_Check(value)) {
 709                 object->query_count = PyLong_AsLongLong(value);
 710         } else if (PyInt_Check(value)) {
 711                 object->query_count = PyInt_AsLong(value);
 712         } else {
 713                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 714                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 715                 return -1;
 716         }
 717         return 0;
 718 }
 719
 720 static PyObject *py_nbtd_statistics_get_register_count(PyObject *obj, void *closure)
 721 {
 722         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(obj);
 723         PyObject *py_register_count;
 724         py_register_count = PyLong_FromLongLong(object->register_count);
 725         return py_register_count;
 726 }
 727
 728 static int py_nbtd_statistics_set_register_count(PyObject *py_obj, PyObject *value, void *closure)
 729 {
 730         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(py_obj);
 731         if (PyLong_Check(value)) {
 732                 object->register_count = PyLong_AsLongLong(value);
 733         } else if (PyInt_Check(value)) {
 734                 object->register_count = PyInt_AsLong(value);
 735         } else {
 736                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 737                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 738                 return -1;
 739         }
 740         return 0;
 741 }
 742
 743 static PyObject *py_nbtd_statistics_get_release_count(PyObject *obj, void *closure)
 744 {
 745         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(obj);
 746         PyObject *py_release_count;
 747         py_release_count = PyLong_FromLongLong(object->release_count);
 748         return py_release_count;
 749 }
 750
 751 static int py_nbtd_statistics_set_release_count(PyObject *py_obj, PyObject *value, void *closure)
 752 {
 753         struct nbtd_statistics *object = (struct nbtd_statistics *)pytalloc_get_ptr(py_obj);
 754         if (PyLong_Check(value)) {
 755                 object->release_count = PyLong_AsLongLong(value);
 756         } else if (PyInt_Check(value)) {
 757                 object->release_count = PyInt_AsLong(value);
 758         } else {
 759                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 760                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 761                 return -1;
 762         }
 763         return 0;
 764 }
 765
 766 static PyGetSetDef py_nbtd_statistics_getsetters[] = {
 767         { discard_const_p(char, "total_received"), py_nbtd_statistics_get_total_received, py_nbtd_statistics_set_total_received },
 768         { discard_const_p(char, "total_sent"), py_nbtd_statistics_get_total_sent, py_nbtd_statistics_set_total_sent },
 769         { discard_const_p(char, "query_count"), py_nbtd_statistics_get_query_count, py_nbtd_statistics_set_query_count },
 770         { discard_const_p(char, "register_count"), py_nbtd_statistics_get_register_count, py_nbtd_statistics_set_register_count },
 771         { discard_const_p(char, "release_count"), py_nbtd_statistics_get_release_count, py_nbtd_statistics_set_release_count },
 772         { NULL }
 773 };
 774
 775 static PyObject *py_nbtd_statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 776 {
 777         return pytalloc_new(struct nbtd_statistics, type);
 778 }
 779
 780
 781 static PyTypeObject nbtd_statistics_Type = {
 782         PyObject_HEAD_INIT(NULL) 0,
 783         .tp_name = "irpc.nbtd_statistics",
 784         .tp_getset = py_nbtd_statistics_getsetters,
 785         .tp_methods = NULL,
 786         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 787         .tp_basicsize = sizeof(pytalloc_Object),
 788         .tp_new = py_nbtd_statistics_new,
 789 };
 790
 791 PyObject *py_import_nbtd_info(TALLOC_CTX *mem_ctx, int level, union nbtd_info *in)
 792 {
 793         PyObject *ret;
 794
 795         switch (level) {
 796                 case NBTD_INFO_STATISTICS:
 797                         if (in->stats == NULL) {
 798                                 ret = Py_None;
 799                                 Py_INCREF(ret);
 800                         } else {
 801                                 ret = pytalloc_reference_ex(&nbtd_statistics_Type, in->stats, in->stats);
 802                         }
 803                         return ret;
 804
 805         }
 806         PyErr_SetString(PyExc_TypeError, "unknown union level");
 807         return NULL;
 808 }
 809
 810 union nbtd_info *py_export_nbtd_info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 811 {
 812         union nbtd_info *ret = talloc_zero(mem_ctx, union nbtd_info);
 813         switch (level) {
 814                 case NBTD_INFO_STATISTICS:
 815                         if (in == Py_None) {
 816                                 ret->stats = NULL;
 817                         } else {
 818                                 ret->stats = NULL;
 819                                 PY_CHECK_TYPE(&nbtd_statistics_Type, in, talloc_free(ret); return NULL;);
 820                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 821                                         PyErr_NoMemory();
 822                                         talloc_free(ret); return NULL;
 823                                 }
 824                                 ret->stats = (struct nbtd_statistics *)pytalloc_get_ptr(in);
 825                         }
 826                         break;
 827
 828                 default:
 829                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
 830                         talloc_free(ret);
 831                         ret = NULL;
 832         }
 833
 834         return ret;
 835 }
 836
 837
 838 static PyObject *py_nbtd_proxy_wins_addr_get_addr(PyObject *obj, void *closure)
 839 {
 840         struct nbtd_proxy_wins_addr *object = (struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(obj);
 841         PyObject *py_addr;
 842         py_addr = PyString_FromStringOrNULL(object->addr);
 843         return py_addr;
 844 }
 845
 846 static int py_nbtd_proxy_wins_addr_set_addr(PyObject *py_obj, PyObject *value, void *closure)
 847 {
 848         struct nbtd_proxy_wins_addr *object = (struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(py_obj);
 849         object->addr = PyString_AS_STRING(value);
 850         return 0;
 851 }
 852
 853 static PyGetSetDef py_nbtd_proxy_wins_addr_getsetters[] = {
 854         { discard_const_p(char, "addr"), py_nbtd_proxy_wins_addr_get_addr, py_nbtd_proxy_wins_addr_set_addr },
 855         { NULL }
 856 };
 857
 858 static PyObject *py_nbtd_proxy_wins_addr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 859 {
 860         return pytalloc_new(struct nbtd_proxy_wins_addr, type);
 861 }
 862
 863
 864 static PyTypeObject nbtd_proxy_wins_addr_Type = {
 865         PyObject_HEAD_INIT(NULL) 0,
 866         .tp_name = "irpc.nbtd_proxy_wins_addr",
 867         .tp_getset = py_nbtd_proxy_wins_addr_getsetters,
 868         .tp_methods = NULL,
 869         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 870         .tp_basicsize = sizeof(pytalloc_Object),
 871         .tp_new = py_nbtd_proxy_wins_addr_new,
 872 };
 873
 874
 875 static PyObject *py_smbsrv_session_info_get_vuid(PyObject *obj, void *closure)
 876 {
 877         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 878         PyObject *py_vuid;
 879         py_vuid = PyLong_FromLongLong(object->vuid);
 880         return py_vuid;
 881 }
 882
 883 static int py_smbsrv_session_info_set_vuid(PyObject *py_obj, PyObject *value, void *closure)
 884 {
 885         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 886         if (PyLong_Check(value)) {
 887                 object->vuid = PyLong_AsLongLong(value);
 888         } else if (PyInt_Check(value)) {
 889                 object->vuid = PyInt_AsLong(value);
 890         } else {
 891                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 892                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 893                 return -1;
 894         }
 895         return 0;
 896 }
 897
 898 static PyObject *py_smbsrv_session_info_get_account_name(PyObject *obj, void *closure)
 899 {
 900         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 901         PyObject *py_account_name;
 902         py_account_name = PyString_FromStringOrNULL(object->account_name);
 903         return py_account_name;
 904 }
 905
 906 static int py_smbsrv_session_info_set_account_name(PyObject *py_obj, PyObject *value, void *closure)
 907 {
 908         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 909         object->account_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 910         return 0;
 911 }
 912
 913 static PyObject *py_smbsrv_session_info_get_domain_name(PyObject *obj, void *closure)
 914 {
 915         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 916         PyObject *py_domain_name;
 917         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
 918         return py_domain_name;
 919 }
 920
 921 static int py_smbsrv_session_info_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
 922 {
 923         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 924         object->domain_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 925         return 0;
 926 }
 927
 928 static PyObject *py_smbsrv_session_info_get_client_ip(PyObject *obj, void *closure)
 929 {
 930         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 931         PyObject *py_client_ip;
 932         py_client_ip = PyString_FromStringOrNULL(object->client_ip);
 933         return py_client_ip;
 934 }
 935
 936 static int py_smbsrv_session_info_set_client_ip(PyObject *py_obj, PyObject *value, void *closure)
 937 {
 938         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 939         object->client_ip = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
 940         return 0;
 941 }
 942
 943 static PyObject *py_smbsrv_session_info_get_connect_time(PyObject *obj, void *closure)
 944 {
 945         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 946         PyObject *py_connect_time;
 947         py_connect_time = PyLong_FromLongLong(object->connect_time);
 948         return py_connect_time;
 949 }
 950
 951 static int py_smbsrv_session_info_set_connect_time(PyObject *py_obj, PyObject *value, void *closure)
 952 {
 953         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 954         if (PyLong_Check(value)) {
 955                 object->connect_time = PyLong_AsLongLong(value);
 956         } else if (PyInt_Check(value)) {
 957                 object->connect_time = PyInt_AsLong(value);
 958         } else {
 959                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 960                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 961                 return -1;
 962         }
 963         return 0;
 964 }
 965
 966 static PyObject *py_smbsrv_session_info_get_auth_time(PyObject *obj, void *closure)
 967 {
 968         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 969         PyObject *py_auth_time;
 970         py_auth_time = PyLong_FromLongLong(object->auth_time);
 971         return py_auth_time;
 972 }
 973
 974 static int py_smbsrv_session_info_set_auth_time(PyObject *py_obj, PyObject *value, void *closure)
 975 {
 976         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
 977         if (PyLong_Check(value)) {
 978                 object->auth_time = PyLong_AsLongLong(value);
 979         } else if (PyInt_Check(value)) {
 980                 object->auth_time = PyInt_AsLong(value);
 981         } else {
 982                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 983                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 984                 return -1;
 985         }
 986         return 0;
 987 }
 988
 989 static PyObject *py_smbsrv_session_info_get_last_use_time(PyObject *obj, void *closure)
 990 {
 991         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(obj);
 992         PyObject *py_last_use_time;
 993         py_last_use_time = PyLong_FromLongLong(object->last_use_time);
 994         return py_last_use_time;
 995 }
 996
 997 static int py_smbsrv_session_info_set_last_use_time(PyObject *py_obj, PyObject *value, void *closure)
 998 {
 999         struct smbsrv_session_info *object = (struct smbsrv_session_info *)pytalloc_get_ptr(py_obj);
1000         if (PyLong_Check(value)) {
1001                 object->last_use_time = PyLong_AsLongLong(value);
1002         } else if (PyInt_Check(value)) {
1003                 object->last_use_time = PyInt_AsLong(value);
1004         } else {
1005                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1006                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1007                 return -1;
1008         }
1009         return 0;
1010 }
1011
1012 static PyGetSetDef py_smbsrv_session_info_getsetters[] = {
1013         { discard_const_p(char, "vuid"), py_smbsrv_session_info_get_vuid, py_smbsrv_session_info_set_vuid },
1014         { discard_const_p(char, "account_name"), py_smbsrv_session_info_get_account_name, py_smbsrv_session_info_set_account_name },
1015         { discard_const_p(char, "domain_name"), py_smbsrv_session_info_get_domain_name, py_smbsrv_session_info_set_domain_name },
1016         { discard_const_p(char, "client_ip"), py_smbsrv_session_info_get_client_ip, py_smbsrv_session_info_set_client_ip },
1017         { discard_const_p(char, "connect_time"), py_smbsrv_session_info_get_connect_time, py_smbsrv_session_info_set_connect_time },
1018         { discard_const_p(char, "auth_time"), py_smbsrv_session_info_get_auth_time, py_smbsrv_session_info_set_auth_time },
1019         { discard_const_p(char, "last_use_time"), py_smbsrv_session_info_get_last_use_time, py_smbsrv_session_info_set_last_use_time },
1020         { NULL }
1021 };
1022
1023 static PyObject *py_smbsrv_session_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1024 {
1025         return pytalloc_new(struct smbsrv_session_info, type);
1026 }
1027
1028
1029 static PyTypeObject smbsrv_session_info_Type = {
1030         PyObject_HEAD_INIT(NULL) 0,
1031         .tp_name = "irpc.smbsrv_session_info",
1032         .tp_getset = py_smbsrv_session_info_getsetters,
1033         .tp_methods = NULL,
1034         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1035         .tp_basicsize = sizeof(pytalloc_Object),
1036         .tp_new = py_smbsrv_session_info_new,
1037 };
1038
1039
1040 static PyObject *py_smbsrv_sessions_get_num_sessions(PyObject *obj, void *closure)
1041 {
1042         struct smbsrv_sessions *object = (struct smbsrv_sessions *)pytalloc_get_ptr(obj);
1043         PyObject *py_num_sessions;
1044         py_num_sessions = PyInt_FromLong(object->num_sessions);
1045         return py_num_sessions;
1046 }
1047
1048 static int py_smbsrv_sessions_set_num_sessions(PyObject *py_obj, PyObject *value, void *closure)
1049 {
1050         struct smbsrv_sessions *object = (struct smbsrv_sessions *)pytalloc_get_ptr(py_obj);
1051         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1052         object->num_sessions = PyInt_AsLong(value);
1053         return 0;
1054 }
1055
1056 static PyObject *py_smbsrv_sessions_get_sessions(PyObject *obj, void *closure)
1057 {
1058         struct smbsrv_sessions *object = (struct smbsrv_sessions *)pytalloc_get_ptr(obj);
1059         PyObject *py_sessions;
1060         if (object->sessions == NULL) {
1061                 py_sessions = Py_None;
1062                 Py_INCREF(py_sessions);
1063         } else {
1064                 py_sessions = PyList_New(object->num_sessions);
1065                 if (py_sessions == NULL) {
1066                         return NULL;
1067                 }
1068                 {
1069                         int sessions_cntr_1;
1070                         for (sessions_cntr_1 = 0; sessions_cntr_1 < object->num_sessions; sessions_cntr_1++) {
1071                                 PyObject *py_sessions_1;
1072                                 py_sessions_1 = pytalloc_reference_ex(&smbsrv_session_info_Type, object->sessions, &object->sessions[sessions_cntr_1]);
1073                                 PyList_SetItem(py_sessions, sessions_cntr_1, py_sessions_1);
1074                         }
1075                 }
1076         }
1077         return py_sessions;
1078 }
1079
1080 static int py_smbsrv_sessions_set_sessions(PyObject *py_obj, PyObject *value, void *closure)
1081 {
1082         struct smbsrv_sessions *object = (struct smbsrv_sessions *)pytalloc_get_ptr(py_obj);
1083         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->sessions);
1084         if (value == Py_None) {
1085                 object->sessions = NULL;
1086         } else {
1087                 object->sessions = NULL;
1088                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1089                 {
1090                         int sessions_cntr_1;
1091                         object->sessions = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->sessions, PyList_GET_SIZE(value));
1092                         if (!object->sessions) { return -1;; }
1093                         talloc_set_name_const(object->sessions, "ARRAY: object->sessions");
1094                         for (sessions_cntr_1 = 0; sessions_cntr_1 < PyList_GET_SIZE(value); sessions_cntr_1++) {
1095                                 PY_CHECK_TYPE(&smbsrv_session_info_Type, PyList_GET_ITEM(value, sessions_cntr_1), return -1;);
1096                                 if (talloc_reference(object->sessions, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, sessions_cntr_1))) == NULL) {
1097                                         PyErr_NoMemory();
1098                                         return -1;
1099                                 }
1100                                 object->sessions[sessions_cntr_1] = *(struct smbsrv_session_info *)pytalloc_get_ptr(PyList_GET_ITEM(value, sessions_cntr_1));
1101                         }
1102                 }
1103         }
1104         return 0;
1105 }
1106
1107 static PyGetSetDef py_smbsrv_sessions_getsetters[] = {
1108         { discard_const_p(char, "num_sessions"), py_smbsrv_sessions_get_num_sessions, py_smbsrv_sessions_set_num_sessions },
1109         { discard_const_p(char, "sessions"), py_smbsrv_sessions_get_sessions, py_smbsrv_sessions_set_sessions },
1110         { NULL }
1111 };
1112
1113 static PyObject *py_smbsrv_sessions_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1114 {
1115         return pytalloc_new(struct smbsrv_sessions, type);
1116 }
1117
1118
1119 static PyTypeObject smbsrv_sessions_Type = {
1120         PyObject_HEAD_INIT(NULL) 0,
1121         .tp_name = "irpc.smbsrv_sessions",
1122         .tp_getset = py_smbsrv_sessions_getsetters,
1123         .tp_methods = NULL,
1124         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1125         .tp_basicsize = sizeof(pytalloc_Object),
1126         .tp_new = py_smbsrv_sessions_new,
1127 };
1128
1129
1130 static PyObject *py_smbsrv_tcon_info_get_tid(PyObject *obj, void *closure)
1131 {
1132         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(obj);
1133         PyObject *py_tid;
1134         py_tid = PyInt_FromLong(object->tid);
1135         return py_tid;
1136 }
1137
1138 static int py_smbsrv_tcon_info_set_tid(PyObject *py_obj, PyObject *value, void *closure)
1139 {
1140         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(py_obj);
1141         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1142         object->tid = PyInt_AsLong(value);
1143         return 0;
1144 }
1145
1146 static PyObject *py_smbsrv_tcon_info_get_share_name(PyObject *obj, void *closure)
1147 {
1148         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(obj);
1149         PyObject *py_share_name;
1150         py_share_name = PyString_FromStringOrNULL(object->share_name);
1151         return py_share_name;
1152 }
1153
1154 static int py_smbsrv_tcon_info_set_share_name(PyObject *py_obj, PyObject *value, void *closure)
1155 {
1156         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(py_obj);
1157         object->share_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
1158         return 0;
1159 }
1160
1161 static PyObject *py_smbsrv_tcon_info_get_client_ip(PyObject *obj, void *closure)
1162 {
1163         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(obj);
1164         PyObject *py_client_ip;
1165         py_client_ip = PyString_FromStringOrNULL(object->client_ip);
1166         return py_client_ip;
1167 }
1168
1169 static int py_smbsrv_tcon_info_set_client_ip(PyObject *py_obj, PyObject *value, void *closure)
1170 {
1171         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(py_obj);
1172         object->client_ip = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
1173         return 0;
1174 }
1175
1176 static PyObject *py_smbsrv_tcon_info_get_connect_time(PyObject *obj, void *closure)
1177 {
1178         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(obj);
1179         PyObject *py_connect_time;
1180         py_connect_time = PyLong_FromLongLong(object->connect_time);
1181         return py_connect_time;
1182 }
1183
1184 static int py_smbsrv_tcon_info_set_connect_time(PyObject *py_obj, PyObject *value, void *closure)
1185 {
1186         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(py_obj);
1187         if (PyLong_Check(value)) {
1188                 object->connect_time = PyLong_AsLongLong(value);
1189         } else if (PyInt_Check(value)) {
1190                 object->connect_time = PyInt_AsLong(value);
1191         } else {
1192                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1193                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1194                 return -1;
1195         }
1196         return 0;
1197 }
1198
1199 static PyObject *py_smbsrv_tcon_info_get_last_use_time(PyObject *obj, void *closure)
1200 {
1201         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(obj);
1202         PyObject *py_last_use_time;
1203         py_last_use_time = PyLong_FromLongLong(object->last_use_time);
1204         return py_last_use_time;
1205 }
1206
1207 static int py_smbsrv_tcon_info_set_last_use_time(PyObject *py_obj, PyObject *value, void *closure)
1208 {
1209         struct smbsrv_tcon_info *object = (struct smbsrv_tcon_info *)pytalloc_get_ptr(py_obj);
1210         if (PyLong_Check(value)) {
1211                 object->last_use_time = PyLong_AsLongLong(value);
1212         } else if (PyInt_Check(value)) {
1213                 object->last_use_time = PyInt_AsLong(value);
1214         } else {
1215                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1216                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1217                 return -1;
1218         }
1219         return 0;
1220 }
1221
1222 static PyGetSetDef py_smbsrv_tcon_info_getsetters[] = {
1223         { discard_const_p(char, "tid"), py_smbsrv_tcon_info_get_tid, py_smbsrv_tcon_info_set_tid },
1224         { discard_const_p(char, "share_name"), py_smbsrv_tcon_info_get_share_name, py_smbsrv_tcon_info_set_share_name },
1225         { discard_const_p(char, "client_ip"), py_smbsrv_tcon_info_get_client_ip, py_smbsrv_tcon_info_set_client_ip },
1226         { discard_const_p(char, "connect_time"), py_smbsrv_tcon_info_get_connect_time, py_smbsrv_tcon_info_set_connect_time },
1227         { discard_const_p(char, "last_use_time"), py_smbsrv_tcon_info_get_last_use_time, py_smbsrv_tcon_info_set_last_use_time },
1228         { NULL }
1229 };
1230
1231 static PyObject *py_smbsrv_tcon_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1232 {
1233         return pytalloc_new(struct smbsrv_tcon_info, type);
1234 }
1235
1236
1237 static PyTypeObject smbsrv_tcon_info_Type = {
1238         PyObject_HEAD_INIT(NULL) 0,
1239         .tp_name = "irpc.smbsrv_tcon_info",
1240         .tp_getset = py_smbsrv_tcon_info_getsetters,
1241         .tp_methods = NULL,
1242         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1243         .tp_basicsize = sizeof(pytalloc_Object),
1244         .tp_new = py_smbsrv_tcon_info_new,
1245 };
1246
1247
1248 static PyObject *py_smbsrv_tcons_get_num_tcons(PyObject *obj, void *closure)
1249 {
1250         struct smbsrv_tcons *object = (struct smbsrv_tcons *)pytalloc_get_ptr(obj);
1251         PyObject *py_num_tcons;
1252         py_num_tcons = PyInt_FromLong(object->num_tcons);
1253         return py_num_tcons;
1254 }
1255
1256 static int py_smbsrv_tcons_set_num_tcons(PyObject *py_obj, PyObject *value, void *closure)
1257 {
1258         struct smbsrv_tcons *object = (struct smbsrv_tcons *)pytalloc_get_ptr(py_obj);
1259         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1260         object->num_tcons = PyInt_AsLong(value);
1261         return 0;
1262 }
1263
1264 static PyObject *py_smbsrv_tcons_get_tcons(PyObject *obj, void *closure)
1265 {
1266         struct smbsrv_tcons *object = (struct smbsrv_tcons *)pytalloc_get_ptr(obj);
1267         PyObject *py_tcons;
1268         if (object->tcons == NULL) {
1269                 py_tcons = Py_None;
1270                 Py_INCREF(py_tcons);
1271         } else {
1272                 py_tcons = PyList_New(object->num_tcons);
1273                 if (py_tcons == NULL) {
1274                         return NULL;
1275                 }
1276                 {
1277                         int tcons_cntr_1;
1278                         for (tcons_cntr_1 = 0; tcons_cntr_1 < object->num_tcons; tcons_cntr_1++) {
1279                                 PyObject *py_tcons_1;
1280                                 py_tcons_1 = pytalloc_reference_ex(&smbsrv_tcon_info_Type, object->tcons, &object->tcons[tcons_cntr_1]);
1281                                 PyList_SetItem(py_tcons, tcons_cntr_1, py_tcons_1);
1282                         }
1283                 }
1284         }
1285         return py_tcons;
1286 }
1287
1288 static int py_smbsrv_tcons_set_tcons(PyObject *py_obj, PyObject *value, void *closure)
1289 {
1290         struct smbsrv_tcons *object = (struct smbsrv_tcons *)pytalloc_get_ptr(py_obj);
1291         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->tcons);
1292         if (value == Py_None) {
1293                 object->tcons = NULL;
1294         } else {
1295                 object->tcons = NULL;
1296                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1297                 {
1298                         int tcons_cntr_1;
1299                         object->tcons = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->tcons, PyList_GET_SIZE(value));
1300                         if (!object->tcons) { return -1;; }
1301                         talloc_set_name_const(object->tcons, "ARRAY: object->tcons");
1302                         for (tcons_cntr_1 = 0; tcons_cntr_1 < PyList_GET_SIZE(value); tcons_cntr_1++) {
1303                                 PY_CHECK_TYPE(&smbsrv_tcon_info_Type, PyList_GET_ITEM(value, tcons_cntr_1), return -1;);
1304                                 if (talloc_reference(object->tcons, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, tcons_cntr_1))) == NULL) {
1305                                         PyErr_NoMemory();
1306                                         return -1;
1307                                 }
1308                                 object->tcons[tcons_cntr_1] = *(struct smbsrv_tcon_info *)pytalloc_get_ptr(PyList_GET_ITEM(value, tcons_cntr_1));
1309                         }
1310                 }
1311         }
1312         return 0;
1313 }
1314
1315 static PyGetSetDef py_smbsrv_tcons_getsetters[] = {
1316         { discard_const_p(char, "num_tcons"), py_smbsrv_tcons_get_num_tcons, py_smbsrv_tcons_set_num_tcons },
1317         { discard_const_p(char, "tcons"), py_smbsrv_tcons_get_tcons, py_smbsrv_tcons_set_tcons },
1318         { NULL }
1319 };
1320
1321 static PyObject *py_smbsrv_tcons_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1322 {
1323         return pytalloc_new(struct smbsrv_tcons, type);
1324 }
1325
1326
1327 static PyTypeObject smbsrv_tcons_Type = {
1328         PyObject_HEAD_INIT(NULL) 0,
1329         .tp_name = "irpc.smbsrv_tcons",
1330         .tp_getset = py_smbsrv_tcons_getsetters,
1331         .tp_methods = NULL,
1332         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1333         .tp_basicsize = sizeof(pytalloc_Object),
1334         .tp_new = py_smbsrv_tcons_new,
1335 };
1336
1337 PyObject *py_import_smbsrv_info(TALLOC_CTX *mem_ctx, int level, union smbsrv_info *in)
1338 {
1339         PyObject *ret;
1340
1341         switch (level) {
1342                 case SMBSRV_INFO_SESSIONS:
1343                         ret = pytalloc_reference_ex(&smbsrv_sessions_Type, mem_ctx, &in->sessions);
1344                         return ret;
1345
1346                 case SMBSRV_INFO_TCONS:
1347                         ret = pytalloc_reference_ex(&smbsrv_tcons_Type, mem_ctx, &in->tcons);
1348                         return ret;
1349
1350         }
1351         PyErr_SetString(PyExc_TypeError, "unknown union level");
1352         return NULL;
1353 }
1354
1355 union smbsrv_info *py_export_smbsrv_info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1356 {
1357         union smbsrv_info *ret = talloc_zero(mem_ctx, union smbsrv_info);
1358         switch (level) {
1359                 case SMBSRV_INFO_SESSIONS:
1360                         PY_CHECK_TYPE(&smbsrv_sessions_Type, in, talloc_free(ret); return NULL;);
1361                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1362                                 PyErr_NoMemory();
1363                                 talloc_free(ret); return NULL;
1364                         }
1365                         ret->sessions = *(struct smbsrv_sessions *)pytalloc_get_ptr(in);
1366                         break;
1367
1368                 case SMBSRV_INFO_TCONS:
1369                         PY_CHECK_TYPE(&smbsrv_tcons_Type, in, talloc_free(ret); return NULL;);
1370                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1371                                 PyErr_NoMemory();
1372                                 talloc_free(ret); return NULL;
1373                         }
1374                         ret->tcons = *(struct smbsrv_tcons *)pytalloc_get_ptr(in);
1375                         break;
1376
1377                 default:
1378                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
1379                         talloc_free(ret);
1380                         ret = NULL;
1381         }
1382
1383         return ret;
1384 }
1385
1386
1387 static bool pack_py_irpc_uptime_args_in(PyObject *args, PyObject *kwargs, struct irpc_uptime *r)
1388 {
1389         const char *kwnames[] = {
1390                 NULL
1391         };
1392
1393         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":irpc_uptime", discard_const_p(char *, kwnames))) {
1394                 return false;
1395         }
1396
1397         return true;
1398 }
1399
1400 static PyObject *unpack_py_irpc_uptime_args_out(struct irpc_uptime *r)
1401 {
1402         PyObject *result;
1403         PyObject *py_start_time;
1404         py_start_time = PyLong_FromLongLong(*r->out.start_time);
1405         result = py_start_time;
1406         return result;
1407 }
1408
1409 static bool pack_py_nbtd_information_args_in(PyObject *args, PyObject *kwargs, struct nbtd_information *r)
1410 {
1411         PyObject *py_level;
1412         const char *kwnames[] = {
1413                 "level", NULL
1414         };
1415
1416         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:nbtd_information", discard_const_p(char *, kwnames), &py_level)) {
1417                 return false;
1418         }
1419
1420         if (PyLong_Check(py_level)) {
1421                 r->in.level = PyLong_AsLongLong(py_level);
1422         } else if (PyInt_Check(py_level)) {
1423                 r->in.level = PyInt_AsLong(py_level);
1424         } else {
1425                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1426                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1427                 return false;
1428         }
1429         return true;
1430 }
1431
1432 static PyObject *unpack_py_nbtd_information_args_out(struct nbtd_information *r)
1433 {
1434         PyObject *result;
1435         PyObject *py_info;
1436         py_info = py_import_nbtd_info(r, r->in.level, &r->out.info);
1437         if (py_info == NULL) {
1438                 return NULL;
1439         }
1440         result = py_info;
1441         return result;
1442 }
1443
1444 static bool pack_py_nbtd_getdcname_args_in(PyObject *args, PyObject *kwargs, struct nbtd_getdcname *r)
1445 {
1446         PyObject *py_domainname;
1447         PyObject *py_ip_address;
1448         PyObject *py_my_computername;
1449         PyObject *py_my_accountname;
1450         PyObject *py_account_control;
1451         PyObject *py_domain_sid;
1452         const char *kwnames[] = {
1453                 "domainname", "ip_address", "my_computername", "my_accountname", "account_control", "domain_sid", NULL
1454         };
1455
1456         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:nbtd_getdcname", discard_const_p(char *, kwnames), &py_domainname, &py_ip_address, &py_my_computername, &py_my_accountname, &py_account_control, &py_domain_sid)) {
1457                 return false;
1458         }
1459
1460         r->in.domainname = talloc_strdup(r, PyString_AS_STRING(py_domainname));
1461         r->in.ip_address = talloc_strdup(r, PyString_AS_STRING(py_ip_address));
1462         r->in.my_computername = talloc_strdup(r, PyString_AS_STRING(py_my_computername));
1463         r->in.my_accountname = talloc_strdup(r, PyString_AS_STRING(py_my_accountname));
1464         PY_CHECK_TYPE(&PyInt_Type, py_account_control, return false;);
1465         r->in.account_control = PyInt_AsLong(py_account_control);
1466         r->in.domain_sid = talloc_ptrtype(r, r->in.domain_sid);
1467         PY_CHECK_TYPE(dom_sid_Type, py_domain_sid, return false;);
1468         if (talloc_reference(r, pytalloc_get_mem_ctx(py_domain_sid)) == NULL) {
1469                 PyErr_NoMemory();
1470                 return false;
1471         }
1472         r->in.domain_sid = (struct dom_sid *)pytalloc_get_ptr(py_domain_sid);
1473         return true;
1474 }
1475
1476 static PyObject *unpack_py_nbtd_getdcname_args_out(struct nbtd_getdcname *r)
1477 {
1478         PyObject *result;
1479         PyObject *py_dcname;
1480         if (r->out.dcname == NULL) {
1481                 py_dcname = Py_None;
1482                 Py_INCREF(py_dcname);
1483         } else {
1484                 py_dcname = PyString_FromStringOrNULL(r->out.dcname);
1485         }
1486         result = py_dcname;
1487         return result;
1488 }
1489
1490 static bool pack_py_nbtd_proxy_wins_challenge_args_in(PyObject *args, PyObject *kwargs, struct nbtd_proxy_wins_challenge *r)
1491 {
1492         PyObject *py_name;
1493         PyObject *py_num_addrs;
1494         PyObject *py_addrs;
1495         const char *kwnames[] = {
1496                 "name", "num_addrs", "addrs", NULL
1497         };
1498
1499         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:nbtd_proxy_wins_challenge", discard_const_p(char *, kwnames), &py_name, &py_num_addrs, &py_addrs)) {
1500                 return false;
1501         }
1502
1503         PY_CHECK_TYPE(nbt_name_Type, py_name, return false;);
1504         if (talloc_reference(r, pytalloc_get_mem_ctx(py_name)) == NULL) {
1505                 PyErr_NoMemory();
1506                 return false;
1507         }
1508         r->in.name = *(struct nbt_name *)pytalloc_get_ptr(py_name);
1509         PY_CHECK_TYPE(&PyInt_Type, py_num_addrs, return false;);
1510         r->in.num_addrs = PyInt_AsLong(py_num_addrs);
1511         PY_CHECK_TYPE(&PyList_Type, py_addrs, return false;);
1512         {
1513                 int addrs_cntr_0;
1514                 r->in.addrs = talloc_array_ptrtype(r, r->in.addrs, PyList_GET_SIZE(py_addrs));
1515                 if (!r->in.addrs) { return false;; }
1516                 talloc_set_name_const(r->in.addrs, "ARRAY: r->in.addrs");
1517                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(py_addrs); addrs_cntr_0++) {
1518                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(py_addrs, addrs_cntr_0), return false;);
1519                         if (talloc_reference(r->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_addrs, addrs_cntr_0))) == NULL) {
1520                                 PyErr_NoMemory();
1521                                 return false;
1522                         }
1523                         r->in.addrs[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(py_addrs, addrs_cntr_0));
1524                 }
1525         }
1526         return true;
1527 }
1528
1529 static PyObject *unpack_py_nbtd_proxy_wins_challenge_args_out(struct nbtd_proxy_wins_challenge *r)
1530 {
1531         PyObject *result;
1532         PyObject *py_num_addrs;
1533         PyObject *py_addrs;
1534         result = PyTuple_New(2);
1535         py_num_addrs = PyInt_FromLong(r->out.num_addrs);
1536         PyTuple_SetItem(result, 0, py_num_addrs);
1537         py_addrs = PyList_New(r->out.num_addrs);
1538         if (py_addrs == NULL) {
1539                 return NULL;
1540         }
1541         {
1542                 int addrs_cntr_0;
1543                 for (addrs_cntr_0 = 0; addrs_cntr_0 < r->out.num_addrs; addrs_cntr_0++) {
1544                         PyObject *py_addrs_0;
1545                         py_addrs_0 = pytalloc_reference_ex(&nbtd_proxy_wins_addr_Type, r->out.addrs, &r->out.addrs[addrs_cntr_0]);
1546                         PyList_SetItem(py_addrs, addrs_cntr_0, py_addrs_0);
1547                 }
1548         }
1549         PyTuple_SetItem(result, 1, py_addrs);
1550         return result;
1551 }
1552
1553 static bool pack_py_nbtd_proxy_wins_release_demand_args_in(PyObject *args, PyObject *kwargs, struct nbtd_proxy_wins_release_demand *r)
1554 {
1555         PyObject *py_name;
1556         PyObject *py_num_addrs;
1557         PyObject *py_addrs;
1558         const char *kwnames[] = {
1559                 "name", "num_addrs", "addrs", NULL
1560         };
1561
1562         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:nbtd_proxy_wins_release_demand", discard_const_p(char *, kwnames), &py_name, &py_num_addrs, &py_addrs)) {
1563                 return false;
1564         }
1565
1566         PY_CHECK_TYPE(nbt_name_Type, py_name, return false;);
1567         if (talloc_reference(r, pytalloc_get_mem_ctx(py_name)) == NULL) {
1568                 PyErr_NoMemory();
1569                 return false;
1570         }
1571         r->in.name = *(struct nbt_name *)pytalloc_get_ptr(py_name);
1572         PY_CHECK_TYPE(&PyInt_Type, py_num_addrs, return false;);
1573         r->in.num_addrs = PyInt_AsLong(py_num_addrs);
1574         PY_CHECK_TYPE(&PyList_Type, py_addrs, return false;);
1575         {
1576                 int addrs_cntr_0;
1577                 r->in.addrs = talloc_array_ptrtype(r, r->in.addrs, PyList_GET_SIZE(py_addrs));
1578                 if (!r->in.addrs) { return false;; }
1579                 talloc_set_name_const(r->in.addrs, "ARRAY: r->in.addrs");
1580                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(py_addrs); addrs_cntr_0++) {
1581                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(py_addrs, addrs_cntr_0), return false;);
1582                         if (talloc_reference(r->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_addrs, addrs_cntr_0))) == NULL) {
1583                                 PyErr_NoMemory();
1584                                 return false;
1585                         }
1586                         r->in.addrs[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(py_addrs, addrs_cntr_0));
1587                 }
1588         }
1589         return true;
1590 }
1591
1592 static PyObject *unpack_py_nbtd_proxy_wins_release_demand_args_out(struct nbtd_proxy_wins_release_demand *r)
1593 {
1594         PyObject *result;
1595         result = Py_None;
1596         Py_INCREF(result);
1597         return result;
1598 }
1599
1600 static bool pack_py_kdc_check_generic_kerberos_args_in(PyObject *args, PyObject *kwargs, struct kdc_check_generic_kerberos *r)
1601 {
1602         PyObject *py_generic_request;
1603         const char *kwnames[] = {
1604                 "generic_request", NULL
1605         };
1606
1607         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:kdc_check_generic_kerberos", discard_const_p(char *, kwnames), &py_generic_request)) {
1608                 return false;
1609         }
1610
1611         r->in.generic_request = data_blob_talloc(r, PyString_AS_STRING(py_generic_request), PyString_GET_SIZE(py_generic_request));
1612         return true;
1613 }
1614
1615 static PyObject *unpack_py_kdc_check_generic_kerberos_args_out(struct kdc_check_generic_kerberos *r)
1616 {
1617         PyObject *result;
1618         PyObject *py_generic_reply;
1619         py_generic_reply = PyString_FromStringAndSize((char *)(r->out.generic_reply).data, (r->out.generic_reply).length);
1620         result = py_generic_reply;
1621         return result;
1622 }
1623
1624 static bool pack_py_smbsrv_information_args_in(PyObject *args, PyObject *kwargs, struct smbsrv_information *r)
1625 {
1626         PyObject *py_level;
1627         const char *kwnames[] = {
1628                 "level", NULL
1629         };
1630
1631         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:smbsrv_information", discard_const_p(char *, kwnames), &py_level)) {
1632                 return false;
1633         }
1634
1635         if (PyLong_Check(py_level)) {
1636                 r->in.level = PyLong_AsLongLong(py_level);
1637         } else if (PyInt_Check(py_level)) {
1638                 r->in.level = PyInt_AsLong(py_level);
1639         } else {
1640                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1641                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1642                 return false;
1643         }
1644         return true;
1645 }
1646
1647 static PyObject *unpack_py_smbsrv_information_args_out(struct smbsrv_information *r)
1648 {
1649         PyObject *result;
1650         PyObject *py_info;
1651         py_info = py_import_smbsrv_info(r, r->in.level, &r->out.info);
1652         if (py_info == NULL) {
1653                 return NULL;
1654         }
1655         result = py_info;
1656         return result;
1657 }
1658
1659 static bool pack_py_samba_terminate_args_in(PyObject *args, PyObject *kwargs, struct samba_terminate *r)
1660 {
1661         PyObject *py_reason;
1662         const char *kwnames[] = {
1663                 "reason", NULL
1664         };
1665
1666         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:samba_terminate", discard_const_p(char *, kwnames), &py_reason)) {
1667                 return false;
1668         }
1669
1670         r->in.reason = talloc_strdup(r, PyString_AS_STRING(py_reason));
1671         return true;
1672 }
1673
1674 static PyObject *unpack_py_samba_terminate_args_out(struct samba_terminate *r)
1675 {
1676         PyObject *result;
1677         result = Py_None;
1678         Py_INCREF(result);
1679         return result;
1680 }
1681
1682 static bool pack_py_dreplsrv_refresh_args_in(PyObject *args, PyObject *kwargs, struct dreplsrv_refresh *r)
1683 {
1684         const char *kwnames[] = {
1685                 NULL
1686         };
1687
1688         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":dreplsrv_refresh", discard_const_p(char *, kwnames))) {
1689                 return false;
1690         }
1691
1692         return true;
1693 }
1694
1695 static PyObject *unpack_py_dreplsrv_refresh_args_out(struct dreplsrv_refresh *r)
1696 {
1697         PyObject *result;
1698         result = Py_None;
1699         Py_INCREF(result);
1700         if (!W_ERROR_IS_OK(r->out.result)) {
1701                 PyErr_SetWERROR(r->out.result);
1702                 return NULL;
1703         }
1704
1705         return result;
1706 }
1707
1708 static bool pack_py_drepl_takeFSMORole_args_in(PyObject *args, PyObject *kwargs, struct drepl_takeFSMORole *r)
1709 {
1710         PyObject *py_role;
1711         const char *kwnames[] = {
1712                 "role", NULL
1713         };
1714
1715         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:drepl_takeFSMORole", discard_const_p(char *, kwnames), &py_role)) {
1716                 return false;
1717         }
1718
1719         if (PyLong_Check(py_role)) {
1720                 r->in.role = PyLong_AsLongLong(py_role);
1721         } else if (PyInt_Check(py_role)) {
1722                 r->in.role = PyInt_AsLong(py_role);
1723         } else {
1724                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1725                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1726                 return false;
1727         }
1728         return true;
1729 }
1730
1731 static PyObject *unpack_py_drepl_takeFSMORole_args_out(struct drepl_takeFSMORole *r)
1732 {
1733         PyObject *result;
1734         result = Py_None;
1735         Py_INCREF(result);
1736         if (!W_ERROR_IS_OK(r->out.result)) {
1737                 PyErr_SetWERROR(r->out.result);
1738                 return NULL;
1739         }
1740
1741         return result;
1742 }
1743
1744 static bool pack_py_drepl_trigger_repl_secret_args_in(PyObject *args, PyObject *kwargs, struct drepl_trigger_repl_secret *r)
1745 {
1746         PyObject *py_user_dn;
1747         const char *kwnames[] = {
1748                 "user_dn", NULL
1749         };
1750
1751         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:drepl_trigger_repl_secret", discard_const_p(char *, kwnames), &py_user_dn)) {
1752                 return false;
1753         }
1754
1755         r->in.user_dn = talloc_strdup(r, PyString_AS_STRING(py_user_dn));
1756         return true;
1757 }
1758
1759 static PyObject *unpack_py_drepl_trigger_repl_secret_args_out(struct drepl_trigger_repl_secret *r)
1760 {
1761         PyObject *result;
1762         result = Py_None;
1763         Py_INCREF(result);
1764         return result;
1765 }
1766
1767 static bool pack_py_dnsupdate_RODC_args_in(PyObject *args, PyObject *kwargs, struct dnsupdate_RODC *r)
1768 {
1769         PyObject *py_dom_sid;
1770         PyObject *py_site_name;
1771         PyObject *py_dns_ttl;
1772         PyObject *py_dns_names;
1773         const char *kwnames[] = {
1774                 "dom_sid", "site_name", "dns_ttl", "dns_names", NULL
1775         };
1776
1777         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dnsupdate_RODC", discard_const_p(char *, kwnames), &py_dom_sid, &py_site_name, &py_dns_ttl, &py_dns_names)) {
1778                 return false;
1779         }
1780
1781         if (py_dom_sid == Py_None) {
1782                 r->in.dom_sid = NULL;
1783         } else {
1784                 r->in.dom_sid = NULL;
1785                 PY_CHECK_TYPE(dom_sid_Type, py_dom_sid, return false;);
1786                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_dom_sid)) == NULL) {
1787                         PyErr_NoMemory();
1788                         return false;
1789                 }
1790                 r->in.dom_sid = (struct dom_sid *)pytalloc_get_ptr(py_dom_sid);
1791         }
1792         if (py_site_name == Py_None) {
1793                 r->in.site_name = NULL;
1794         } else {
1795                 r->in.site_name = NULL;
1796                 if (PyUnicode_Check(py_site_name)) {
1797                         r->in.site_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_site_name, "utf-8", "ignore"));
1798                 } else if (PyString_Check(py_site_name)) {
1799                         r->in.site_name = PyString_AS_STRING(py_site_name);
1800                 } else {
1801                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_site_name)->tp_name);
1802                         return false;
1803                 }
1804         }
1805         PY_CHECK_TYPE(&PyInt_Type, py_dns_ttl, return false;);
1806         r->in.dns_ttl = PyInt_AsLong(py_dns_ttl);
1807         r->in.dns_names = talloc_ptrtype(r, r->in.dns_names);
1808         PY_CHECK_TYPE(NL_DNS_NAME_INFO_ARRAY_Type, py_dns_names, return false;);
1809         if (talloc_reference(r, pytalloc_get_mem_ctx(py_dns_names)) == NULL) {
1810                 PyErr_NoMemory();
1811                 return false;
1812         }
1813         r->in.dns_names = (struct NL_DNS_NAME_INFO_ARRAY *)pytalloc_get_ptr(py_dns_names);
1814         return true;
1815 }
1816
1817 static PyObject *unpack_py_dnsupdate_RODC_args_out(struct dnsupdate_RODC *r)
1818 {
1819         PyObject *result;
1820         PyObject *py_dns_names;
1821         py_dns_names = pytalloc_reference_ex(NL_DNS_NAME_INFO_ARRAY_Type, r->out.dns_names, r->out.dns_names);
1822         result = py_dns_names;
1823         if (NT_STATUS_IS_ERR(r->out.result)) {
1824                 PyErr_SetNTSTATUS(r->out.result);
1825                 return NULL;
1826         }
1827
1828         return result;
1829 }
1830
1831 const struct PyNdrRpcMethodDef py_ndr_irpc_methods[] = {
1832         { "uptime", "S.uptime() -> start_time", (py_dcerpc_call_fn)dcerpc_irpc_uptime_r, (py_data_pack_fn)pack_py_irpc_uptime_args_in, (py_data_unpack_fn)unpack_py_irpc_uptime_args_out, 0, &ndr_table_irpc },
1833         { "nbtd_information", "S.nbtd_information(level) -> info", (py_dcerpc_call_fn)dcerpc_nbtd_information_r, (py_data_pack_fn)pack_py_nbtd_information_args_in, (py_data_unpack_fn)unpack_py_nbtd_information_args_out, 1, &ndr_table_irpc },
1834         { "nbtd_getdcname", "S.nbtd_getdcname(domainname, ip_address, my_computername, my_accountname, account_control, domain_sid) -> dcname", (py_dcerpc_call_fn)dcerpc_nbtd_getdcname_r, (py_data_pack_fn)pack_py_nbtd_getdcname_args_in, (py_data_unpack_fn)unpack_py_nbtd_getdcname_args_out, 2, &ndr_table_irpc },
1835         { "nbtd_proxy_wins_challenge", "S.nbtd_proxy_wins_challenge(name, num_addrs, addrs) -> (num_addrs, addrs)", (py_dcerpc_call_fn)dcerpc_nbtd_proxy_wins_challenge_r, (py_data_pack_fn)pack_py_nbtd_proxy_wins_challenge_args_in, (py_data_unpack_fn)unpack_py_nbtd_proxy_wins_challenge_args_out, 3, &ndr_table_irpc },
1836         { "nbtd_proxy_wins_release_demand", "S.nbtd_proxy_wins_release_demand(name, num_addrs, addrs) -> None", (py_dcerpc_call_fn)dcerpc_nbtd_proxy_wins_release_demand_r, (py_data_pack_fn)pack_py_nbtd_proxy_wins_release_demand_args_in, (py_data_unpack_fn)unpack_py_nbtd_proxy_wins_release_demand_args_out, 4, &ndr_table_irpc },
1837         { "kdc_check_generic_kerberos", "S.kdc_check_generic_kerberos(generic_request) -> generic_reply", (py_dcerpc_call_fn)dcerpc_kdc_check_generic_kerberos_r, (py_data_pack_fn)pack_py_kdc_check_generic_kerberos_args_in, (py_data_unpack_fn)unpack_py_kdc_check_generic_kerberos_args_out, 5, &ndr_table_irpc },
1838         { "smbsrv_information", "S.smbsrv_information(level) -> info", (py_dcerpc_call_fn)dcerpc_smbsrv_information_r, (py_data_pack_fn)pack_py_smbsrv_information_args_in, (py_data_unpack_fn)unpack_py_smbsrv_information_args_out, 6, &ndr_table_irpc },
1839         { "samba_terminate", "S.samba_terminate(reason) -> None", (py_dcerpc_call_fn)dcerpc_samba_terminate_r, (py_data_pack_fn)pack_py_samba_terminate_args_in, (py_data_unpack_fn)unpack_py_samba_terminate_args_out, 7, &ndr_table_irpc },
1840         { "dreplsrv_refresh", "S.dreplsrv_refresh() -> None", (py_dcerpc_call_fn)dcerpc_dreplsrv_refresh_r, (py_data_pack_fn)pack_py_dreplsrv_refresh_args_in, (py_data_unpack_fn)unpack_py_dreplsrv_refresh_args_out, 8, &ndr_table_irpc },
1841         { "drepl_takeFSMORole", "S.drepl_takeFSMORole(role) -> None", (py_dcerpc_call_fn)dcerpc_drepl_takeFSMORole_r, (py_data_pack_fn)pack_py_drepl_takeFSMORole_args_in, (py_data_unpack_fn)unpack_py_drepl_takeFSMORole_args_out, 9, &ndr_table_irpc },
1842         { "drepl_trigger_repl_secret", "S.drepl_trigger_repl_secret(user_dn) -> None", (py_dcerpc_call_fn)dcerpc_drepl_trigger_repl_secret_r, (py_data_pack_fn)pack_py_drepl_trigger_repl_secret_args_in, (py_data_unpack_fn)unpack_py_drepl_trigger_repl_secret_args_out, 10, &ndr_table_irpc },
1843         { "dnsupdate_RODC", "S.dnsupdate_RODC(dom_sid, site_name, dns_ttl, dns_names) -> dns_names", (py_dcerpc_call_fn)dcerpc_dnsupdate_RODC_r, (py_data_pack_fn)pack_py_dnsupdate_RODC_args_in, (py_data_unpack_fn)unpack_py_dnsupdate_RODC_args_out, 11, &ndr_table_irpc },
1844         { NULL }
1845 };
1846
1847 static PyObject *interface_irpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1848 {
1849         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_irpc);
1850 }
1851
1852 static PyTypeObject irpc_InterfaceType = {
1853         PyObject_HEAD_INIT(NULL) 0,
1854         .tp_name = "irpc.irpc",
1855         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
1856         .tp_doc = "irpc(binding, lp_ctx=None, credentials=None) -> connection\n"
1857 "\n"
1858 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
1859 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
1860 "credentials should be a credentials.Credentials object.\n\n",
1861         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1862         .tp_new = interface_irpc_new,
1863 };
1864
1865 static PyMethodDef irpc_methods[] = {
1866         { NULL, NULL, 0, NULL }
1867 };
1868
1869 void initirpc(void)
1870 {
1871         PyObject *m;
1872         PyObject *dep_samba_dcerpc_nbt;
1873         PyObject *dep_samba_dcerpc_security;
1874         PyObject *dep_talloc;
1875         PyObject *dep_samba_dcerpc_misc;
1876         PyObject *dep_samba_dcerpc_base;
1877         PyObject *dep_samba_dcerpc_netlogon;
1878         PyObject *dep_samba_dcerpc_server_id;
1879
1880         dep_samba_dcerpc_nbt = PyImport_ImportModule("samba.dcerpc.nbt");
1881         if (dep_samba_dcerpc_nbt == NULL)
1882                 return;
1883
1884         dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
1885         if (dep_samba_dcerpc_security == NULL)
1886                 return;
1887
1888         dep_talloc = PyImport_ImportModule("talloc");
1889         if (dep_talloc == NULL)
1890                 return;
1891
1892         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
1893         if (dep_samba_dcerpc_misc == NULL)
1894                 return;
1895
1896         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
1897         if (dep_samba_dcerpc_base == NULL)
1898                 return;
1899
1900         dep_samba_dcerpc_netlogon = PyImport_ImportModule("samba.dcerpc.netlogon");
1901         if (dep_samba_dcerpc_netlogon == NULL)
1902                 return;
1903
1904         dep_samba_dcerpc_server_id = PyImport_ImportModule("samba.dcerpc.server_id");
1905         if (dep_samba_dcerpc_server_id == NULL)
1906                 return;
1907
1908         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "dom_sid");
1909         if (dom_sid_Type == NULL)
1910                 return;
1911
1912         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
1913         if (GUID_Type == NULL)
1914                 return;
1915
1916         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
1917         if (ClientConnection_Type == NULL)
1918                 return;
1919
1920         security_token_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "token");
1921         if (security_token_Type == NULL)
1922                 return;
1923
1924         server_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_server_id, "server_id");
1925         if (server_id_Type == NULL)
1926                 return;
1927
1928         NL_DNS_NAME_INFO_ARRAY_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_netlogon, "NL_DNS_NAME_INFO_ARRAY");
1929         if (NL_DNS_NAME_INFO_ARRAY_Type == NULL)
1930                 return;
1931
1932         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
1933         if (Object_Type == NULL)
1934                 return;
1935
1936         nbt_name_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_nbt, "name");
1937         if (nbt_name_Type == NULL)
1938                 return;
1939
1940         irpc_creds_Type.tp_base = Object_Type;
1941
1942         irpc_header_Type.tp_base = Object_Type;
1943
1944         irpc_name_record_Type.tp_base = Object_Type;
1945
1946         irpc_name_records_Type.tp_base = Object_Type;
1947
1948         nbtd_statistics_Type.tp_base = Object_Type;
1949
1950         nbtd_proxy_wins_addr_Type.tp_base = Object_Type;
1951
1952         smbsrv_session_info_Type.tp_base = Object_Type;
1953
1954         smbsrv_sessions_Type.tp_base = Object_Type;
1955
1956         smbsrv_tcon_info_Type.tp_base = Object_Type;
1957
1958         smbsrv_tcons_Type.tp_base = Object_Type;
1959
1960         irpc_InterfaceType.tp_base = ClientConnection_Type;
1961
1962         if (PyType_Ready(&irpc_creds_Type) < 0)
1963                 return;
1964         if (PyType_Ready(&irpc_header_Type) < 0)
1965                 return;
1966         if (PyType_Ready(&irpc_name_record_Type) < 0)
1967                 return;
1968         if (PyType_Ready(&irpc_name_records_Type) < 0)
1969                 return;
1970         if (PyType_Ready(&nbtd_statistics_Type) < 0)
1971                 return;
1972         if (PyType_Ready(&nbtd_proxy_wins_addr_Type) < 0)
1973                 return;
1974         if (PyType_Ready(&smbsrv_session_info_Type) < 0)
1975                 return;
1976         if (PyType_Ready(&smbsrv_sessions_Type) < 0)
1977                 return;
1978         if (PyType_Ready(&smbsrv_tcon_info_Type) < 0)
1979                 return;
1980         if (PyType_Ready(&smbsrv_tcons_Type) < 0)
1981                 return;
1982         if (PyType_Ready(&irpc_InterfaceType) < 0)
1983                 return;
1984         if (!PyInterface_AddNdrRpcMethods(&irpc_InterfaceType, py_ndr_irpc_methods))
1985                 return;
1986
1987 #ifdef PY_CREDS_PATCH
1988         PY_CREDS_PATCH(&irpc_creds_Type);
1989 #endif
1990 #ifdef PY_HEADER_PATCH
1991         PY_HEADER_PATCH(&irpc_header_Type);
1992 #endif
1993 #ifdef PY_NAME_RECORD_PATCH
1994         PY_NAME_RECORD_PATCH(&irpc_name_record_Type);
1995 #endif
1996 #ifdef PY_NAME_RECORDS_PATCH
1997         PY_NAME_RECORDS_PATCH(&irpc_name_records_Type);
1998 #endif
1999 #ifdef PY_NBTD_STATISTICS_PATCH
2000         PY_NBTD_STATISTICS_PATCH(&nbtd_statistics_Type);
2001 #endif
2002 #ifdef PY_NBTD_PROXY_WINS_ADDR_PATCH
2003         PY_NBTD_PROXY_WINS_ADDR_PATCH(&nbtd_proxy_wins_addr_Type);
2004 #endif
2005 #ifdef PY_SMBSRV_SESSION_INFO_PATCH
2006         PY_SMBSRV_SESSION_INFO_PATCH(&smbsrv_session_info_Type);
2007 #endif
2008 #ifdef PY_SMBSRV_SESSIONS_PATCH
2009         PY_SMBSRV_SESSIONS_PATCH(&smbsrv_sessions_Type);
2010 #endif
2011 #ifdef PY_SMBSRV_TCON_INFO_PATCH
2012         PY_SMBSRV_TCON_INFO_PATCH(&smbsrv_tcon_info_Type);
2013 #endif
2014 #ifdef PY_SMBSRV_TCONS_PATCH
2015         PY_SMBSRV_TCONS_PATCH(&smbsrv_tcons_Type);
2016 #endif
2017 #ifdef PY_IRPC_PATCH
2018         PY_IRPC_PATCH(&irpc_InterfaceType);
2019 #endif
2020
2021         m = Py_InitModule3("irpc", irpc_methods, "irpc DCE/RPC");
2022         if (m == NULL)
2023                 return;
2024
2025         PyModule_AddObject(m, "DREPL_INFRASTRUCTURE_MASTER", PyInt_FromLong(DREPL_INFRASTRUCTURE_MASTER));
2026         PyModule_AddObject(m, "NBTD_INFO_STATISTICS", PyInt_FromLong(NBTD_INFO_STATISTICS));
2027         PyModule_AddObject(m, "DREPL_PDC_MASTER", PyInt_FromLong(DREPL_PDC_MASTER));
2028         PyModule_AddObject(m, "DREPL_SCHEMA_MASTER", PyInt_FromLong(DREPL_SCHEMA_MASTER));
2029         PyModule_AddObject(m, "DREPL_NAMING_MASTER", PyInt_FromLong(DREPL_NAMING_MASTER));
2030         PyModule_AddObject(m, "SMBSRV_INFO_TCONS", PyInt_FromLong(SMBSRV_INFO_TCONS));
2031         PyModule_AddObject(m, "SMBSRV_INFO_SESSIONS", PyInt_FromLong(SMBSRV_INFO_SESSIONS));
2032         PyModule_AddObject(m, "IRPC_FLAG_REPLY", PyInt_FromLong(IRPC_FLAG_REPLY));
2033         PyModule_AddObject(m, "DREPL_RID_MASTER", PyInt_FromLong(DREPL_RID_MASTER));
2034         Py_INCREF((PyObject *)(void *)&irpc_creds_Type);
2035         PyModule_AddObject(m, "creds", (PyObject *)(void *)&irpc_creds_Type);
2036         Py_INCREF((PyObject *)(void *)&irpc_header_Type);
2037         PyModule_AddObject(m, "header", (PyObject *)(void *)&irpc_header_Type);
2038         Py_INCREF((PyObject *)(void *)&irpc_name_record_Type);
2039         PyModule_AddObject(m, "name_record", (PyObject *)(void *)&irpc_name_record_Type);
2040         Py_INCREF((PyObject *)(void *)&irpc_name_records_Type);
2041         PyModule_AddObject(m, "name_records", (PyObject *)(void *)&irpc_name_records_Type);
2042         Py_INCREF((PyObject *)(void *)&nbtd_statistics_Type);
2043         PyModule_AddObject(m, "nbtd_statistics", (PyObject *)(void *)&nbtd_statistics_Type);
2044         Py_INCREF((PyObject *)(void *)&nbtd_proxy_wins_addr_Type);
2045         PyModule_AddObject(m, "nbtd_proxy_wins_addr", (PyObject *)(void *)&nbtd_proxy_wins_addr_Type);
2046         Py_INCREF((PyObject *)(void *)&smbsrv_session_info_Type);
2047         PyModule_AddObject(m, "smbsrv_session_info", (PyObject *)(void *)&smbsrv_session_info_Type);
2048         Py_INCREF((PyObject *)(void *)&smbsrv_sessions_Type);
2049         PyModule_AddObject(m, "smbsrv_sessions", (PyObject *)(void *)&smbsrv_sessions_Type);
2050         Py_INCREF((PyObject *)(void *)&smbsrv_tcon_info_Type);
2051         PyModule_AddObject(m, "smbsrv_tcon_info", (PyObject *)(void *)&smbsrv_tcon_info_Type);
2052         Py_INCREF((PyObject *)(void *)&smbsrv_tcons_Type);
2053         PyModule_AddObject(m, "smbsrv_tcons", (PyObject *)(void *)&smbsrv_tcons_Type);
2054         Py_INCREF((PyObject *)(void *)&irpc_InterfaceType);
2055         PyModule_AddObject(m, "irpc", (PyObject *)(void *)&irpc_InterfaceType);
2056 #ifdef PY_MOD_IRPC_PATCH
2057         PY_MOD_IRPC_PATCH(m);
2058 #endif
2059
2060 }