bin/default/librpc/gen_ndr/py_browser.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
   4 #include <Python.h>
   5 #include "includes.h"
   6 #include <pytalloc.h>
   7 #include "librpc/rpc/pyrpc.h"
   8 #include "librpc/rpc/pyrpc_util.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_browser.h"
  10 #include "bin/default/librpc/gen_ndr/ndr_browser_c.h"
  11
  12 /*
  13  * These functions are here to ensure they can be optimized out by
  14  * the compiler based on the constant input values
  15  */
  16
  17 static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
  18 {
  19         switch (var_size) {
  20         case 8:
  21                 return UINT64_MAX;
  22         case 4:
  23                 return UINT32_MAX;
  24         case 2:
  25                 return UINT16_MAX;
  26         case 1:
  27                 return UINT8_MAX;
  28         }
  29
  30         return 0;
  31 }
  32
  33 static inline long long ndr_sizeof2intmax(size_t var_size)
  34 {
  35         switch (var_size) {
  36         case 8:
  37                 return INT64_MAX;
  38         case 4:
  39                 return INT32_MAX;
  40         case 2:
  41                 return INT16_MAX;
  42         case 1:
  43                 return INT8_MAX;
  44         }
  45
  46         return 0;
  47 }
  48
  49 static inline PyObject *ndr_PyLong_FromLongLong(long long v)
  50 {
  51         if (v > LONG_MAX || v < LONG_MIN) {
  52                 return PyLong_FromLongLong(v);
  53         } else {
  54                 return PyInt_FromLong(v);
  55         }
  56 }
  57
  58 static inline PyObject *ndr_PyLong_FromUnsignedLongLong(unsigned long long v)
  59 {
  60         if (v > LONG_MAX) {
  61                 return PyLong_FromUnsignedLongLong(v);
  62         } else {
  63                 return PyInt_FromLong(v);
  64         }
  65 }
  66
  67 #include "librpc/gen_ndr/srvsvc.h"
  68 static PyTypeObject BrowserrSrvInfo100Ctr_Type;
  69 static PyTypeObject BrowserrSrvInfo101Ctr_Type;
  70 PyObject *py_import_BrowserrSrvInfoUnion(TALLOC_CTX *mem_ctx, int level, union BrowserrSrvInfoUnion *in);
  71 union BrowserrSrvInfoUnion *py_export_BrowserrSrvInfoUnion(TALLOC_CTX *mem_ctx, int level, PyObject *in);
  72 static PyTypeObject BrowserrSrvInfo_Type;
  73 static PyTypeObject browser_InterfaceType;
  74
  75 void initbrowser(void);static PyTypeObject *srvsvc_NetSrvInfo100_Type;
  76 static PyTypeObject *BaseObject_Type;
  77 static PyTypeObject *srvsvc_NetSrvInfo101_Type;
  78 static PyTypeObject *ClientConnection_Type;
  79 static PyTypeObject *ndr_syntax_id_Type;
  80
  81 static PyObject *py_BrowserrSrvInfo100Ctr_get_entries_read(PyObject *obj, void *closure)
  82 {
  83         struct BrowserrSrvInfo100Ctr *object = (struct BrowserrSrvInfo100Ctr *)pytalloc_get_ptr(obj);
  84         PyObject *py_entries_read;
  85         py_entries_read = ndr_PyLong_FromUnsignedLongLong((uint32_t)object->entries_read);
  86         return py_entries_read;
  87 }
  88
  89 static int py_BrowserrSrvInfo100Ctr_set_entries_read(PyObject *py_obj, PyObject *value, void *closure)
  90 {
  91         struct BrowserrSrvInfo100Ctr *object = (struct BrowserrSrvInfo100Ctr *)pytalloc_get_ptr(py_obj);
  92         if (value == NULL) {
  93                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries_read");
  94                 return -1;
  95         }
  96         {
  97                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->entries_read));
  98                 if (PyLong_Check(value)) {
  99                         unsigned long long test_var;
 100                         test_var = PyLong_AsUnsignedLongLong(value);
 101                         if (PyErr_Occurred() != NULL) {
 102                                 return -1;
 103                         }
 104                         if (test_var > uint_max) {
 105                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %llu",\
 106                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 107                                 return -1;
 108                         }
 109                         object->entries_read = test_var;
 110                 } else if (PyInt_Check(value)) {
 111                         long test_var;
 112                         test_var = PyInt_AsLong(value);
 113                         if (test_var < 0 || test_var > uint_max) {
 114                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %ld",\
 115                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 116                                 return -1;
 117                         }
 118                         object->entries_read = test_var;
 119                 } else {
 120                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 121                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 122                         return -1;
 123                 }
 124         }
 125         return 0;
 126 }
 127
 128 static PyObject *py_BrowserrSrvInfo100Ctr_get_entries(PyObject *obj, void *closure)
 129 {
 130         struct BrowserrSrvInfo100Ctr *object = (struct BrowserrSrvInfo100Ctr *)pytalloc_get_ptr(obj);
 131         PyObject *py_entries;
 132         if (object->entries == NULL) {
 133                 py_entries = Py_None;
 134                 Py_INCREF(py_entries);
 135         } else {
 136                 py_entries = PyList_New(object->entries_read);
 137                 if (py_entries == NULL) {
 138                         return NULL;
 139                 }
 140                 {
 141                         int entries_cntr_1;
 142                         for (entries_cntr_1 = 0; entries_cntr_1 < (object->entries_read); entries_cntr_1++) {
 143                                 PyObject *py_entries_1;
 144                                 py_entries_1 = pytalloc_reference_ex(srvsvc_NetSrvInfo100_Type, object->entries, &object->entries[entries_cntr_1]);
 145                                 PyList_SetItem(py_entries, entries_cntr_1, py_entries_1);
 146                         }
 147                 }
 148         }
 149         return py_entries;
 150 }
 151
 152 static int py_BrowserrSrvInfo100Ctr_set_entries(PyObject *py_obj, PyObject *value, void *closure)
 153 {
 154         struct BrowserrSrvInfo100Ctr *object = (struct BrowserrSrvInfo100Ctr *)pytalloc_get_ptr(py_obj);
 155         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->entries));
 156         if (value == NULL) {
 157                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries");
 158                 return -1;
 159         }
 160         if (value == Py_None) {
 161                 object->entries = NULL;
 162         } else {
 163                 object->entries = NULL;
 164                 if (value == NULL) {
 165                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *object->entries");
 166                         return -1;
 167                 }
 168                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 169                 {
 170                         int entries_cntr_1;
 171                         object->entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->entries, PyList_GET_SIZE(value));
 172                         if (!object->entries) { return -1;; }
 173                         talloc_set_name_const(object->entries, "ARRAY: object->entries");
 174                         for (entries_cntr_1 = 0; entries_cntr_1 < PyList_GET_SIZE(value); entries_cntr_1++) {
 175                                 if (PyList_GET_ITEM(value, entries_cntr_1) == NULL) {
 176                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries[entries_cntr_1]");
 177                                         return -1;
 178                                 }
 179                                 PY_CHECK_TYPE(srvsvc_NetSrvInfo100_Type, PyList_GET_ITEM(value, entries_cntr_1), return -1;);
 180                                 if (talloc_reference(object->entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, entries_cntr_1))) == NULL) {
 181                                         PyErr_NoMemory();
 182                                         return -1;
 183                                 }
 184                                 object->entries[entries_cntr_1] = *(struct srvsvc_NetSrvInfo100 *)pytalloc_get_ptr(PyList_GET_ITEM(value, entries_cntr_1));
 185                         }
 186                 }
 187         }
 188         return 0;
 189 }
 190
 191 static PyGetSetDef py_BrowserrSrvInfo100Ctr_getsetters[] = {
 192         {
 193                 .name = discard_const_p(char, "entries_read"),
 194                 .get = py_BrowserrSrvInfo100Ctr_get_entries_read,
 195                 .set = py_BrowserrSrvInfo100Ctr_set_entries_read,
 196                 .doc = discard_const_p(char, "PIDL-generated element entries_read")
 197         },
 198         {
 199                 .name = discard_const_p(char, "entries"),
 200                 .get = py_BrowserrSrvInfo100Ctr_get_entries,
 201                 .set = py_BrowserrSrvInfo100Ctr_set_entries,
 202                 .doc = discard_const_p(char, "PIDL-generated element entries")
 203         },
 204         { .name = NULL }
 205 };
 206
 207 static PyObject *py_BrowserrSrvInfo100Ctr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 208 {
 209         return pytalloc_new(struct BrowserrSrvInfo100Ctr, type);
 210 }
 211
 212
 213 static PyTypeObject BrowserrSrvInfo100Ctr_Type = {
 214         PyObject_HEAD_INIT(NULL) 0,
 215         .tp_name = "browser.BrowserrSrvInfo100Ctr",
 216         .tp_getset = py_BrowserrSrvInfo100Ctr_getsetters,
 217         .tp_methods = NULL,
 218         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 219         .tp_new = py_BrowserrSrvInfo100Ctr_new,
 220 };
 221
 222
 223 static PyObject *py_BrowserrSrvInfo101Ctr_get_entries_read(PyObject *obj, void *closure)
 224 {
 225         struct BrowserrSrvInfo101Ctr *object = (struct BrowserrSrvInfo101Ctr *)pytalloc_get_ptr(obj);
 226         PyObject *py_entries_read;
 227         py_entries_read = ndr_PyLong_FromUnsignedLongLong((uint32_t)object->entries_read);
 228         return py_entries_read;
 229 }
 230
 231 static int py_BrowserrSrvInfo101Ctr_set_entries_read(PyObject *py_obj, PyObject *value, void *closure)
 232 {
 233         struct BrowserrSrvInfo101Ctr *object = (struct BrowserrSrvInfo101Ctr *)pytalloc_get_ptr(py_obj);
 234         if (value == NULL) {
 235                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries_read");
 236                 return -1;
 237         }
 238         {
 239                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->entries_read));
 240                 if (PyLong_Check(value)) {
 241                         unsigned long long test_var;
 242                         test_var = PyLong_AsUnsignedLongLong(value);
 243                         if (PyErr_Occurred() != NULL) {
 244                                 return -1;
 245                         }
 246                         if (test_var > uint_max) {
 247                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %llu",\
 248                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 249                                 return -1;
 250                         }
 251                         object->entries_read = test_var;
 252                 } else if (PyInt_Check(value)) {
 253                         long test_var;
 254                         test_var = PyInt_AsLong(value);
 255                         if (test_var < 0 || test_var > uint_max) {
 256                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %ld",\
 257                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 258                                 return -1;
 259                         }
 260                         object->entries_read = test_var;
 261                 } else {
 262                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 263                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 264                         return -1;
 265                 }
 266         }
 267         return 0;
 268 }
 269
 270 static PyObject *py_BrowserrSrvInfo101Ctr_get_entries(PyObject *obj, void *closure)
 271 {
 272         struct BrowserrSrvInfo101Ctr *object = (struct BrowserrSrvInfo101Ctr *)pytalloc_get_ptr(obj);
 273         PyObject *py_entries;
 274         if (object->entries == NULL) {
 275                 py_entries = Py_None;
 276                 Py_INCREF(py_entries);
 277         } else {
 278                 py_entries = PyList_New(object->entries_read);
 279                 if (py_entries == NULL) {
 280                         return NULL;
 281                 }
 282                 {
 283                         int entries_cntr_1;
 284                         for (entries_cntr_1 = 0; entries_cntr_1 < (object->entries_read); entries_cntr_1++) {
 285                                 PyObject *py_entries_1;
 286                                 py_entries_1 = pytalloc_reference_ex(srvsvc_NetSrvInfo101_Type, object->entries, &object->entries[entries_cntr_1]);
 287                                 PyList_SetItem(py_entries, entries_cntr_1, py_entries_1);
 288                         }
 289                 }
 290         }
 291         return py_entries;
 292 }
 293
 294 static int py_BrowserrSrvInfo101Ctr_set_entries(PyObject *py_obj, PyObject *value, void *closure)
 295 {
 296         struct BrowserrSrvInfo101Ctr *object = (struct BrowserrSrvInfo101Ctr *)pytalloc_get_ptr(py_obj);
 297         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->entries));
 298         if (value == NULL) {
 299                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries");
 300                 return -1;
 301         }
 302         if (value == Py_None) {
 303                 object->entries = NULL;
 304         } else {
 305                 object->entries = NULL;
 306                 if (value == NULL) {
 307                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *object->entries");
 308                         return -1;
 309                 }
 310                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 311                 {
 312                         int entries_cntr_1;
 313                         object->entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->entries, PyList_GET_SIZE(value));
 314                         if (!object->entries) { return -1;; }
 315                         talloc_set_name_const(object->entries, "ARRAY: object->entries");
 316                         for (entries_cntr_1 = 0; entries_cntr_1 < PyList_GET_SIZE(value); entries_cntr_1++) {
 317                                 if (PyList_GET_ITEM(value, entries_cntr_1) == NULL) {
 318                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entries[entries_cntr_1]");
 319                                         return -1;
 320                                 }
 321                                 PY_CHECK_TYPE(srvsvc_NetSrvInfo101_Type, PyList_GET_ITEM(value, entries_cntr_1), return -1;);
 322                                 if (talloc_reference(object->entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, entries_cntr_1))) == NULL) {
 323                                         PyErr_NoMemory();
 324                                         return -1;
 325                                 }
 326                                 object->entries[entries_cntr_1] = *(struct srvsvc_NetSrvInfo101 *)pytalloc_get_ptr(PyList_GET_ITEM(value, entries_cntr_1));
 327                         }
 328                 }
 329         }
 330         return 0;
 331 }
 332
 333 static PyGetSetDef py_BrowserrSrvInfo101Ctr_getsetters[] = {
 334         {
 335                 .name = discard_const_p(char, "entries_read"),
 336                 .get = py_BrowserrSrvInfo101Ctr_get_entries_read,
 337                 .set = py_BrowserrSrvInfo101Ctr_set_entries_read,
 338                 .doc = discard_const_p(char, "PIDL-generated element entries_read")
 339         },
 340         {
 341                 .name = discard_const_p(char, "entries"),
 342                 .get = py_BrowserrSrvInfo101Ctr_get_entries,
 343                 .set = py_BrowserrSrvInfo101Ctr_set_entries,
 344                 .doc = discard_const_p(char, "PIDL-generated element entries")
 345         },
 346         { .name = NULL }
 347 };
 348
 349 static PyObject *py_BrowserrSrvInfo101Ctr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 350 {
 351         return pytalloc_new(struct BrowserrSrvInfo101Ctr, type);
 352 }
 353
 354
 355 static PyTypeObject BrowserrSrvInfo101Ctr_Type = {
 356         PyObject_HEAD_INIT(NULL) 0,
 357         .tp_name = "browser.BrowserrSrvInfo101Ctr",
 358         .tp_getset = py_BrowserrSrvInfo101Ctr_getsetters,
 359         .tp_methods = NULL,
 360         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 361         .tp_new = py_BrowserrSrvInfo101Ctr_new,
 362 };
 363
 364 PyObject *py_import_BrowserrSrvInfoUnion(TALLOC_CTX *mem_ctx, int level, union BrowserrSrvInfoUnion *in)
 365 {
 366         PyObject *ret;
 367
 368         switch (level) {
 369                 case 100:
 370                         if (in->info100 == NULL) {
 371                                 ret = Py_None;
 372                                 Py_INCREF(ret);
 373                         } else {
 374                                 ret = pytalloc_reference_ex(&BrowserrSrvInfo100Ctr_Type, in->info100, in->info100);
 375                         }
 376                         return ret;
 377
 378                 case 101:
 379                         if (in->info101 == NULL) {
 380                                 ret = Py_None;
 381                                 Py_INCREF(ret);
 382                         } else {
 383                                 ret = pytalloc_reference_ex(&BrowserrSrvInfo101Ctr_Type, in->info101, in->info101);
 384                         }
 385                         return ret;
 386
 387                 default:
 388                         ret = Py_None;
 389                         Py_INCREF(ret);
 390                         return ret;
 391
 392         }
 393         PyErr_SetString(PyExc_TypeError, "unknown union level");
 394         return NULL;
 395 }
 396
 397 union BrowserrSrvInfoUnion *py_export_BrowserrSrvInfoUnion(TALLOC_CTX *mem_ctx, int level, PyObject *in)
 398 {
 399         union BrowserrSrvInfoUnion *ret = talloc_zero(mem_ctx, union BrowserrSrvInfoUnion);
 400         switch (level) {
 401                 case 100:
 402                         if (in == NULL) {
 403                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->info100");
 404                                 talloc_free(ret); return NULL;
 405                         }
 406                         if (in == Py_None) {
 407                                 ret->info100 = NULL;
 408                         } else {
 409                                 ret->info100 = NULL;
 410                                 if (in == NULL) {
 411                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *ret->info100");
 412                                         talloc_free(ret); return NULL;
 413                                 }
 414                                 PY_CHECK_TYPE(&BrowserrSrvInfo100Ctr_Type, in, talloc_free(ret); return NULL;);
 415                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 416                                         PyErr_NoMemory();
 417                                         talloc_free(ret); return NULL;
 418                                 }
 419                                 ret->info100 = (struct BrowserrSrvInfo100Ctr *)pytalloc_get_ptr(in);
 420                         }
 421                         break;
 422
 423                 case 101:
 424                         if (in == NULL) {
 425                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->info101");
 426                                 talloc_free(ret); return NULL;
 427                         }
 428                         if (in == Py_None) {
 429                                 ret->info101 = NULL;
 430                         } else {
 431                                 ret->info101 = NULL;
 432                                 if (in == NULL) {
 433                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *ret->info101");
 434                                         talloc_free(ret); return NULL;
 435                                 }
 436                                 PY_CHECK_TYPE(&BrowserrSrvInfo101Ctr_Type, in, talloc_free(ret); return NULL;);
 437                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
 438                                         PyErr_NoMemory();
 439                                         talloc_free(ret); return NULL;
 440                                 }
 441                                 ret->info101 = (struct BrowserrSrvInfo101Ctr *)pytalloc_get_ptr(in);
 442                         }
 443                         break;
 444
 445                 default:
 446                         break;
 447
 448         }
 449
 450         return ret;
 451 }
 452
 453
 454 static PyObject *py_BrowserrSrvInfo_get_level(PyObject *obj, void *closure)
 455 {
 456         struct BrowserrSrvInfo *object = (struct BrowserrSrvInfo *)pytalloc_get_ptr(obj);
 457         PyObject *py_level;
 458         py_level = ndr_PyLong_FromUnsignedLongLong((uint32_t)object->level);
 459         return py_level;
 460 }
 461
 462 static int py_BrowserrSrvInfo_set_level(PyObject *py_obj, PyObject *value, void *closure)
 463 {
 464         struct BrowserrSrvInfo *object = (struct BrowserrSrvInfo *)pytalloc_get_ptr(py_obj);
 465         if (value == NULL) {
 466                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->level");
 467                 return -1;
 468         }
 469         {
 470                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->level));
 471                 if (PyLong_Check(value)) {
 472                         unsigned long long test_var;
 473                         test_var = PyLong_AsUnsignedLongLong(value);
 474                         if (PyErr_Occurred() != NULL) {
 475                                 return -1;
 476                         }
 477                         if (test_var > uint_max) {
 478                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %llu",\
 479                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 480                                 return -1;
 481                         }
 482                         object->level = test_var;
 483                 } else if (PyInt_Check(value)) {
 484                         long test_var;
 485                         test_var = PyInt_AsLong(value);
 486                         if (test_var < 0 || test_var > uint_max) {
 487                                 PyErr_Format(PyExc_OverflowError, "Expected type %s or %s within range 0 - %llu, got %ld",\
 488                                   PyInt_Type.tp_name, PyLong_Type.tp_name, uint_max, test_var);
 489                                 return -1;
 490                         }
 491                         object->level = test_var;
 492                 } else {
 493                         PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 494                           PyInt_Type.tp_name, PyLong_Type.tp_name);
 495                         return -1;
 496                 }
 497         }
 498         return 0;
 499 }
 500
 501 static PyObject *py_BrowserrSrvInfo_get_info(PyObject *obj, void *closure)
 502 {
 503         struct BrowserrSrvInfo *object = (struct BrowserrSrvInfo *)pytalloc_get_ptr(obj);
 504         PyObject *py_info;
 505         py_info = py_import_BrowserrSrvInfoUnion(pytalloc_get_mem_ctx(obj), object->level, &object->info);
 506         if (py_info == NULL) {
 507                 return NULL;
 508         }
 509         return py_info;
 510 }
 511
 512 static int py_BrowserrSrvInfo_set_info(PyObject *py_obj, PyObject *value, void *closure)
 513 {
 514         struct BrowserrSrvInfo *object = (struct BrowserrSrvInfo *)pytalloc_get_ptr(py_obj);
 515         if (value == NULL) {
 516                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->info");
 517                 return -1;
 518         }
 519         {
 520                 union BrowserrSrvInfoUnion *info_switch_0;
 521                 info_switch_0 = py_export_BrowserrSrvInfoUnion(pytalloc_get_mem_ctx(py_obj), object->level, value);
 522                 if (info_switch_0 == NULL) {
 523                         return -1;
 524                 }
 525                 object->info = *info_switch_0;
 526         }
 527         return 0;
 528 }
 529
 530 static PyGetSetDef py_BrowserrSrvInfo_getsetters[] = {
 531         {
 532                 .name = discard_const_p(char, "level"),
 533                 .get = py_BrowserrSrvInfo_get_level,
 534                 .set = py_BrowserrSrvInfo_set_level,
 535                 .doc = discard_const_p(char, "PIDL-generated element level")
 536         },
 537         {
 538                 .name = discard_const_p(char, "info"),
 539                 .get = py_BrowserrSrvInfo_get_info,
 540                 .set = py_BrowserrSrvInfo_set_info,
 541                 .doc = discard_const_p(char, "PIDL-generated element info")
 542         },
 543         { .name = NULL }
 544 };
 545
 546 static PyObject *py_BrowserrSrvInfo_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 547 {
 548         return pytalloc_new(struct BrowserrSrvInfo, type);
 549 }
 550
 551
 552 static PyTypeObject BrowserrSrvInfo_Type = {
 553         PyObject_HEAD_INIT(NULL) 0,
 554         .tp_name = "browser.BrowserrSrvInfo",
 555         .tp_getset = py_BrowserrSrvInfo_getsetters,
 556         .tp_methods = NULL,
 557         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 558         .tp_new = py_BrowserrSrvInfo_new,
 559 };
 560
 561
 562 static bool pack_py_BrowserrQueryOtherDomains_args_in(PyObject *args, PyObject *kwargs, struct BrowserrQueryOtherDomains *r)
 563 {
 564         PyObject *py_server_unc;
 565         PyObject *py_info;
 566         const char *kwnames[] = {
 567                 "server_unc", "info", NULL
 568         };
 569
 570         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BrowserrQueryOtherDomains", discard_const_p(char *, kwnames), &py_server_unc, &py_info)) {
 571                 return false;
 572         }
 573
 574         if (py_server_unc == NULL) {
 575                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.server_unc");
 576                 return false;
 577         }
 578         if (py_server_unc == Py_None) {
 579                 r->in.server_unc = NULL;
 580         } else {
 581                 r->in.server_unc = NULL;
 582                 if (py_server_unc == NULL) {
 583                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *r->in.server_unc");
 584                         return false;
 585                 }
 586                 {
 587                         const char *test_str;
 588                         const char *talloc_str;
 589                         PyObject *unicode = NULL;
 590                         if (PyUnicode_Check(py_server_unc)) {
 591                                 unicode = PyUnicode_AsEncodedString(py_server_unc, "utf-8", "ignore");
 592                                 if (unicode == NULL) {
 593                                         PyErr_NoMemory();
 594                                         return false;
 595                                 }
 596                                 test_str = PyString_AS_STRING(unicode);
 597                         } else if (PyString_Check(py_server_unc)) {
 598                                 test_str = PyString_AS_STRING(py_server_unc);
 599                         } else {
 600                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_server_unc)->tp_name);
 601                                 return false;
 602                         }
 603                         talloc_str = talloc_strdup(r, test_str);
 604                         if (unicode != NULL) {
 605                                 Py_DECREF(unicode);
 606                         }
 607                         if (talloc_str == NULL) {
 608                                 PyErr_NoMemory();
 609                                 return false;
 610                         }
 611                         r->in.server_unc = talloc_str;
 612                 }
 613         }
 614         if (py_info == NULL) {
 615                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.info");
 616                 return false;
 617         }
 618         r->in.info = talloc_ptrtype(r, r->in.info);
 619         if (py_info == NULL) {
 620                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct *r->in.info");
 621                 return false;
 622         }
 623         PY_CHECK_TYPE(&BrowserrSrvInfo_Type, py_info, return false;);
 624         if (talloc_reference(r, pytalloc_get_mem_ctx(py_info)) == NULL) {
 625                 PyErr_NoMemory();
 626                 return false;
 627         }
 628         r->in.info = (struct BrowserrSrvInfo *)pytalloc_get_ptr(py_info);
 629         return true;
 630 }
 631
 632 static PyObject *unpack_py_BrowserrQueryOtherDomains_args_out(struct BrowserrQueryOtherDomains *r)
 633 {
 634         PyObject *result;
 635         PyObject *py_info;
 636         PyObject *py_total_entries;
 637         result = PyTuple_New(2);
 638         py_info = pytalloc_reference_ex(&BrowserrSrvInfo_Type, r->out.info, r->out.info);
 639         PyTuple_SetItem(result, 0, py_info);
 640         py_total_entries = ndr_PyLong_FromUnsignedLongLong((uint32_t)*r->out.total_entries);
 641         PyTuple_SetItem(result, 1, py_total_entries);
 642         if (!W_ERROR_IS_OK(r->out.result)) {
 643                 PyErr_SetWERROR(r->out.result);
 644                 return NULL;
 645         }
 646
 647         return result;
 648 }
 649
 650 const struct PyNdrRpcMethodDef py_ndr_browser_methods[] = {
 651         { "BrowserrQueryOtherDomains", "S.BrowserrQueryOtherDomains(server_unc, info) -> (info, total_entries)", (py_dcerpc_call_fn)dcerpc_BrowserrQueryOtherDomains_r, (py_data_pack_fn)pack_py_BrowserrQueryOtherDomains_args_in, (py_data_unpack_fn)unpack_py_BrowserrQueryOtherDomains_args_out, 2, &ndr_table_browser },
 652         { NULL }
 653 };
 654
 655 static PyObject *interface_browser_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 656 {
 657         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_browser);
 658 }
 659
 660 #define PY_DOC_BROWSER "Browsing"
 661 static PyTypeObject browser_InterfaceType = {
 662         PyObject_HEAD_INIT(NULL) 0,
 663         .tp_name = "browser.browser",
 664         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
 665         .tp_doc = "browser(binding, lp_ctx=None, credentials=None) -> connection\n"
 666 "\n"
 667 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
 668 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
 669 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_BROWSER,
 670         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 671         .tp_new = interface_browser_new,
 672 };
 673
 674 static PyObject *syntax_browser_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 675 {
 676         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_browser.syntax_id);
 677 }
 678
 679 #define PY_DOC_BROWSER_SYNTAX "Browsing"
 680 static PyTypeObject browser_SyntaxType = {
 681         PyObject_HEAD_INIT(NULL) 0,
 682         .tp_name = "browser.browser",
 683         .tp_doc = "abstract_syntax()\n"PY_DOC_BROWSER_SYNTAX,
 684         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 685         .tp_new = syntax_browser_new,
 686 };
 687
 688 static PyMethodDef browser_methods[] = {
 689         { NULL, NULL, 0, NULL }
 690 };
 691
 692 void initbrowser(void)
 693 {
 694         PyObject *m;
 695         PyObject *dep_samba_dcerpc_srvsvc;
 696         PyObject *dep_talloc;
 697         PyObject *dep_samba_dcerpc_base;
 698         PyObject *dep_samba_dcerpc_misc;
 699
 700         dep_samba_dcerpc_srvsvc = PyImport_ImportModule("samba.dcerpc.srvsvc");
 701         if (dep_samba_dcerpc_srvsvc == NULL)
 702                 return;
 703
 704         dep_talloc = PyImport_ImportModule("talloc");
 705         if (dep_talloc == NULL)
 706                 return;
 707
 708         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
 709         if (dep_samba_dcerpc_base == NULL)
 710                 return;
 711
 712         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
 713         if (dep_samba_dcerpc_misc == NULL)
 714                 return;
 715
 716         srvsvc_NetSrvInfo100_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_srvsvc, "NetSrvInfo100");
 717         if (srvsvc_NetSrvInfo100_Type == NULL)
 718                 return;
 719
 720         BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
 721         if (BaseObject_Type == NULL)
 722                 return;
 723
 724         srvsvc_NetSrvInfo101_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_srvsvc, "NetSrvInfo101");
 725         if (srvsvc_NetSrvInfo101_Type == NULL)
 726                 return;
 727
 728         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
 729         if (ClientConnection_Type == NULL)
 730                 return;
 731
 732         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
 733         if (ndr_syntax_id_Type == NULL)
 734                 return;
 735
 736         BrowserrSrvInfo100Ctr_Type.tp_base = BaseObject_Type;
 737         BrowserrSrvInfo100Ctr_Type.tp_basicsize = pytalloc_BaseObject_size();
 738
 739         BrowserrSrvInfo101Ctr_Type.tp_base = BaseObject_Type;
 740         BrowserrSrvInfo101Ctr_Type.tp_basicsize = pytalloc_BaseObject_size();
 741
 742         BrowserrSrvInfo_Type.tp_base = BaseObject_Type;
 743         BrowserrSrvInfo_Type.tp_basicsize = pytalloc_BaseObject_size();
 744
 745         browser_InterfaceType.tp_base = ClientConnection_Type;
 746
 747         browser_SyntaxType.tp_base = ndr_syntax_id_Type;
 748         browser_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
 749
 750         if (PyType_Ready(&BrowserrSrvInfo100Ctr_Type) < 0)
 751                 return;
 752         if (PyType_Ready(&BrowserrSrvInfo101Ctr_Type) < 0)
 753                 return;
 754         if (PyType_Ready(&BrowserrSrvInfo_Type) < 0)
 755                 return;
 756         if (PyType_Ready(&browser_InterfaceType) < 0)
 757                 return;
 758         if (PyType_Ready(&browser_SyntaxType) < 0)
 759                 return;
 760         if (!PyInterface_AddNdrRpcMethods(&browser_InterfaceType, py_ndr_browser_methods))
 761                 return;
 762
 763 #ifdef PY_BROWSERRSRVINFO100CTR_PATCH
 764         PY_BROWSERRSRVINFO100CTR_PATCH(&BrowserrSrvInfo100Ctr_Type);
 765 #endif
 766 #ifdef PY_BROWSERRSRVINFO101CTR_PATCH
 767         PY_BROWSERRSRVINFO101CTR_PATCH(&BrowserrSrvInfo101Ctr_Type);
 768 #endif
 769 #ifdef PY_BROWSERRSRVINFO_PATCH
 770         PY_BROWSERRSRVINFO_PATCH(&BrowserrSrvInfo_Type);
 771 #endif
 772 #ifdef PY_BROWSER_PATCH
 773         PY_BROWSER_PATCH(&browser_InterfaceType);
 774 #endif
 775 #ifdef PY_ABSTRACT_SYNTAX_PATCH
 776         PY_ABSTRACT_SYNTAX_PATCH(&browser_SyntaxType);
 777 #endif
 778
 779         m = Py_InitModule3("browser", browser_methods, "browser DCE/RPC");
 780         if (m == NULL)
 781                 return;
 782
 783         Py_INCREF((PyObject *)(void *)&BrowserrSrvInfo100Ctr_Type);
 784         PyModule_AddObject(m, "BrowserrSrvInfo100Ctr", (PyObject *)(void *)&BrowserrSrvInfo100Ctr_Type);
 785         Py_INCREF((PyObject *)(void *)&BrowserrSrvInfo101Ctr_Type);
 786         PyModule_AddObject(m, "BrowserrSrvInfo101Ctr", (PyObject *)(void *)&BrowserrSrvInfo101Ctr_Type);
 787         Py_INCREF((PyObject *)(void *)&BrowserrSrvInfo_Type);
 788         PyModule_AddObject(m, "BrowserrSrvInfo", (PyObject *)(void *)&BrowserrSrvInfo_Type);
 789         Py_INCREF((PyObject *)(void *)&browser_InterfaceType);
 790         PyModule_AddObject(m, "browser", (PyObject *)(void *)&browser_InterfaceType);
 791         Py_INCREF((PyObject *)(void *)&browser_SyntaxType);
 792         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&browser_SyntaxType);
 793 #ifdef PY_MOD_BROWSER_PATCH
 794         PY_MOD_BROWSER_PATCH(m);
 795 #endif
 796
 797 }