pidl/lib/Parse/Pidl/Samba4/Python.pm

   1 ###################################################
   2 # Python function wrapper generator
   3 # Copyright jelmer@samba.org 2007-2008
   4 # released under the GNU GPL
   5
   6 package Parse::Pidl::Samba4::Python;
   7 use parent Parse::Pidl::Base;
   8
   9 use strict;
  10 use warnings;
  11 use Parse::Pidl qw(warning fatal error);
  12 use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias bitmap_type_fn enum_type_fn);
  13 use Parse::Pidl::Util qw(has_property ParseExpr unmake_str);
  14 use Parse::Pidl::NDR qw(ReturnTypeElement GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe is_charset_array);
  15 use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
  16 use Parse::Pidl::Samba4 qw(ArrayDynamicallyAllocated);
  17 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
  18
  19
  20 use vars qw($VERSION);
  21 $VERSION = '0.01';
  22
  23 sub new($) {
  24         my ($class) = @_;
  25         my $self = { res => "", res_hdr => "", tabs => "",
  26                                  constants => [], constants_uniq => {},
  27                                  module_methods => [],
  28                                  module_objects => [], module_objects_uniq => {},
  29                                  ready_types => [],
  30                                  module_imports => [], module_imports_uniq => {},
  31                                  type_imports => [], type_imports_uniq => {},
  32                                  patch_type_calls => [], prereadycode => [],
  33                                  postreadycode => []};
  34         bless($self, $class);
  35 }
  36
  37 sub PrettifyTypeName($$)
  38 {
  39         my ($name, $basename) = @_;
  40
  41         $basename =~ s/^.*\.([^.]+)$/$1/;
  42
  43         $name =~ s/^$basename\_//;
  44
  45
  46         return $name;
  47 }
  48
  49 sub Import
  50 {
  51         my $self = shift;
  52         my @imports = @_;
  53         foreach (@imports) {
  54                 $_ = unmake_str($_);
  55                 s/\.idl$//;
  56                 $self->pidl_hdr("#include \"librpc/gen_ndr/$_\.h\"");
  57                 $self->register_module_import("samba.dcerpc.$_");
  58         }
  59 }
  60
  61 sub Const($$)
  62 {
  63     my ($self, $const) = @_;
  64         $self->register_constant($const->{NAME}, $const->{DTYPE}, $const->{VALUE});
  65 }
  66
  67 sub register_constant($$$$)
  68 {
  69         my ($self, $name, $type, $value) = @_;
  70
  71         unless (defined $self->{constants_uniq}->{$name}) {
  72                 my $h = {"key" => $name, "val" => [$type, $value]};
  73                 push @{$self->{constants}}, $h;
  74                 $self->{constants_uniq}->{$name} = $h;
  75         }
  76 }
  77
  78 sub EnumAndBitmapConsts($$$)
  79 {
  80         my ($self, $name, $d) = @_;
  81
  82         return unless (defined($d->{ELEMENTS}));
  83
  84         foreach my $e (@{$d->{ELEMENTS}}) {
  85                 $e =~ /^([A-Za-z0-9_]+)/;
  86                 my $cname = $1;
  87
  88                 $self->register_constant($cname, $d, $cname);
  89         }
  90 }
  91
  92 sub FromUnionToPythonFunction($$$$)
  93 {
  94         my ($self, $mem_ctx, $type, $switch, $name) = @_;
  95
  96         $self->pidl("PyObject *ret;");
  97         $self->pidl("");
  98
  99         $self->pidl("switch ($switch) {");
 100         $self->indent;
 101
 102         foreach my $e (@{$type->{ELEMENTS}}) {
 103                 $self->pidl("$e->{CASE}:");
 104
 105                 $self->indent;
 106
 107                 if ($e->{NAME}) {
 108                         $self->ConvertObjectToPython($mem_ctx, {}, $e, "$name->$e->{NAME}", "ret", "return NULL;");
 109                 } else {
 110                         $self->pidl("ret = Py_None;");
 111                         $self->pidl("Py_INCREF(ret);");
 112                 }
 113
 114                 $self->pidl("return ret;");
 115                 $self->pidl("");
 116
 117                 $self->deindent;
 118         }
 119
 120         $self->deindent;
 121         $self->pidl("}");
 122
 123         $self->pidl("PyErr_SetString(PyExc_TypeError, \"unknown union level\");");
 124         $self->pidl("return NULL;");
 125 }
 126
 127 sub FromPythonToUnionFunction($$$$$)
 128 {
 129         my ($self, $type, $typename, $switch, $mem_ctx, $name) = @_;
 130
 131         my $has_default = 0;
 132
 133         $self->pidl("$typename *ret = talloc_zero($mem_ctx, $typename);");
 134
 135         $self->pidl("switch ($switch) {");
 136         $self->indent;
 137
 138         foreach my $e (@{$type->{ELEMENTS}}) {
 139                 $self->pidl("$e->{CASE}:");
 140                 if ($e->{CASE} eq "default") { $has_default = 1; }
 141                 $self->indent;
 142                 if ($e->{NAME}) {
 143                         $self->ConvertObjectFromPython({}, $mem_ctx, $e, $name, "ret->$e->{NAME}", "talloc_free(ret); return NULL;");
 144                 }
 145                 $self->pidl("break;");
 146                 $self->deindent;
 147                 $self->pidl("");
 148         }
 149
 150         if (!$has_default) {
 151                 $self->pidl("default:");
 152                 $self->indent;
 153                 $self->pidl("PyErr_SetString(PyExc_TypeError, \"invalid union level value\");");
 154                 $self->pidl("talloc_free(ret);");
 155                 $self->pidl("ret = NULL;");
 156                 $self->deindent;
 157         }
 158
 159         $self->deindent;
 160         $self->pidl("}");
 161         $self->pidl("");
 162         $self->pidl("return ret;");
 163 }
 164
 165 sub PythonElementGetSet($$$$$$) {
 166         my ($self, $name, $cname, $ename, $e, $env) = @_;
 167
 168         my $varname = "object->$ename";
 169         $self->pidl("static PyObject *py_$name\_get_$e->{NAME}(PyObject *obj, void *closure)");
 170         $self->pidl("{");
 171         $self->indent;
 172         $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(obj);");
 173         $self->pidl("PyObject *py_$e->{NAME};");
 174         my $l = $e->{LEVELS}[0];
 175         if ($l->{TYPE} eq "POINTER") {
 176                 $self->pidl("if ($varname == NULL) {");
 177                 $self->indent;
 178                 $self->pidl("Py_RETURN_NONE;");
 179                 $self->deindent;
 180                 $self->pidl("}");
 181         }
 182         $self->ConvertObjectToPython("pytalloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
 183         $self->pidl("return py_$e->{NAME};");
 184         $self->deindent;
 185         $self->pidl("}");
 186         $self->pidl("");
 187
 188         $self->pidl("static int py_$name\_set_$e->{NAME}(PyObject *py_obj, PyObject *value, void *closure)");
 189         $self->pidl("{");
 190         $self->indent;
 191         $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
 192         my $mem_ctx = "pytalloc_get_mem_ctx(py_obj)";
 193         my $nl = GetNextLevel($e, $l);
 194         if ($l->{TYPE} eq "POINTER" and
 195                 not ($nl->{TYPE} eq "ARRAY" and ($nl->{IS_FIXED} or is_charset_array($e, $nl))) and
 196                 not ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE}))) {
 197                 $self->pidl("talloc_unlink($mem_ctx, discard_const($varname));");
 198         }
 199         $self->ConvertObjectFromPython($env, $mem_ctx, $e, "value", $varname, "return -1;");
 200         $self->pidl("return 0;");
 201         $self->deindent;
 202         $self->pidl("}");
 203         $self->pidl("");
 204 }
 205
 206 sub PythonStruct($$$$$$)
 207 {
 208         my ($self, $modulename, $prettyname, $name, $cname, $d) = @_;
 209
 210         my $env = GenerateStructEnv($d, "object");
 211
 212         $self->pidl("");
 213
 214         my $getsetters = "NULL";
 215
 216         if ($#{$d->{ELEMENTS}} > -1) {
 217                 foreach my $e (@{$d->{ELEMENTS}}) {
 218                         $self->PythonElementGetSet($name, $cname, $e->{NAME}, $e, $env);
 219                 }
 220
 221                 $getsetters = "py_$name\_getsetters";
 222                 $self->pidl("static PyGetSetDef ".$getsetters."[] = {");
 223                 $self->indent;
 224                 foreach my $e (@{$d->{ELEMENTS}}) {
 225                         my $etype = "";
 226                         if (ref($e->{TYPE}) eq "HASH") {
 227                                 $etype = $e->{TYPE}->{NAME};
 228                         } else {
 229                                 $etype = $e->{TYPE};
 230                         }
 231                         $self->pidl("{");
 232                         $self->indent;
 233                         $self->pidl(".name = discard_const_p(char, \"$e->{NAME}\"),");
 234                         $self->pidl(".get = py_$name\_get_$e->{NAME},");
 235                         $self->pidl(".set = py_$name\_set_$e->{NAME},");
 236                         $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $etype\")");
 237                         $self->deindent;
 238                         $self->pidl("},");
 239                 }
 240                 $self->pidl("{ .name = NULL }");
 241                 $self->deindent;
 242                 $self->pidl("};");
 243                 $self->pidl("");
 244         }
 245
 246         $self->pidl("static PyObject *py_$name\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
 247         $self->pidl("{");
 248         $self->indent;
 249         $self->pidl("return pytalloc_new($cname, type);");
 250         $self->deindent;
 251         $self->pidl("}");
 252         $self->pidl("");
 253
 254         my $py_methods = "NULL";
 255
 256         # If the struct is not public there ndr_pull/ndr_push functions will
 257         # be static so not callable from here
 258         if (has_property($d, "public")) {
 259                 $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))");
 260                 $self->pidl("{");
 261                 $self->indent;
 262                 $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
 263                 $self->pidl("PyObject *ret = NULL;");
 264                 $self->pidl("DATA_BLOB blob;");
 265                 $self->pidl("enum ndr_err_code err;");
 266                 $self->pidl("TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));");
 267                 $self->pidl("if (tmp_ctx == NULL) {");
 268                 $self->indent;
 269                 $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
 270                 $self->pidl("return NULL;");
 271                 $self->deindent;
 272                 $self->pidl("}");
 273                 $self->pidl("err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_$name);");
 274                 $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
 275                 $self->indent;
 276                 $self->pidl("TALLOC_FREE(tmp_ctx);");
 277                 $self->pidl("PyErr_SetNdrError(err);");
 278                 $self->pidl("return NULL;");
 279                 $self->deindent;
 280                 $self->pidl("}");
 281                 $self->pidl("");
 282                 $self->pidl("ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);");
 283                 $self->pidl("TALLOC_FREE(tmp_ctx);");
 284                 $self->pidl("return ret;");
 285                 $self->deindent;
 286                 $self->pidl("}");
 287                 $self->pidl("");
 288
 289                 $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
 290                 $self->pidl("{");
 291                 $self->indent;
 292                 $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
 293                 $self->pidl("DATA_BLOB blob = {.data = NULL, .length = 0};");
 294                 $self->pidl("Py_ssize_t blob_length = 0;");
 295                 $self->pidl("enum ndr_err_code err;");
 296                 $self->pidl("const char * const kwnames[] = { \"data_blob\", \"allow_remaining\", NULL };");
 297                 $self->pidl("PyObject *allow_remaining_obj = NULL;");
 298                 $self->pidl("bool allow_remaining = false;");
 299                 $self->pidl("");
 300                 $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|O:__ndr_unpack__\",");
 301                 $self->indent;
 302                 $self->pidl("discard_const_p(char *, kwnames),");
 303                 $self->pidl("&blob.data, &blob_length,");
 304                 $self->pidl("&allow_remaining_obj)) {");
 305                 $self->deindent;
 306                 $self->indent;
 307                 $self->pidl("return NULL;");
 308                 $self->deindent;
 309                 $self->pidl("}");
 310                 $self->pidl("blob.length = blob_length;");
 311                 $self->pidl("");
 312                 $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
 313                 $self->indent;
 314                 $self->pidl("allow_remaining = true;");
 315                 $self->deindent;
 316                 $self->pidl("}");
 317                 $self->pidl("");
 318                 $self->pidl("if (allow_remaining) {");
 319                 $self->indent;
 320                 $self->pidl("err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
 321                 $self->deindent;
 322                 $self->pidl("} else {");
 323                 $self->indent;
 324                 $self->pidl("err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
 325                 $self->deindent;
 326                 $self->pidl("}");
 327                 $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
 328                 $self->indent;
 329                 $self->pidl("PyErr_SetNdrError(err);");
 330                 $self->pidl("return NULL;");
 331                 $self->deindent;
 332                 $self->pidl("}");
 333                 $self->pidl("");
 334                 $self->pidl("Py_RETURN_NONE;");
 335                 $self->deindent;
 336                 $self->pidl("}");
 337                 $self->pidl("");
 338
 339                 $self->pidl("static PyObject *py_$name\_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
 340                 $self->pidl("{");
 341                 $self->indent;
 342                 $self->pidl("$cname *object = ($cname *)pytalloc_get_ptr(py_obj);");
 343                 $self->pidl("PyObject *ret;");
 344                 $self->pidl("char *retstr;");
 345                 $self->pidl("");
 346                 $self->pidl("retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_$name, \"$name\", object);");
 347                 $self->pidl("ret = PyUnicode_FromString(retstr);");
 348                 $self->pidl("talloc_free(retstr);");
 349                 $self->pidl("");
 350                 $self->pidl("return ret;");
 351                 $self->deindent;
 352                 $self->pidl("}");
 353                 $self->pidl("");
 354
 355                 $py_methods = "py_$name\_methods";
 356                 $self->pidl("static PyMethodDef $py_methods\[] = {");
 357                 $self->indent;
 358                 $self->pidl("{ \"__ndr_pack__\", (PyCFunction)py_$name\_ndr_pack, METH_NOARGS, \"S.ndr_pack(object) -> blob\\nNDR pack\" },");
 359                 $self->pidl("{ \"__ndr_unpack__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack), METH_VARARGS|METH_KEYWORDS, \"S.ndr_unpack(class, blob, allow_remaining=False) -> None\\nNDR unpack\" },");
 360                 $self->pidl("{ \"__ndr_print__\", (PyCFunction)py_$name\_ndr_print, METH_NOARGS, \"S.ndr_print(object) -> None\\nNDR print\" },");
 361                 $self->pidl("{ NULL, NULL, 0, NULL }");
 362                 $self->deindent;
 363                 $self->pidl("};");
 364                 $self->pidl("");
 365         }
 366
 367         $self->pidl_hdr("static PyTypeObject $name\_Type;");
 368         $self->pidl("");
 369         my $docstring = $self->DocString($d, $name);
 370         my $typeobject = "$name\_Type";
 371         $self->pidl("static PyTypeObject $typeobject = {");
 372         $self->indent;
 373         $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
 374         $self->pidl(".tp_name = \"$modulename.$prettyname\",");
 375         $self->pidl(".tp_getset = $getsetters,");
 376         if ($docstring) {
 377                 $self->pidl(".tp_doc = $docstring,");
 378         }
 379         $self->pidl(".tp_methods = $py_methods,");
 380         $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
 381         $self->pidl(".tp_new = py_$name\_new,");
 382         $self->deindent;
 383         $self->pidl("};");
 384
 385         $self->pidl("");
 386
 387         my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
 388         $self->register_module_prereadycode(["$name\_Type.tp_base = $talloc_typename;",
 389                                              "$name\_Type.tp_basicsize = pytalloc_BaseObject_size();",
 390                                              ""]);
 391
 392         return "&$typeobject";
 393 }
 394
 395 sub PythonFunctionStruct($$$$)
 396 {
 397         my ($self, $modulename, $fn, $iface, $prettyname) = @_;
 398
 399         my $inenv = GenerateFunctionInEnv($fn, "object->");
 400         my $outenv = GenerateFunctionOutEnv($fn, "object->");
 401
 402         my $name = "$fn->{NAME}";
 403         my $cname = "struct $name";
 404
 405         $self->pidl("");
 406
 407         my $getsetters = "NULL";
 408
 409         foreach my $e (@{$fn->{ELEMENTS}}) {
 410                 if (grep(/in/,@{$e->{DIRECTION}})) {
 411                         my $inname = "$name\_in";
 412                         my $ename = "in.$e->{NAME}";
 413                         $self->PythonElementGetSet($inname, $cname, $ename, $e, $inenv);
 414                 }
 415                 if (grep(/out/,@{$e->{DIRECTION}})) {
 416                         my $outname = "$name\_out";
 417                         my $ename = "out.$e->{NAME}";
 418                         $self->PythonElementGetSet($outname, $cname, $ename, $e, $outenv);
 419                 }
 420         }
 421
 422         if (defined($fn->{RETURN_TYPE})) {
 423                 my $e = ReturnTypeElement($fn);
 424                 my $ename = "out.result";
 425                 $self->PythonElementGetSet($name, $cname, $ename, $e, $outenv);
 426         }
 427
 428         $getsetters = "py_$name\_getsetters";
 429         $self->pidl("static PyGetSetDef ".$getsetters."[] = {");
 430         $self->indent;
 431         foreach my $e (@{$fn->{ELEMENTS}}) {
 432                 if (grep(/in/,@{$e->{DIRECTION}})) {
 433                         $self->pidl("{");
 434                         $self->indent;
 435                         $self->pidl(".name = discard_const_p(char, \"in_$e->{NAME}\"),");
 436                         $self->pidl(".get = py_$name\_in_get_$e->{NAME},");
 437                         $self->pidl(".set = py_$name\_in_set_$e->{NAME},");
 438                         $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $e->{TYPE}\")");
 439                         $self->deindent;
 440                         $self->pidl("},");
 441                 }
 442                 if (grep(/out/,@{$e->{DIRECTION}})) {
 443                         $self->pidl("{");
 444                         $self->indent;
 445                         $self->pidl(".name = discard_const_p(char, \"out_$e->{NAME}\"),");
 446                         $self->pidl(".get = py_$name\_out_get_$e->{NAME},");
 447                         $self->pidl(".set = py_$name\_out_set_$e->{NAME},");
 448                         $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of base type $e->{TYPE}\")");
 449                         $self->deindent;
 450                         $self->pidl("},");
 451                 }
 452         }
 453         if (defined($fn->{RETURN_TYPE})) {
 454                 $self->pidl("{");
 455                 $self->indent;
 456                 $self->pidl(".name = discard_const_p(char, \"result\"),");
 457                 $self->pidl(".get = py_$name\_get_result,");
 458                 $self->pidl(".set = py_$name\_set_result,");
 459                 $self->pidl(".doc = discard_const_p(char, \"PIDL-generated element of type $fn->{RETURN_TYPE}\")");
 460                 $self->deindent;
 461                 $self->pidl("},");
 462         }
 463         $self->pidl("{ .name = NULL }");
 464         $self->deindent;
 465         $self->pidl("};");
 466         $self->pidl("");
 467
 468         $self->pidl("static PyObject *py_$name\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
 469         $self->pidl("{");
 470         $self->indent;
 471
 472         # This creates a new, zeroed C structure and python object.
 473         # Thse may not be valid or sensible values, but this is as
 474         # well as we can do.
 475
 476         $self->pidl("PyObject *self = pytalloc_new($cname, type);");
 477
 478         # If there are any children that are ref pointers, we need to
 479         # allocate something for them to point to just as the pull
 480         # routine will when parsing the stucture from NDR.
 481         #
 482         # We then make those pointers point to zeroed memory
 483         #
 484         # A ref pointer is a pointer in the C structure but a scalar
 485         # on the wire. It is for a remote function like:
 486         #
 487         # int foo(int *i)
 488         #
 489         # This may be called with the pointer by reference eg foo(&i)
 490         #
 491         # That is why this only goes as far as the next level; deeply
 492         # nested pointer chains will end in a NULL.
 493
 494         my @ref_elements;
 495         foreach my $e (@{$fn->{ELEMENTS}}) {
 496                 if (has_property($e, "ref") && ! has_property($e, "charset")) {
 497                         if (!has_property($e, 'in') && !has_property($e, 'out')) {
 498                                 die "ref pointer that is not in or out";
 499                         }
 500                         push @ref_elements, $e;
 501                 }
 502         }
 503         if (@ref_elements) {
 504                 $self->pidl("$cname *_self = ($cname *)pytalloc_get_ptr(self);");
 505                 $self->pidl("TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);");
 506                 foreach my $e (@ref_elements) {
 507                         my $ename = $e->{NAME};
 508                         my $t = mapTypeName($e->{TYPE});
 509                         my $p = $e->{ORIGINAL}->{POINTERS} // 1;
 510                         if ($p > 1) {
 511                                 $self->pidl("/* a pointer to a NULL pointer */");
 512                                 $t .= ' ' . '*' x ($p - 1);
 513                         }
 514
 515                         # We checked in the loop above that each ref
 516                         # pointer is in or out (or both)
 517                         if (has_property($e, 'in')) {
 518                                 $self->pidl("_self->in.$ename = talloc_zero(mem_ctx, $t);");
 519                         }
 520
 521                         if (has_property($e, 'out')) {
 522                                 $self->pidl("_self->out.$ename = talloc_zero(mem_ctx, $t);");
 523                         }
 524                 }
 525         }
 526         $self->pidl("return self;");
 527         $self->deindent;
 528         $self->pidl("}");
 529         $self->pidl("");
 530
 531         my $py_methods = "NULL";
 532
 533         my $ndr_call = "const struct ndr_interface_call *call = NULL;";
 534         my $object_ptr = "$cname *object = ($cname *)pytalloc_get_ptr(py_obj);";
 535
 536         $self->pidl("static PyObject *py_$name\_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))");
 537         $self->pidl("{");
 538         $self->indent;
 539         $self->pidl("");
 540         $self->pidl("");
 541         $self->pidl("return PyLong_FromLong($fn->{OPNUM});");
 542         $self->deindent;
 543         $self->pidl("}");
 544         $self->pidl("");
 545
 546         $self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)");
 547         $self->pidl("{");
 548         $self->indent;
 549         $self->pidl("$ndr_call");
 550         $self->pidl("$object_ptr");
 551         $self->pidl("PyObject *ret = NULL;");
 552         $self->pidl("struct ndr_push *push = NULL;");
 553         $self->pidl("DATA_BLOB blob;");
 554         $self->pidl("enum ndr_err_code err;");
 555         $self->pidl("");
 556         $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
 557                     ") {");
 558         $self->indent;
 559         $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_pack\");");
 560         $self->pidl("return NULL;");
 561         $self->deindent;
 562         $self->pidl("}");
 563         $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
 564         $self->pidl("");
 565         $self->pidl("push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));");
 566         $self->pidl("if (push == NULL) {");
 567         $self->indent;
 568         $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
 569         $self->pidl("return NULL;");
 570         $self->deindent;
 571         $self->pidl("}");
 572         $self->pidl("");
 573         $self->pidl("push->flags |= ndr_push_flags;");
 574         $self->pidl("");
 575         $self->pidl("err = call->ndr_push(push, ndr_inout_flags, object);");
 576         $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
 577         $self->indent;
 578         $self->pidl("TALLOC_FREE(push);");
 579         $self->pidl("PyErr_SetNdrError(err);");
 580         $self->pidl("return NULL;");
 581         $self->deindent;
 582         $self->pidl("}");
 583         $self->pidl("blob = ndr_push_blob(push);");
 584         $self->pidl("ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);");
 585         $self->pidl("TALLOC_FREE(push);");
 586         $self->pidl("return ret;");
 587         $self->deindent;
 588         $self->pidl("}");
 589         $self->pidl("");
 590
 591         $self->pidl("static PyObject *py_$name\_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
 592         $self->pidl("{");
 593         $self->indent;
 594         $self->pidl("const char * const kwnames[] = { \"bigendian\", \"ndr64\", NULL };");
 595         $self->pidl("PyObject *bigendian_obj = NULL;");
 596         $self->pidl("PyObject *ndr64_obj = NULL;");
 597         $self->pidl("uint32_t ndr_push_flags = 0;");
 598         $self->pidl("");
 599         $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"|OO:__ndr_pack_in__\",");
 600         $self->indent;
 601         $self->pidl("discard_const_p(char *, kwnames),");
 602         $self->pidl("&bigendian_obj,");
 603         $self->pidl("&ndr64_obj)) {");
 604         $self->deindent;
 605         $self->indent;
 606         $self->pidl("return NULL;");
 607         $self->deindent;
 608         $self->pidl("}");
 609         $self->pidl("");
 610         $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
 611         $self->indent;
 612         $self->pidl("ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;");
 613         $self->deindent;
 614         $self->pidl("}");
 615         $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
 616         $self->indent;
 617         $self->pidl("ndr_push_flags |= LIBNDR_FLAG_NDR64;");
 618         $self->deindent;
 619         $self->pidl("}");
 620         $self->pidl("");
 621         $self->pidl("return py_$name\_ndr_pack(py_obj, NDR_IN, ndr_push_flags);");
 622         $self->deindent;
 623         $self->pidl("}");
 624         $self->pidl("");
 625
 626         $self->pidl("static PyObject *py_$name\_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
 627         $self->pidl("{");
 628         $self->indent;
 629         $self->pidl("const char * const kwnames[] = { \"bigendian\", \"ndr64\", NULL };");
 630         $self->pidl("PyObject *bigendian_obj = NULL;");
 631         $self->pidl("PyObject *ndr64_obj = NULL;");
 632         $self->pidl("uint32_t ndr_push_flags = 0;");
 633         $self->pidl("");
 634         $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"|OO:__ndr_pack_out__\",");
 635         $self->indent;
 636         $self->pidl("discard_const_p(char *, kwnames),");
 637         $self->pidl("&bigendian_obj,");
 638         $self->pidl("&ndr64_obj)) {");
 639         $self->deindent;
 640         $self->indent;
 641         $self->pidl("return NULL;");
 642         $self->deindent;
 643         $self->pidl("}");
 644         $self->pidl("");
 645         $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
 646         $self->indent;
 647         $self->pidl("ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;");
 648         $self->deindent;
 649         $self->pidl("}");
 650         $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
 651         $self->indent;
 652         $self->pidl("ndr_push_flags |= LIBNDR_FLAG_NDR64;");
 653         $self->deindent;
 654         $self->pidl("}");
 655         $self->pidl("");
 656         $self->pidl("return py_$name\_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);");
 657         $self->deindent;
 658         $self->pidl("}");
 659         $self->pidl("");
 660
 661         $self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)");
 662         $self->pidl("{");
 663         $self->indent;
 664         $self->pidl("$ndr_call");
 665         $self->pidl("$object_ptr");
 666         $self->pidl("struct ndr_pull *pull = NULL;");
 667         $self->pidl("enum ndr_err_code err;");
 668         $self->pidl("");
 669         $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
 670                     ") {");
 671         $self->indent;
 672         $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_unpack\");");
 673         $self->pidl("return NULL;");
 674         $self->deindent;
 675         $self->pidl("}");
 676         $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
 677         $self->pidl("");
 678         $self->pidl("pull = ndr_pull_init_blob(blob, object);");
 679         $self->pidl("if (pull == NULL) {");
 680         $self->indent;
 681         $self->pidl("PyErr_SetNdrError(NDR_ERR_ALLOC);");
 682         $self->pidl("return NULL;");
 683         $self->deindent;
 684         $self->pidl("}");
 685         $self->pidl("");
 686         $self->pidl("pull->flags |= ndr_pull_flags;");
 687         $self->pidl("");
 688         $self->pidl("err = call->ndr_pull(pull, ndr_inout_flags, object);");
 689         $self->pidl("if (!NDR_ERR_CODE_IS_SUCCESS(err)) {");
 690         $self->indent;
 691         $self->pidl("TALLOC_FREE(pull);");
 692         $self->pidl("PyErr_SetNdrError(err);");
 693         $self->pidl("return NULL;");
 694         $self->deindent;
 695         $self->pidl("}");
 696         $self->pidl("if (!allow_remaining) {");
 697         $self->indent;
 698         $self->pidl("uint32_t highest_ofs;");
 699         $self->pidl("");
 700         $self->pidl("if (pull->offset > pull->relative_highest_offset) {");
 701         $self->indent;
 702         $self->pidl("highest_ofs = pull->offset;");
 703         $self->deindent;
 704         $self->pidl("} else {");
 705         $self->indent;
 706         $self->pidl("highest_ofs = pull->relative_highest_offset;");
 707         $self->deindent;
 708         $self->pidl("}");
 709         $self->pidl("if (highest_ofs < pull->data_size) {");
 710         $self->indent;
 711         $self->pidl("err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,");
 712         $self->indent;
 713         $self->pidl("\"not all bytes consumed ofs[%u] size[%u]\",");
 714         $self->pidl("highest_ofs, pull->data_size);");
 715         $self->deindent;
 716         $self->pidl("TALLOC_FREE(pull);");
 717         $self->pidl("PyErr_SetNdrError(err);");
 718         $self->pidl("return NULL;");
 719         $self->deindent;
 720         $self->pidl("}");
 721         $self->deindent;
 722         $self->pidl("}");
 723         $self->pidl("");
 724         $self->pidl("TALLOC_FREE(pull);");
 725         $self->pidl("Py_RETURN_NONE;");
 726         $self->deindent;
 727         $self->pidl("}");
 728         $self->pidl("");
 729
 730         $self->pidl("static PyObject *py_$name\_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
 731         $self->pidl("{");
 732         $self->indent;
 733         $self->pidl("DATA_BLOB blob;");
 734         $self->pidl("Py_ssize_t blob_length = 0;");
 735         $self->pidl("const char * const kwnames[] = { \"data_blob\", \"bigendian\", \"ndr64\", \"allow_remaining\", NULL };");
 736         $self->pidl("PyObject *bigendian_obj = NULL;");
 737         $self->pidl("PyObject *ndr64_obj = NULL;");
 738         $self->pidl("uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;");
 739         $self->pidl("PyObject *allow_remaining_obj = NULL;");
 740         $self->pidl("bool allow_remaining = false;");
 741         $self->pidl("");
 742         $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|OOO:__ndr_unpack_in__\",");
 743         $self->indent;
 744         $self->pidl("discard_const_p(char *, kwnames),");
 745         $self->pidl("&blob.data, &blob_length,");
 746         $self->pidl("&bigendian_obj,");
 747         $self->pidl("&ndr64_obj,");
 748         $self->pidl("&allow_remaining_obj)) {");
 749         $self->deindent;
 750         $self->indent;
 751         $self->pidl("return NULL;");
 752         $self->deindent;
 753         $self->pidl("}");
 754         $self->pidl("blob.length = blob_length;");
 755         $self->pidl("");
 756         $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
 757         $self->indent;
 758         $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;");
 759         $self->deindent;
 760         $self->pidl("}");
 761         $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
 762         $self->indent;
 763         $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_NDR64;");
 764         $self->deindent;
 765         $self->pidl("}");
 766         $self->pidl("");
 767         $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
 768         $self->indent;
 769         $self->pidl("allow_remaining = true;");
 770         $self->deindent;
 771         $self->pidl("}");
 772         $self->pidl("");
 773         $self->pidl("return py_$name\_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);");
 774         $self->deindent;
 775         $self->pidl("}");
 776         $self->pidl("");
 777
 778         $self->pidl("static PyObject *py_$name\_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)");
 779         $self->pidl("{");
 780         $self->indent;
 781         $self->pidl("DATA_BLOB blob;");
 782         $self->pidl("Py_ssize_t blob_length = 0;");
 783         $self->pidl("const char * const kwnames[] = { \"data_blob\", \"bigendian\", \"ndr64\", \"allow_remaining\", NULL };");
 784         $self->pidl("PyObject *bigendian_obj = NULL;");
 785         $self->pidl("PyObject *ndr64_obj = NULL;");
 786         $self->pidl("uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;");
 787         $self->pidl("PyObject *allow_remaining_obj = NULL;");
 788         $self->pidl("bool allow_remaining = false;");
 789         $self->pidl("");
 790         $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN \"|OOO:__ndr_unpack_out__\",");
 791         $self->indent;
 792         $self->pidl("discard_const_p(char *, kwnames),");
 793         $self->pidl("&blob.data, &blob_length,");
 794         $self->pidl("&bigendian_obj,");
 795         $self->pidl("&ndr64_obj,");
 796         $self->pidl("&allow_remaining_obj)) {");
 797         $self->deindent;
 798         $self->indent;
 799         $self->pidl("return NULL;");
 800         $self->deindent;
 801         $self->pidl("}");
 802         $self->pidl("blob.length = blob_length;");
 803         $self->pidl("");
 804         $self->pidl("if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {");
 805         $self->indent;
 806         $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;");
 807         $self->deindent;
 808         $self->pidl("}");
 809         $self->pidl("if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {");
 810         $self->indent;
 811         $self->pidl("ndr_pull_flags |= LIBNDR_FLAG_NDR64;");
 812         $self->deindent;
 813         $self->pidl("}");
 814         $self->pidl("");
 815         $self->pidl("if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {");
 816         $self->indent;
 817         $self->pidl("allow_remaining = true;");
 818         $self->deindent;
 819         $self->pidl("}");
 820         $self->pidl("");
 821         $self->pidl("return py_$name\_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);");
 822         $self->deindent;
 823         $self->pidl("}");
 824         $self->pidl("");
 825
 826         $self->pidl("static PyObject *py_$name\_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)");
 827         $self->pidl("{");
 828         $self->indent;
 829         $self->pidl("$ndr_call");
 830         $self->pidl("$object_ptr");
 831         $self->pidl("PyObject *ret;");
 832         $self->pidl("char *retstr;");
 833         $self->pidl("");
 834         $self->pidl("if (ndr_table_$iface\.num_calls < " . ($fn->{OPNUM}+1) .
 835                     ") {");
 836         $self->indent;
 837         $self->pidl("PyErr_SetString(PyExc_TypeError, \"Internal Error, ndr_interface_call missing for py_$name\_ndr_print\");");
 838         $self->pidl("return NULL;");
 839         $self->deindent;
 840         $self->pidl("}");
 841         $self->pidl("call = &ndr_table_$iface\.calls[$fn->{OPNUM}];");
 842         $self->pidl("");
 843         $self->pidl("retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);");
 844         $self->pidl("ret = PyUnicode_FromString(retstr);");
 845         $self->pidl("TALLOC_FREE(retstr);");
 846         $self->pidl("");
 847         $self->pidl("return ret;");
 848         $self->deindent;
 849         $self->pidl("}");
 850         $self->pidl("");
 851
 852         $self->pidl("static PyObject *py_$name\_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
 853         $self->pidl("{");
 854         $self->indent;
 855         $self->pidl("return py_$name\_ndr_print(py_obj, \"$name\_in\", NDR_IN);");
 856         $self->deindent;
 857         $self->pidl("}");
 858         $self->pidl("");
 859
 860         $self->pidl("static PyObject *py_$name\_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))");
 861         $self->pidl("{");
 862         $self->indent;
 863         $self->pidl("return py_$name\_ndr_print(py_obj, \"$name\_out\", NDR_OUT);");
 864         $self->deindent;
 865         $self->pidl("}");
 866         $self->pidl("");
 867
 868         $py_methods = "py_$name\_methods";
 869         $self->pidl("static PyMethodDef $py_methods\[] = {");
 870         $self->indent;
 871         $self->pidl("{ \"opnum\", (PyCFunction)py_$name\_ndr_opnum, METH_NOARGS|METH_CLASS,");
 872         $self->indent;
 873         $self->pidl("\"$modulename.$prettyname.opnum() -> ".sprintf("%d (0x%02x)", $fn->{OPNUM}, $fn->{OPNUM})." \" },");
 874         $self->deindent;
 875         $self->pidl("{ \"__ndr_pack_in__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,");
 876         $self->indent;
 877         $self->pidl("\"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\\nNDR pack input\" },");
 878         $self->deindent;
 879         $self->pidl("{ \"__ndr_pack_out__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,");
 880         $self->indent;
 881         $self->pidl("\"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\\nNDR pack output\" },");
 882         $self->deindent;
 883         $self->pidl("{ \"__ndr_unpack_in__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,");
 884         $self->indent;
 885         $self->pidl("\"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\\nNDR unpack input\" },");
 886         $self->deindent;
 887         $self->pidl("{ \"__ndr_unpack_out__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$name\_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,");
 888         $self->indent;
 889         $self->pidl("\"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\\nNDR unpack output\" },");
 890         $self->deindent;
 891         $self->pidl("{ \"__ndr_print_in__\", (PyCFunction)py_$name\_ndr_print_in, METH_NOARGS, \"S.ndr_print_in(object) -> None\\nNDR print input\" },");
 892         $self->pidl("{ \"__ndr_print_out__\", (PyCFunction)py_$name\_ndr_print_out, METH_NOARGS, \"S.ndr_print_out(object) -> None\\nNDR print output\" },");
 893         $self->pidl("{ NULL, NULL, 0, NULL }");
 894         $self->deindent;
 895         $self->pidl("};");
 896         $self->pidl("");
 897
 898         $self->pidl_hdr("static PyTypeObject $name\_Type;");
 899         $self->pidl("");
 900         my $docstring = $self->DocString($fn, $name);
 901         my $typeobject = "$name\_Type";
 902         $self->pidl("static PyTypeObject $typeobject = {");
 903         $self->indent;
 904         $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
 905         $self->pidl(".tp_name = \"$modulename.$prettyname\",");
 906         $self->pidl(".tp_getset = $getsetters,");
 907         if ($docstring) {
 908                 $self->pidl(".tp_doc = $docstring,");
 909         }
 910         $self->pidl(".tp_methods = $py_methods,");
 911         $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
 912         $self->pidl(".tp_new = py_$name\_new,");
 913         $self->deindent;
 914         $self->pidl("};");
 915
 916         $self->pidl("");
 917
 918         my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
 919         $self->register_module_prereadycode(["$name\_Type.tp_base = $talloc_typename;",
 920                                              "$name\_Type.tp_basicsize = pytalloc_BaseObject_size();",
 921                                              ""]);
 922
 923         return "&$typeobject";
 924 }
 925
 926 sub get_metadata_var($)
 927 {
 928         my ($e) = @_;
 929         sub get_var($) { my $x = shift; $x =~ s/\*//g; return $x; }
 930
 931          if (has_property($e, "length_is")) {
 932                 return get_var($e->{PROPERTIES}->{length_is});
 933          } elsif (has_property($e, "size_is")) {
 934                 return get_var($e->{PROPERTIES}->{size_is});
 935          }
 936
 937          return undef;
 938 }
 939
 940 sub find_metadata_args($)
 941 {
 942         my ($fn) = @_;
 943         my $metadata_args = { in => {}, out => {} };
 944
 945         # Determine arguments that are metadata for other arguments (size_is/length_is)
 946         foreach my $e (@{$fn->{ELEMENTS}}) {
 947                 foreach my $dir (@{$e->{DIRECTION}}) {
 948                          my $main = get_metadata_var($e);
 949                          if ($main) {
 950                                  $metadata_args->{$dir}->{$main} = $e->{NAME};
 951                          }
 952                  }
 953         }
 954
 955         return $metadata_args;
 956 }
 957
 958 sub PythonFunctionUnpackOut($$$)
 959 {
 960         my ($self, $fn, $fnname) = @_;
 961
 962         my $outfnname = "unpack_$fnname\_args_out";
 963         my $signature = "";
 964
 965         my $metadata_args = find_metadata_args($fn);
 966
 967         my $env = GenerateFunctionOutEnv($fn, "r->");
 968         my $result_size = 0;
 969
 970         $self->pidl("static PyObject *$outfnname(struct $fn->{NAME} *r)");
 971         $self->pidl("{");
 972         $self->indent;
 973         $self->pidl("PyObject *result;");
 974         foreach my $e (@{$fn->{ELEMENTS}}) {
 975                 next unless (grep(/out/,@{$e->{DIRECTION}}));
 976                 next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or
 977                          ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}}));
 978                 $self->pidl("PyObject *py_$e->{NAME};");
 979                 $result_size++;
 980         }
 981
 982         if ($fn->{RETURN_TYPE}) {
 983                 $result_size++ unless ($fn->{RETURN_TYPE} eq "WERROR" or $fn->{RETURN_TYPE} eq "NTSTATUS");
 984         }
 985
 986         my $i = 0;
 987
 988         if ($result_size > 1) {
 989                 $self->pidl("result = PyTuple_New($result_size);");
 990                 $signature .= "(";
 991         } elsif ($result_size == 0) {
 992                 $self->pidl("result = Py_None;");
 993                 $self->pidl("Py_INCREF(result);");
 994                 $signature .= "None";
 995         }
 996
 997         foreach my $e (@{$fn->{ELEMENTS}}) {
 998                 next if ($metadata_args->{out}->{$e->{NAME}});
 999                 my $py_name = "py_$e->{NAME}";
1000                 if (grep(/out/,@{$e->{DIRECTION}})) {
1001                         $self->ConvertObjectToPython("r", $env, $e, "r->out.$e->{NAME}", $py_name, "return NULL;");
1002                         if ($result_size > 1) {
1003                                 $self->pidl("PyTuple_SetItem(result, $i, $py_name);");
1004                                 $i++;
1005                                 $signature .= "$e->{NAME}, ";
1006                         } else {
1007                                 $self->pidl("result = $py_name;");
1008                                 $signature .= $e->{NAME};
1009                         }
1010                 }
1011         }
1012
1013         if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
1014                 $self->handle_ntstatus("r->out.result", "NULL", undef);
1015         } elsif (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "WERROR") {
1016                 $self->handle_werror("r->out.result", "NULL", undef);
1017         } elsif (defined($fn->{RETURN_TYPE})) {
1018                 my $conv = $self->ConvertObjectToPythonData("r", $fn->{RETURN_TYPE}, "r->out.result", $fn);
1019                 if ($result_size > 1) {
1020                         $self->pidl("PyTuple_SetItem(result, $i, $conv);");
1021                 } else {
1022                         $self->pidl("result = $conv;");
1023                 }
1024                 $signature .= "result";
1025         }
1026
1027         if (substr($signature, -2) eq ", ") {
1028                 $signature = substr($signature, 0, -2);
1029         }
1030         if ($result_size > 1) {
1031                 $signature .= ")";
1032         }
1033
1034         $self->pidl("return result;");
1035         $self->deindent;
1036         $self->pidl("}");
1037         $self->pidl("");
1038
1039         return ($outfnname, $signature);
1040 }
1041
1042 sub PythonFunctionPackIn($$$)
1043 {
1044         my ($self, $fn, $fnname) = @_;
1045         my $metadata_args = find_metadata_args($fn);
1046
1047         my $infnname = "pack_$fnname\_args_in";
1048
1049         $self->pidl("static bool $infnname(PyObject *args, PyObject *kwargs, struct $fn->{NAME} *r)");
1050         $self->pidl("{");
1051         $self->indent;
1052         my $args_format = "";
1053         my $args_string = "";
1054         my $args_names = "";
1055         my $signature = "";
1056
1057         foreach my $e (@{$fn->{ELEMENTS}}) {
1058                 next unless (grep(/in/,@{$e->{DIRECTION}}));
1059                 next if (($metadata_args->{in}->{$e->{NAME}} and grep(/in/, @{$e->{DIRECTION}})) or
1060                                  ($metadata_args->{out}->{$e->{NAME}}) and grep(/out/, @{$e->{DIRECTION}}));
1061                 $self->pidl("PyObject *py_$e->{NAME};");
1062                 $args_format .= "O";
1063                 $args_string .= ", &py_$e->{NAME}";
1064                 $args_names .= "\"$e->{NAME}\", ";
1065                 $signature .= "$e->{NAME}, ";
1066         }
1067         if (substr($signature, -2) eq ", ") {
1068                 $signature = substr($signature, 0, -2);
1069         }
1070         $self->pidl("const char *kwnames[] = {");
1071         $self->indent;
1072         $self->pidl($args_names . "NULL");
1073         $self->deindent;
1074         $self->pidl("};");
1075
1076         $self->pidl("");
1077         $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"$args_format:$fn->{NAME}\", discard_const_p(char *, kwnames)$args_string)) {");
1078         $self->indent;
1079         $self->pidl("return false;");
1080         $self->deindent;
1081         $self->pidl("}");
1082         $self->pidl("");
1083
1084         my $env = GenerateFunctionInEnv($fn, "r->");
1085
1086         my $fail = "return false;";
1087         foreach my $e (@{$fn->{ELEMENTS}}) {
1088                 next unless (grep(/in/,@{$e->{DIRECTION}}));
1089                 if ($metadata_args->{in}->{$e->{NAME}}) {
1090                         my $py_var = "py_".$metadata_args->{in}->{$e->{NAME}};
1091                         $self->pidl("PY_CHECK_TYPE(&PyList_Type, $py_var, $fail);");
1092                         my $val = "PyList_GET_SIZE($py_var)";
1093                         if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
1094                                 $self->pidl("r->in.$e->{NAME} = talloc_ptrtype(r, r->in.$e->{NAME});");
1095                                 $self->pidl("if (r->in.$e->{NAME} == NULL) {");
1096                                 $self->indent;
1097                                 $self->pidl("PyErr_NoMemory();");
1098                                 $self->pidl($fail);
1099                                 $self->deindent;
1100                                 $self->pidl("}");
1101                                 $self->pidl("*r->in.$e->{NAME} = $val;");
1102                         } else {
1103                                 $self->pidl("r->in.$e->{NAME} = $val;");
1104                         }
1105                 } else {
1106                         $self->ConvertObjectFromPython($env, "r", $e, "py_$e->{NAME}", "r->in.$e->{NAME}", $fail);
1107                 }
1108         }
1109         $self->pidl("return true;");
1110         $self->deindent;
1111         $self->pidl("}");
1112         $self->pidl("");
1113         return ($infnname, $signature);
1114 }
1115
1116 sub PythonFunction($$$)
1117 {
1118         my ($self, $fn, $iface, $prettyname) = @_;
1119
1120         my $fnname = "py_$fn->{NAME}";
1121         my $docstring = $self->DocString($fn, $fn->{NAME});
1122
1123         my ($infn, $insignature) = $self->PythonFunctionPackIn($fn, $fnname);
1124         my ($outfn, $outsignature) = $self->PythonFunctionUnpackOut($fn, $fnname);
1125         my $signature = "S.$prettyname($insignature) -> $outsignature";
1126         if ($docstring) {
1127                 $docstring = "\"$signature\\n\\n\"$docstring";
1128         } else {
1129                 $docstring = "\"$signature\"";
1130         }
1131
1132         return ($infn, $outfn, $docstring);
1133 }
1134
1135 sub handle_werror($$$$)
1136 {
1137         my ($self, $var, $retval, $mem_ctx) = @_;
1138
1139         $self->pidl("if (!W_ERROR_IS_OK($var)) {");
1140         $self->indent;
1141         $self->pidl("PyErr_SetWERROR($var);");
1142         $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
1143         $self->pidl("return $retval;");
1144         $self->deindent;
1145         $self->pidl("}");
1146         $self->pidl("");
1147 }
1148
1149 sub handle_ntstatus($$$$)
1150 {
1151         my ($self, $var, $retval, $mem_ctx) = @_;
1152
1153         $self->pidl("if (NT_STATUS_IS_ERR($var)) {");
1154         $self->indent;
1155         $self->pidl("PyErr_SetNTSTATUS($var);");
1156         $self->pidl("talloc_free($mem_ctx);") if ($mem_ctx);
1157         $self->pidl("return $retval;");
1158         $self->deindent;
1159         $self->pidl("}");
1160         $self->pidl("");
1161 }
1162
1163 sub PythonType($$$$)
1164 {
1165         my ($self, $modulename, $d, $interface, $basename) = @_;
1166
1167         my $actual_ctype = $d;
1168         if ($actual_ctype->{TYPE} eq "TYPEDEF") {
1169                 $actual_ctype = $actual_ctype->{DATA};
1170         }
1171
1172         if ($actual_ctype->{TYPE} eq "STRUCT") {
1173                 my $typeobject;
1174                 my $fn_name = PrettifyTypeName($d->{NAME}, $basename);
1175
1176                 if ($d->{TYPE} eq "STRUCT") {
1177                         $typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d);
1178                 } else {
1179                         $typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d->{DATA});
1180                 }
1181
1182                 $self->register_module_typeobject($fn_name, $typeobject, $d->{ORIGINAL});
1183         }
1184
1185         if ($d->{TYPE} eq "ENUM" or $d->{TYPE} eq "BITMAP") {
1186                 $self->EnumAndBitmapConsts($d->{NAME}, $d);
1187         }
1188
1189         if ($d->{TYPE} eq "TYPEDEF" and ($d->{DATA}->{TYPE} eq "ENUM" or $d->{DATA}->{TYPE} eq "BITMAP")) {
1190                 $self->EnumAndBitmapConsts($d->{NAME}, $d->{DATA});
1191         }
1192
1193         if ($actual_ctype->{TYPE} eq "UNION" and defined($actual_ctype->{ELEMENTS})) {
1194                 my $prettyname = PrettifyTypeName($d->{NAME}, $basename);
1195                 my $typeobject = "$d->{NAME}\_Type";
1196                 my $docstring = $self->DocString($d, $d->{NAME});
1197                 my $cname = "union $d->{NAME}";
1198
1199                 $self->pidl("static PyObject *py_import_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, " .mapTypeName($d) . " *in)");
1200                 $self->pidl("{");
1201                 $self->indent;
1202                 $self->FromUnionToPythonFunction("mem_ctx", $actual_ctype, "level", "in") if ($actual_ctype->{TYPE} eq "UNION");
1203                 $self->deindent;
1204                 $self->pidl("}");
1205                 $self->pidl("");
1206
1207                 $self->pidl("static ".mapTypeName($d) . " *py_export_$d->{NAME}(TALLOC_CTX *mem_ctx, int level, PyObject *in)");
1208                 $self->pidl("{");
1209                 $self->indent;
1210                 $self->FromPythonToUnionFunction($actual_ctype, mapTypeName($d), "level", "mem_ctx", "in") if ($actual_ctype->{TYPE} eq "UNION");
1211                 $self->deindent;
1212                 $self->pidl("}");
1213                 $self->pidl("");
1214
1215                 my $getsetters = "NULL";
1216                 my $py_methods = "NULL";
1217                 my $typename = mapTypeName($d);
1218
1219                 $self->pidl("static PyObject *py_$d->{NAME}\_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
1220                 $self->pidl("{");
1221                 $self->indent;
1222                 $self->pidl("const char * const kwnames[] = { \"mem_ctx\", \"level\", \"in\", NULL };");
1223                 $self->pidl("PyObject *mem_ctx_obj = NULL;");
1224                 $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
1225                 $self->pidl("int level = 0;");
1226                 $self->pidl("PyObject *in_obj = NULL;");
1227                 $self->pidl("$typename *in = NULL;");
1228                 $self->pidl("");
1229                 $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"OiO:import\",");
1230                 $self->indent;
1231                 $self->pidl("discard_const_p(char *, kwnames),");
1232                 $self->pidl("&mem_ctx_obj,");
1233                 $self->pidl("&level,");
1234                 $self->pidl("&in_obj)) {");
1235                 $self->deindent;
1236                 $self->indent;
1237                 $self->pidl("return NULL;");
1238                 $self->deindent;
1239                 $self->pidl("}");
1240                 $self->pidl("mem_ctx = pytalloc_get_ptr(mem_ctx_obj);");
1241                 $self->pidl("if (mem_ctx == NULL) {");
1242                 $self->indent;
1243                 $self->pidl("PyErr_SetString(PyExc_TypeError, \"mem_ctx is NULL)!\");");
1244                 $self->pidl("return NULL;");
1245                 $self->deindent;
1246                 $self->pidl("}");
1247                 $self->pidl("in = ($typename *)pytalloc_get_ptr(in_obj);");
1248                 $self->pidl("if (in == NULL) {");
1249                 $self->indent;
1250                 $self->pidl("PyErr_Format(PyExc_TypeError, \"in needs to be a pointer to $typename!\");");
1251                 $self->pidl("return NULL;");
1252                 $self->deindent;
1253                 $self->pidl("}");
1254                 $self->pidl("");
1255                 $self->pidl("return py_import_$d->{NAME}(mem_ctx, level, in);");
1256                 $self->deindent;
1257                 $self->pidl("}");
1258                 $self->pidl("");
1259
1260                 $self->pidl("static PyObject *py_$d->{NAME}\_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
1261                 $self->pidl("{");
1262                 $self->indent;
1263                 $self->pidl("const char * const kwnames[] = { \"mem_ctx\", \"level\", \"in\", NULL };");
1264                 $self->pidl("PyObject *mem_ctx_obj = NULL;");
1265                 $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
1266                 $self->pidl("int level = 0;");
1267                 $self->pidl("PyObject *in = NULL;");
1268                 $self->pidl("$typename *out = NULL;");
1269                 $self->pidl("");
1270                 $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"OiO:export\",");
1271                 $self->indent;
1272                 $self->pidl("discard_const_p(char *, kwnames),");
1273                 $self->pidl("&mem_ctx_obj,");
1274                 $self->pidl("&level,");
1275                 $self->pidl("&in)) {");
1276                 $self->deindent;
1277                 $self->indent;
1278                 $self->pidl("return NULL;");
1279                 $self->deindent;
1280                 $self->pidl("}");
1281                 $self->pidl("mem_ctx = pytalloc_get_ptr(mem_ctx_obj);");
1282                 $self->pidl("if (mem_ctx == NULL) {");
1283                 $self->indent;
1284                 $self->pidl("PyErr_SetString(PyExc_TypeError, \"mem_ctx is NULL)!\");");
1285                 $self->pidl("return NULL;");
1286                 $self->deindent;
1287                 $self->pidl("}");
1288                 $self->pidl("");
1289                 $self->pidl("out = py_export_$d->{NAME}(mem_ctx, level, in);");
1290                 $self->pidl("if (out == NULL) {");
1291                 $self->indent;
1292                 $self->pidl("return NULL;");
1293                 $self->deindent;
1294                 $self->pidl("}");
1295                 $self->pidl("");
1296                 $self->pidl("return pytalloc_GenericObject_reference(out);");
1297                 $self->deindent;
1298                 $self->pidl("}");
1299                 $self->pidl("");
1300
1301                 $py_methods = "py_$d->{NAME}_methods";
1302                 $self->pidl("static PyMethodDef $py_methods\[] = {");
1303                 $self->indent;
1304                 $self->pidl("{ \"__import__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$d->{NAME}\_import),");
1305                 $self->indent;
1306                 $self->pidl("METH_VARARGS|METH_KEYWORDS|METH_CLASS,");
1307                 $self->pidl("\"T.__import__(mem_ctx, level, in) => ret.\" },");
1308                 $self->deindent;
1309                 $self->pidl("{ \"__export__\", PY_DISCARD_FUNC_SIG(PyCFunction,py_$d->{NAME}\_export),");
1310                 $self->indent;
1311                 $self->pidl("METH_VARARGS|METH_KEYWORDS|METH_CLASS,");
1312                 $self->pidl("\"T.__export__(mem_ctx, level, in) => ret.\" },");
1313                 $self->deindent;
1314                 $self->pidl("{ NULL, NULL, 0, NULL }");
1315                 $self->deindent;
1316                 $self->pidl("};");
1317                 $self->pidl("");
1318
1319                 $self->pidl("static PyObject *py_$d->{NAME}\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
1320                 $self->pidl("{");
1321                 $self->indent;
1322                 $self->pidl("PyErr_Format(PyExc_TypeError, \"New %s Objects are not supported\", type->tp_name);");
1323                 $self->pidl("return NULL;");
1324                 $self->deindent;
1325                 $self->pidl("}");
1326                 $self->pidl("");
1327
1328                 $self->pidl("");
1329                 $self->pidl_hdr("static PyTypeObject $typeobject;");
1330                 $self->pidl("static PyTypeObject $typeobject = {");
1331                 $self->indent;
1332                 $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
1333                 $self->pidl(".tp_name = \"$modulename.$prettyname\",");
1334                 $self->pidl(".tp_getset = $getsetters,");
1335                 if ($docstring) {
1336                         $self->pidl(".tp_doc = $docstring,");
1337                 }
1338                 $self->pidl(".tp_methods = $py_methods,");
1339                 $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
1340                 $self->pidl(".tp_new = py_$d->{NAME}\_new,");
1341                 $self->deindent;
1342                 $self->pidl("};");
1343
1344                 $self->pidl("");
1345
1346                 my $talloc_typename = $self->import_type_variable("talloc", "BaseObject");
1347                 $self->register_module_prereadycode(["$typeobject.tp_base = $talloc_typename;",
1348                                                      "$typeobject.tp_basicsize = pytalloc_BaseObject_size();",
1349                                                      ""]);
1350
1351                 $self->register_module_typeobject($prettyname, "&$typeobject", $d->{ORIGINAL});
1352         }
1353 }
1354
1355 sub DocString($$$)
1356 {
1357         my ($self, $d, $name) = @_;
1358         if (has_property($d, "helpstring")) {
1359                 my $docstring = uc("py_doc_$name");
1360                 $self->pidl("#define $docstring ".has_property($d, "helpstring"));
1361                 return $docstring;
1362         }
1363
1364         return undef;
1365 }
1366
1367 sub Interface($$$)
1368 {
1369         my($self,$interface,$basename) = @_;
1370
1371         if (has_property($interface, "pyhelper")) {
1372                 $self->pidl("#include \"".unmake_str($interface->{PROPERTIES}->{pyhelper})."\"\n");
1373         }
1374
1375         $self->Const($_) foreach (@{$interface->{CONSTS}});
1376
1377         foreach my $d (@{$interface->{TYPES}}) {
1378                 next if has_property($d, "nopython");
1379
1380                 $self->PythonType($basename, $d, $interface, $basename);
1381         }
1382
1383         if (defined $interface->{PROPERTIES}->{uuid}) {
1384                 $self->pidl_hdr("static PyTypeObject $interface->{NAME}_InterfaceType;");
1385                 $self->pidl("");
1386
1387                 my @fns = ();
1388
1389                 foreach my $d (@{$interface->{FUNCTIONS}}) {
1390                         next if has_property($d, "noopnum");
1391                         next if has_property($d, "nopython");
1392                         next if has_property($d, "todo");
1393
1394                         my $skip = 0;
1395                         foreach my $e (@{$d->{ELEMENTS}}) {
1396                                 if (ContainsPipe($e, $e->{LEVELS}[0])) {
1397                                         $skip = 1;
1398                                         last;
1399                                 }
1400                         }
1401                         next if $skip;
1402
1403                         my $prettyname = $d->{NAME};
1404
1405                         $prettyname =~ s/^$interface->{NAME}_//;
1406                         $prettyname =~ s/^$basename\_//;
1407
1408                         my $typeobject = $self->PythonFunctionStruct($basename, $d, $interface->{NAME}, $prettyname);
1409                         $self->register_module_typeobject($prettyname, $typeobject, $d->{ORIGINAL});
1410
1411                         my ($infn, $outfn, $fndocstring) = $self->PythonFunction($d, $interface->{NAME}, $prettyname);
1412
1413                         push (@fns, [$infn, $outfn, "dcerpc_$d->{NAME}_r", $prettyname, $fndocstring, $d->{OPNUM}]);
1414                 }
1415
1416                 $self->pidl("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[] = {");
1417                 $self->indent;
1418                 foreach my $d (@fns) {
1419                         my ($infn, $outfn, $callfn, $prettyname, $docstring, $opnum) = @$d;
1420                         $self->pidl("{ \"$prettyname\", $docstring, (py_dcerpc_call_fn)$callfn, (py_data_pack_fn)$infn, (py_data_unpack_fn)$outfn, $opnum, &ndr_table_$interface->{NAME} },");
1421                 }
1422                 $self->pidl("{0}");
1423                 $self->deindent;
1424                 $self->pidl("};");
1425                 $self->pidl("");
1426
1427                 $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
1428                 $self->pidl("{");
1429                 $self->indent;
1430                 $self->pidl("return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_$interface->{NAME});");
1431                 $self->deindent;
1432                 $self->pidl("}");
1433
1434                 $self->pidl("");
1435
1436                 my $signature =
1437 "\"$interface->{NAME}(binding, lp_ctx=None, credentials=None) -> connection\\n\"
1438 \"\\n\"
1439 \"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\\n\"
1440 \"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\\n\"
1441 \"credentials should be a credentials.Credentials object.\\n\\n\"";
1442
1443                 my $docstring = $self->DocString($interface, $interface->{NAME});
1444
1445                 if ($docstring) {
1446                         $docstring = "$signature$docstring";
1447                 } else {
1448                         $docstring = $signature;
1449                 }
1450
1451                 my $if_typename = "$interface->{NAME}_InterfaceType";
1452
1453                 $self->pidl("static PyTypeObject $if_typename = {");
1454                 $self->indent;
1455                 $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
1456                 $self->pidl(".tp_name = \"$basename.$interface->{NAME}\",");
1457                 $self->pidl(".tp_basicsize = sizeof(dcerpc_InterfaceObject),");
1458                 $self->pidl(".tp_doc = $docstring,");
1459                 $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
1460                 $self->pidl(".tp_new = interface_$interface->{NAME}_new,");
1461                 $self->deindent;
1462                 $self->pidl("};");
1463
1464                 $self->pidl("");
1465
1466                 $self->register_module_typeobject($interface->{NAME}, "&$if_typename", $interface->{ORIGINAL});
1467                 my $dcerpc_typename = $self->import_type_variable("samba.dcerpc.base", "ClientConnection");
1468                 $self->register_module_prereadycode(["$if_typename.tp_base = $dcerpc_typename;", ""]);
1469                 $self->register_module_postreadycode(["if (!PyInterface_AddNdrRpcMethods(&$if_typename, py_ndr_$interface->{NAME}\_methods))", "\treturn NULL;", ""]);
1470
1471
1472                 $self->pidl("static PyObject *syntax_$interface->{NAME}_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
1473                 $self->pidl("{");
1474                 $self->indent;
1475                 $self->pidl("return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_$interface->{NAME}.syntax_id);");
1476                 $self->deindent;
1477                 $self->pidl("}");
1478
1479                 $self->pidl("");
1480
1481                 $signature = "\"$interface->{NAME}_abstract_syntax()\\n\"";
1482
1483                 $docstring = $self->DocString($interface, $interface->{NAME}."_syntax");
1484
1485                 if ($docstring) {
1486                         $docstring = "$signature$docstring";
1487                 } else {
1488                         $docstring = $signature;
1489                 }
1490
1491                 my $syntax_typename = "$interface->{NAME}_SyntaxType";
1492
1493                 $self->pidl("static PyTypeObject $syntax_typename = {");
1494                 $self->indent;
1495                 $self->pidl("PyVarObject_HEAD_INIT(NULL, 0)");
1496                 $self->pidl(".tp_name = \"$basename.$interface->{NAME}_abstract_syntax\",");
1497                 $self->pidl(".tp_doc = $docstring,");
1498                 $self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
1499                 $self->pidl(".tp_new = syntax_$interface->{NAME}_new,");
1500                 $self->deindent;
1501                 $self->pidl("};");
1502
1503                 $self->pidl("");
1504
1505                 $self->register_module_typeobject("$interface->{NAME}_abstract_syntax", "&$syntax_typename", $interface->{ORIGINAL});
1506                 if (not defined($self->existing_module_object("abstract_syntax"))) {
1507                         # Only the first syntax gets registered with the legacy
1508                         # "abstract_syntax" name
1509                         $self->register_module_typeobject("abstract_syntax", "&$syntax_typename", $interface->{ORIGINAL});
1510                 }
1511                 my $ndr_typename = $self->import_type_variable("samba.dcerpc.misc", "ndr_syntax_id");
1512                 $self->register_module_prereadycode(["$syntax_typename.tp_base = $ndr_typename;",
1513                                                      "$syntax_typename.tp_basicsize = pytalloc_BaseObject_size();",
1514                                                      ""]);
1515         }
1516
1517         $self->pidl_hdr("");
1518 }
1519
1520 sub register_module_method($$$$$)
1521 {
1522         my ($self, $fn_name, $pyfn_name, $flags, $doc) = @_;
1523
1524         push (@{$self->{module_methods}}, [$fn_name, $pyfn_name, $flags, $doc])
1525 }
1526
1527 sub register_module_typeobject($$$$)
1528 {
1529         my ($self, $name, $py_name, $location) = @_;
1530
1531         $self->register_module_object($name, "(PyObject *)(void *)$py_name", $location);
1532
1533         $self->check_ready_type($py_name);
1534
1535         $self->register_patch_type_call($name, $py_name);
1536 }
1537
1538 sub check_ready_type($$)
1539 {
1540         my ($self, $py_name) = @_;
1541         push (@{$self->{ready_types}}, $py_name) unless (grep(/^$py_name$/,@{$self->{ready_types}}));
1542 }
1543
1544 sub register_module_import($$)
1545 {
1546         my ($self, $module_path) = @_;
1547
1548         my $var_name = $module_path;
1549         $var_name =~ s/\./_/g;
1550         $var_name = "dep_$var_name";
1551
1552         unless (defined $self->{module_imports_uniq}->{$var_name}) {
1553                 my $h = { "key" => $var_name, "val" => $module_path};
1554                 push @{$self->{module_imports}}, $h;
1555                 $self->{module_imports_uniq}->{$var_name} = $h;
1556         }
1557         return $var_name;
1558 }
1559
1560 sub import_type_variable($$$)
1561 {
1562         my ($self, $module, $name) = @_;
1563
1564         $self->register_module_import($module);
1565         unless (defined $self->{type_imports_uniq}->{$name}) {
1566                 my $h = { "key" => $name, "val" => $module};
1567                 push @{$self->{type_imports}}, $h;
1568                 $self->{type_imports_uniq}->{$name} = $h;
1569         }
1570         return "$name\_Type";
1571 }
1572
1573 sub use_type_variable($$)
1574 {
1575         my ($self, $orig_ctype) = @_;
1576         # FIXME: Have a global lookup table for types that look different on the
1577         # wire than they are named in C?
1578         if ($orig_ctype->{NAME} eq "dom_sid2" or
1579             $orig_ctype->{NAME} eq "dom_sid28" or
1580             $orig_ctype->{NAME} eq "dom_sid0") {
1581                 $orig_ctype->{NAME} = "dom_sid";
1582         }
1583         if ($orig_ctype->{NAME} eq "spoolss_security_descriptor") {
1584                 $orig_ctype->{NAME} = "security_descriptor";
1585         }
1586
1587         my $ctype = resolveType($orig_ctype);
1588         unless (defined($ctype->{BASEFILE})) {
1589                 return undef;
1590         }
1591         # If this is an external type, make sure we do the right imports.
1592         if (($ctype->{BASEFILE} ne $self->{BASENAME})) {
1593                 return $self->import_type_variable("samba.dcerpc.$ctype->{BASEFILE}", $ctype->{NAME});
1594         }
1595         return "&$ctype->{NAME}_Type";
1596 }
1597
1598 sub register_patch_type_call($$$)
1599 {
1600         my ($self, $typename, $cvar) = @_;
1601
1602         push(@{$self->{patch_type_calls}}, [$typename, $cvar]);
1603
1604 }
1605
1606 sub register_module_prereadycode($$)
1607 {
1608         my ($self, $code) = @_;
1609
1610         push (@{$self->{prereadycode}}, @$code);
1611 }
1612
1613 sub register_module_postreadycode($$)
1614 {
1615         my ($self, $code) = @_;
1616
1617         push (@{$self->{postreadycode}}, @$code);
1618 }
1619
1620 sub existing_module_object($$)
1621 {
1622         my ($self, $name) = @_;
1623
1624         if (defined($self->{module_object_uniq}->{$name})) {
1625                 return $self->{module_object_uniq}->{$name};
1626         }
1627
1628         return undef;
1629 }
1630
1631 sub register_module_object($$$$)
1632 {
1633         my ($self, $name, $py_name, $location) = @_;
1634
1635         my $existing = $self->existing_module_object($name);
1636         fatal($location, "module_object($name, $py_name) registered twice! $existing.") if defined($existing);
1637
1638         push (@{$self->{module_objects}}, [$name, $py_name]);
1639         $self->{module_object_uniq}->{$name} = $py_name;
1640 }
1641
1642 sub assign($$$)
1643 {
1644         my ($self, $dest, $src) = @_;
1645         if ($dest =~ /^\&/ and $src eq "NULL") {
1646                 $self->pidl("memset($dest, 0, sizeof(" . get_value_of($dest) . "));");
1647         } elsif ($dest =~ /^\&/) {
1648                 my $destvar = get_value_of($dest);
1649                 $self->pidl("$destvar = *$src;");
1650         } else {
1651                 $self->pidl("$dest = $src;");
1652         }
1653 }
1654
1655 sub ConvertStringFromPythonData($$$$$)
1656 {
1657         my ($self, $mem_ctx, $py_var, $target, $fail) = @_;
1658
1659         $self->pidl("{");
1660         $self->indent;
1661         $self->pidl("const char *test_str;");
1662         $self->pidl("const char *talloc_str;");
1663         $self->pidl("PyObject *unicode = NULL;");
1664         $self->pidl("if (PyUnicode_Check($py_var)) {");
1665         $self->indent;
1666         # FIXME: Use Unix charset setting rather than utf-8
1667         $self->pidl("unicode = PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\");");
1668         $self->pidl("if (unicode == NULL) {");
1669         $self->indent;
1670         $self->pidl("PyErr_NoMemory();");
1671         $self->pidl("$fail");
1672         $self->deindent;
1673         $self->pidl("}");
1674
1675         $self->pidl("test_str = PyBytes_AS_STRING(unicode);");
1676         $self->deindent;
1677         $self->pidl("} else if (PyBytes_Check($py_var)) {");
1678         $self->indent;
1679         $self->pidl("test_str = PyBytes_AS_STRING($py_var);");
1680         $self->deindent;
1681         $self->pidl("} else {");
1682         $self->indent;
1683         $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected string or unicode object, got %s\", Py_TYPE($py_var)->tp_name);");
1684         $self->pidl("$fail");
1685         $self->deindent;
1686         $self->pidl("}");
1687         $self->pidl("talloc_str = talloc_strdup($mem_ctx, test_str);");
1688         $self->pidl("if (unicode != NULL) {");
1689         $self->indent;
1690         $self->pidl("Py_DECREF(unicode);");
1691         $self->deindent;
1692         $self->pidl("}");
1693         $self->pidl("if (talloc_str == NULL) {");
1694         $self->indent;
1695         $self->pidl("PyErr_NoMemory();");
1696         $self->pidl("$fail");
1697         $self->deindent;
1698         $self->pidl("}");
1699         $self->pidl("$target = talloc_str;");
1700         $self->deindent;
1701         $self->pidl("}");
1702 }
1703
1704 sub ConvertObjectFromPythonData($$$$$$;$$)
1705 {
1706         my ($self, $mem_ctx, $cvar, $ctype, $target, $fail, $location, $switch) = @_;
1707
1708         fatal($location, "undef type for $cvar") unless(defined($ctype));
1709
1710         $ctype = resolveType($ctype);
1711
1712         my $actual_ctype = $ctype;
1713         if ($actual_ctype->{TYPE} eq "TYPEDEF") {
1714                 $actual_ctype = $actual_ctype->{DATA};
1715         }
1716
1717         # We need to cover ENUMs, BITMAPS and SCALAR values here, as
1718         # all could otherwise be assigned invalid integer values
1719         my $ctype_alias = "";
1720         my $uint_max = "";
1721         if ($actual_ctype->{TYPE} eq "ENUM") {
1722                 # Importantly, ENUM values are unsigned in pidl, and
1723                 # typically map to uint32
1724                 $ctype_alias = enum_type_fn($actual_ctype);
1725         } elsif ($actual_ctype->{TYPE} eq "BITMAP") {
1726                 $ctype_alias = bitmap_type_fn($actual_ctype);
1727         } elsif ($actual_ctype->{TYPE} eq "SCALAR") {
1728                 $ctype_alias = expandAlias($actual_ctype->{NAME});
1729         }
1730
1731         # This is the unsigned Python Integer -> C integer validation
1732         # case.  The signed case is below.
1733         if ($ctype_alias  =~ /^(uint[0-9]*|hyper|udlong|udlongr
1734                                 |NTTIME_hyper|NTTIME|NTTIME_1sec
1735                                 |uid_t|gid_t)$/x) {
1736                 $self->pidl("{");
1737                 $self->indent;
1738                 $self->pidl("const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof($target));");
1739                 $self->pidl("if (PyLong_Check($cvar)) {");
1740                 $self->indent;
1741                 $self->pidl("unsigned long long test_var;");
1742                 $self->pidl("test_var = PyLong_AsUnsignedLongLong($cvar);");
1743                 $self->pidl("if (PyErr_Occurred() != NULL) {");
1744                 $self->indent;
1745                 $self->pidl($fail);
1746                 $self->deindent;
1747                 $self->pidl("}");
1748                 $self->pidl("if (test_var > uint_max) {");
1749                 $self->indent;
1750                 $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s within range 0 - %llu, got %llu\",\\");
1751                 $self->pidl("  PyLong_Type.tp_name, uint_max, test_var);");
1752                 $self->pidl($fail);
1753                 $self->deindent;
1754                 $self->pidl("}");
1755                 $self->pidl("$target = test_var;");
1756                 $self->deindent;
1757                 $self->pidl("} else {");
1758                 $self->indent;
1759                 $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected type %s\",\\");
1760                 $self->pidl("  PyLong_Type.tp_name);");
1761                 $self->pidl($fail);
1762                 $self->deindent;
1763                 $self->pidl("}");
1764                 $self->deindent;
1765                 $self->pidl("}");
1766                 return;
1767         }
1768
1769         # Confirm the signed python integer fits in the C type
1770         # correctly.  It is subtly different from the unsigned case
1771         # above, so while it looks like a duplicate, it is not
1772         # actually a duplicate.
1773         if ($ctype_alias  =~ /^(dlong|char|int[0-9]*|time_t)$/x) {
1774                 $self->pidl("{");
1775                 $self->indent;
1776                 $self->pidl("const long long int_max = ndr_sizeof2intmax(sizeof($target));");
1777                 $self->pidl("const long long int_min = -int_max - 1;");
1778                 $self->pidl("if (PyLong_Check($cvar)) {");
1779                 $self->indent;
1780                 $self->pidl("long long test_var;");
1781                 $self->pidl("test_var = PyLong_AsLongLong($cvar);");
1782                 $self->pidl("if (PyErr_Occurred() != NULL) {");
1783                 $self->indent;
1784                 $self->pidl($fail);
1785                 $self->deindent;
1786                 $self->pidl("}");
1787                 $self->pidl("if (test_var < int_min || test_var > int_max) {");
1788                 $self->indent;
1789                 $self->pidl("PyErr_Format(PyExc_OverflowError, \"Expected type %s within range %lld - %lld, got %lld\",\\");
1790                 $self->pidl("  PyLong_Type.tp_name, int_min, int_max, test_var);");
1791                 $self->pidl($fail);
1792                 $self->deindent;
1793                 $self->pidl("}");
1794                 $self->pidl("$target = test_var;");
1795                 $self->deindent;
1796                 $self->pidl("} else {");
1797                 $self->indent;
1798                 $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected type %s\",\\");
1799                 $self->pidl("  PyLong_Type.tp_name);");
1800                 $self->pidl($fail);
1801                 $self->deindent;
1802                 $self->pidl("}");
1803                 $self->deindent;
1804                 $self->pidl("}");
1805                 return;
1806         }
1807
1808         if ($actual_ctype->{TYPE} eq "STRUCT" or $actual_ctype->{TYPE} eq "INTERFACE") {
1809                 my $ctype_name = $self->use_type_variable($ctype);
1810                 unless (defined ($ctype_name)) {
1811                         error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
1812                         $self->pidl("PyErr_SetString(PyExc_TypeError, \"Can not convert C Type " . mapTypeName($ctype) . " from Python\");");
1813                         return;
1814                 }
1815                 $self->pidl("PY_CHECK_TYPE($ctype_name, $cvar, $fail);");
1816                 $self->pidl("if (talloc_reference($mem_ctx, pytalloc_get_mem_ctx($cvar)) == NULL) {");
1817                 $self->indent;
1818                 $self->pidl("PyErr_NoMemory();");
1819                 $self->pidl("$fail");
1820                 $self->deindent;
1821                 $self->pidl("}");
1822                 $self->assign($target, "(".mapTypeName($ctype)." *)pytalloc_get_ptr($cvar)");
1823                 return;
1824         }
1825
1826         if ($actual_ctype->{TYPE} eq "UNION") {
1827                 my $ctype_name = $self->use_type_variable($ctype);
1828                 unless (defined ($ctype_name)) {
1829                         error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
1830                         $self->pidl("PyErr_SetString(PyExc_TypeError, \"Can not convert C Type " . mapTypeName($ctype) . " from Python\");");
1831                         return;
1832                 }
1833                 my $export = "pyrpc_export_union($ctype_name, $mem_ctx, $switch, $cvar, \"".mapTypeName($ctype)."\")";
1834                 $self->assign($target, "(".mapTypeName($ctype)." *)$export");
1835                 return;
1836         }
1837
1838         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "DATA_BLOB") {
1839                 $self->pidl("$target = data_blob_talloc($mem_ctx, PyBytes_AS_STRING($cvar), PyBytes_GET_SIZE($cvar));");
1840                 return;
1841         }
1842
1843         if ($actual_ctype->{TYPE} eq "SCALAR" and
1844                 ($actual_ctype->{NAME} eq "string"
1845                  or $actual_ctype->{NAME} eq "nbt_string"
1846                  or $actual_ctype->{NAME} eq "nbt_name"
1847                  or $actual_ctype->{NAME} eq "wrepl_nbt_name"
1848                  or $actual_ctype->{NAME} eq "dns_string"
1849                  or $actual_ctype->{NAME} eq "dnsp_string"
1850                  or $actual_ctype->{NAME} eq "dns_name"
1851                  or $actual_ctype->{NAME} eq "ipv4address"
1852                  or $actual_ctype->{NAME} eq "ipv6address"
1853                  or $actual_ctype->{NAME} eq "dnsp_name")) {
1854                 $self->ConvertStringFromPythonData($mem_ctx, $cvar, $target, $fail);
1855                 return;
1856         }
1857
1858         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "NTSTATUS") {
1859                 $self->pidl("$target = NT_STATUS(PyLong_AsLong($cvar));");
1860                 return;
1861         }
1862
1863         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "WERROR") {
1864                 $self->pidl("$target = W_ERROR(PyLong_AsLong($cvar));");
1865                 return;
1866         }
1867
1868         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "HRESULT") {
1869                 $self->pidl("$target = HRES_ERROR(PyLong_AsLong($cvar));");
1870                 return;
1871         }
1872
1873         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "string_array") {
1874                 $self->pidl("$target = pytalloc_get_ptr($cvar);");
1875                 return;
1876         }
1877
1878         if ($actual_ctype->{TYPE} eq "SCALAR" and $actual_ctype->{NAME} eq "pointer") {
1879                 $self->assign($target, "pytalloc_get_ptr($cvar)");
1880                 return;
1881         }
1882
1883         fatal($location, "unknown type `$actual_ctype->{TYPE}' for ".mapTypeName($ctype) . ": $cvar");
1884
1885 }
1886
1887 sub ConvertObjectFromPythonLevel($$$$$$$$$)
1888 {
1889         my ($self, $env, $mem_ctx, $py_var, $e, $l, $var_name, $fail, $recurse) = @_;
1890         my $nl = GetNextLevel($e, $l);
1891         if ($nl and $nl->{TYPE} eq "SUBCONTEXT") {
1892                 $nl = GetNextLevel($e, $nl);
1893         }
1894         my $pl = GetPrevLevel($e, $l);
1895         if ($pl and $pl->{TYPE} eq "SUBCONTEXT") {
1896                 $pl = GetPrevLevel($e, $pl);
1897         }
1898
1899         if ($recurse == 0) {
1900                 $self->pidl("if ($py_var == NULL) {");
1901                 $self->indent;
1902                 $self->pidl("PyErr_Format(PyExc_AttributeError, \"Cannot delete NDR object: " .
1903                     mapTypeName($var_name) . "\");");
1904                 $self->pidl($fail);
1905                 $self->deindent;
1906                 $self->pidl("}");
1907         }
1908         $recurse = $recurse + 1;
1909
1910         if ($l->{TYPE} eq "POINTER") {
1911                 my $need_deindent = 0;
1912                 my $need_deref = 0;
1913
1914                 if ($l->{POINTER_TYPE} ne "ref") {
1915                         $self->pidl("if ($py_var == Py_None) {");
1916                         $self->indent;
1917                         $self->pidl("$var_name = NULL;");
1918                         $self->deindent;
1919                         $self->pidl("} else {");
1920                         $self->indent;
1921                         $need_deindent = 1;
1922                         if ($nl->{TYPE} eq "POINTER") {
1923                                 $need_deref = 1;
1924                         }
1925                 }
1926
1927                 if ($l->{POINTER_TYPE} eq "ref" or $need_deref == 1) {
1928                         $self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
1929                         $self->pidl("if ($var_name == NULL) {");
1930                         $self->indent;
1931                         $self->pidl("PyErr_NoMemory();");
1932                         $self->pidl($fail);
1933                         $self->deindent;
1934                         $self->pidl("}");
1935                 } elsif ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::is_scalar($nl->{DATA_TYPE})
1936                          and not Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
1937                         $self->pidl("$var_name = talloc_ptrtype($mem_ctx, $var_name);");
1938                         $self->pidl("if ($var_name == NULL) {");
1939                         $self->indent;
1940                         $self->pidl("PyErr_NoMemory();");
1941                         $self->pidl($fail);
1942                         $self->deindent;
1943                         $self->pidl("}");
1944                 } else {
1945                         $self->pidl("$var_name = NULL;");
1946                 }
1947                 if ($need_deref == 1) {
1948                         my $ndr_pointer_typename = $self->import_type_variable("samba.dcerpc.base", "ndr_pointer");
1949                         $self->pidl("$py_var = py_dcerpc_ndr_pointer_deref($ndr_pointer_typename, $py_var);");
1950                         $self->pidl("if ($py_var == NULL) {");
1951                         $self->indent;
1952                         $self->pidl($fail);
1953                         $self->deindent;
1954                         $self->pidl("}");
1955                 }
1956                 unless ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
1957                         $var_name = get_value_of($var_name);
1958                 }
1959                 $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail, $recurse);
1960                 if ($need_deindent == 1) {
1961                         $self->deindent;
1962                         $self->pidl("}");
1963                 }
1964         } elsif ($l->{TYPE} eq "ARRAY") {
1965                 if ($pl && $pl->{TYPE} eq "POINTER") {
1966                         $var_name = get_pointer_to($var_name);
1967                 }
1968
1969                 if (is_charset_array($e, $l)) {
1970                         $self->ConvertStringFromPythonData($mem_ctx, $py_var, $var_name, $fail);
1971                 } else {
1972                         my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
1973                         $self->pidl("PY_CHECK_TYPE(&PyList_Type, $py_var, $fail);");
1974                         $self->pidl("{");
1975                         $self->indent;
1976                         $self->pidl("int $counter;");
1977                         if (ArrayDynamicallyAllocated($e, $l)) {
1978                                 $self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_GET_SIZE($py_var));");
1979                                 $self->pidl("if (!$var_name) { $fail; }");
1980                                 $self->pidl("talloc_set_name_const($var_name, \"ARRAY: $var_name\");");
1981                         } else {
1982                                 $self->pidl("if (ARRAY_SIZE($var_name) != PyList_GET_SIZE($py_var)) {");
1983                                 $self->indent;
1984                                 $self->pidl("PyErr_Format(PyExc_TypeError, \"Expected list of type %s, length %zu, got %zd\", Py_TYPE($py_var)->tp_name, ARRAY_SIZE($var_name),  PyList_GET_SIZE($py_var));");
1985                                 $self->pidl("$fail");
1986                                 $self->deindent;
1987                                 $self->pidl("}");
1988                         }
1989                         $self->pidl("for ($counter = 0; $counter < PyList_GET_SIZE($py_var); $counter++) {");
1990                         $self->indent;
1991                         $self->ConvertObjectFromPythonLevel($env, $var_name, "PyList_GET_ITEM($py_var, $counter)", $e, $nl, $var_name."[$counter]", $fail, 0);
1992                         $self->deindent;
1993                         $self->pidl("}");
1994                         $self->deindent;
1995                         $self->pidl("}");
1996                 }
1997         } elsif ($l->{TYPE} eq "DATA") {
1998                 if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
1999                         $var_name = get_pointer_to($var_name);
2000                 }
2001                 $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $l->{DATA_TYPE}, $var_name, $fail, $e->{ORIGINAL});
2002         } elsif ($l->{TYPE} eq "SWITCH") {
2003                 $var_name = get_pointer_to($var_name);
2004                 my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
2005                 my $switch_ptr = "$e->{NAME}_switch_$l->{LEVEL_INDEX}";
2006                 $self->pidl("{");
2007                 $self->indent;
2008                 my $union_type = mapTypeName($nl->{DATA_TYPE});
2009                 $self->pidl("$union_type *$switch_ptr;");
2010                 $self->ConvertObjectFromPythonData($mem_ctx, $py_var, $nl->{DATA_TYPE}, $switch_ptr, $fail, $e->{ORIGINAL}, $switch);
2011                 $self->fail_on_null($switch_ptr, $fail);
2012                 $self->assign($var_name, "$switch_ptr");
2013                 $self->deindent;
2014                 $self->pidl("}");
2015         } elsif ($l->{TYPE} eq "SUBCONTEXT") {
2016                 $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $py_var, $e, $nl, $var_name, $fail, $recurse);
2017         } else {
2018                 fatal($e->{ORIGINAL}, "unknown level type $l->{TYPE}");
2019         }
2020 }
2021
2022 sub ConvertObjectFromPython($$$$$$$)
2023 {
2024         my ($self, $env, $mem_ctx, $ctype, $cvar, $target, $fail) = @_;
2025         my $recurse = 0;
2026
2027         $self->ConvertObjectFromPythonLevel($env, $mem_ctx, $cvar, $ctype, $ctype->{LEVELS}[0], $target, $fail, $recurse);
2028 }
2029
2030 sub ConvertScalarToPython($$$$)
2031 {
2032         my ($self, $ctypename, $cvar, $mem_ctx) = @_;
2033
2034         die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH");
2035
2036         $ctypename = expandAlias($ctypename);
2037
2038         if ($ctypename =~ /^(int64|dlong)$/) {
2039                 return "PyLong_FromLongLong($cvar)";
2040         }
2041
2042         if ($ctypename =~ /^(uint64|hyper|NTTIME_hyper|NTTIME|NTTIME_1sec|udlong|udlongr|uid_t|gid_t)$/) {
2043                 return "PyLong_FromUnsignedLongLong($cvar)";
2044         }
2045
2046         if ($ctypename =~ /^(char|int|int8|int16|int32|time_t)$/) {
2047                 return "PyLong_FromLong($cvar)";
2048         }
2049
2050         # Needed to ensure unsigned values in a 32 or 16 bit enum is
2051         # cast correctly to a uint32_t, not sign extended to a a
2052         # possibly 64 bit unsigned long.  (enums are signed in C,
2053         # unsigned in NDR)
2054         if ($ctypename =~ /^(uint32|uint3264)$/) {
2055                 return "PyLong_FromUnsignedLongLong((uint32_t)$cvar)";
2056         }
2057
2058         if ($ctypename =~ /^(uint|uint8|uint16|uint1632)$/) {
2059                 return "PyLong_FromLong((uint16_t)$cvar)";
2060         }
2061
2062         if ($ctypename eq "DATA_BLOB") {
2063                 return "PyBytes_FromStringAndSize((char *)($cvar).data, ($cvar).length)";
2064         }
2065
2066         if ($ctypename eq "NTSTATUS") {
2067                 return "PyErr_FromNTSTATUS($cvar)";
2068         }
2069
2070         if ($ctypename eq "WERROR") {
2071                 return "PyErr_FromWERROR($cvar)";
2072         }
2073
2074         if ($ctypename eq "HRESULT") {
2075                 return "PyErr_FromHRESULT($cvar)";
2076         }
2077
2078         if (($ctypename eq "string" or $ctypename eq "nbt_string" or $ctypename eq "nbt_name" or $ctypename eq "wrepl_nbt_name")) {
2079                 return "PyString_FromStringOrNULL($cvar)";
2080         }
2081
2082         if (($ctypename eq "dns_string" or $ctypename eq "dns_name")) {
2083                 return "PyString_FromStringOrNULL($cvar)";
2084         }
2085
2086         # Not yet supported
2087         if ($ctypename eq "string_array") {
2088                 return "pytalloc_GenericObject_reference_ex($mem_ctx, $cvar)";
2089         }
2090         if ($ctypename eq "ipv4address") { return "PyString_FromStringOrNULL($cvar)"; }
2091         if ($ctypename eq "ipv6address") { return "PyString_FromStringOrNULL($cvar)"; }
2092         if ($ctypename eq "dnsp_name") { return "PyString_FromStringOrNULL($cvar)"; }
2093         if ($ctypename eq "dnsp_string") { return "PyString_FromStringOrNULL($cvar)"; }
2094         if ($ctypename eq "pointer") {
2095                 return "pytalloc_GenericObject_reference_ex($mem_ctx, $cvar)";
2096         }
2097
2098         die("Unknown scalar type $ctypename");
2099 }
2100
2101 sub ConvertObjectToPythonData($$$$$;$$)
2102 {
2103         my ($self, $mem_ctx, $ctype, $cvar, $location, $switch) = @_;
2104
2105         die("undef type for $cvar") unless(defined($ctype));
2106
2107         $ctype = resolveType($ctype);
2108
2109         my $actual_ctype = $ctype;
2110         if ($actual_ctype->{TYPE} eq "TYPEDEF") {
2111                 $actual_ctype = $actual_ctype->{DATA};
2112         }
2113
2114         if ($actual_ctype->{TYPE} eq "ENUM") {
2115                 return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar, $mem_ctx);
2116         } elsif ($actual_ctype->{TYPE} eq "BITMAP") {
2117                 return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar, $mem_ctx);
2118         } elsif ($actual_ctype->{TYPE} eq "SCALAR") {
2119                 return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar, $mem_ctx);
2120         } elsif ($actual_ctype->{TYPE} eq "UNION") {
2121                 my $ctype_name = $self->use_type_variable($ctype);
2122                 unless (defined($ctype_name)) {
2123                         error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
2124                         return "NULL"; # FIXME!
2125                 }
2126                 return "pyrpc_import_union($ctype_name, $mem_ctx, $switch, $cvar, \"".mapTypeName($ctype)."\")";
2127         } elsif ($actual_ctype->{TYPE} eq "STRUCT" or $actual_ctype->{TYPE} eq "INTERFACE") {
2128                 my $ctype_name = $self->use_type_variable($ctype);
2129                 unless (defined($ctype_name)) {
2130                         error($location, "Unable to determine origin of type `" . mapTypeName($ctype) . "'");
2131                         return "NULL"; # FIXME!
2132                 }
2133                 return "pytalloc_reference_ex($ctype_name, $mem_ctx, $cvar)";
2134         }
2135
2136         fatal($location, "unknown type $actual_ctype->{TYPE} for ".mapTypeName($ctype) . ": $cvar");
2137 }
2138
2139 sub fail_on_null($$$)
2140 {
2141         my ($self, $var, $fail) = @_;
2142         $self->pidl("if ($var == NULL) {");
2143         $self->indent;
2144         $self->pidl($fail);
2145         $self->deindent;
2146         $self->pidl("}");
2147 }
2148
2149 sub ConvertObjectToPythonLevel($$$$$$$)
2150 {
2151         my ($self, $mem_ctx, $env, $e, $l, $var_name, $py_var, $fail, $recurse) = @_;
2152         my $nl = GetNextLevel($e, $l);
2153         if ($nl and $nl->{TYPE} eq "SUBCONTEXT") {
2154                 $nl = GetNextLevel($e, $nl);
2155         }
2156         my $pl = GetPrevLevel($e, $l);
2157         if ($pl and $pl->{TYPE} eq "SUBCONTEXT") {
2158                 $pl = GetPrevLevel($e, $pl);
2159         }
2160
2161         if ($l->{TYPE} eq "POINTER") {
2162                 my $need_wrap = 0;
2163                 if ($l->{POINTER_TYPE} ne "ref" and $nl->{TYPE} eq "POINTER") {
2164                         $need_wrap = 1;
2165                 }
2166                 if ($l->{POINTER_TYPE} ne "ref") {
2167                         if ($recurse == 0) {
2168                                 $self->pidl("if ($var_name == NULL) {");
2169                                 $self->indent;
2170                                 $self->pidl("$py_var = Py_None;");
2171                                 $self->pidl("Py_INCREF($py_var);");
2172                                 $self->deindent;
2173                                 $self->pidl("} else {");
2174                                 $self->indent;
2175                         } else {
2176                                 $self->pidl("{");
2177                                 $self->indent;
2178                         }
2179                         $recurse = $recurse + 1;
2180                 }
2181                 my $var_name2 = $var_name;
2182                 my $recurse2 = $recurse;
2183                 unless ($nl->{TYPE} eq "DATA" and Parse::Pidl::Typelist::scalar_is_reference($nl->{DATA_TYPE})) {
2184                         $var_name2 = get_value_of($var_name);
2185                         $recurse2 = 0;
2186                 }
2187                 $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name2, $py_var, $fail, $recurse2);
2188                 if ($l->{POINTER_TYPE} ne "ref") {
2189                         $self->deindent;
2190                         $self->pidl("}");
2191                 }
2192                 if ($need_wrap) {
2193                         my $py_var_wrap = undef;
2194                         $need_wrap = 1;
2195                         $self->pidl("{");
2196                         $self->indent;
2197                         $py_var_wrap = "py_$e->{NAME}_level_$l->{LEVEL_INDEX}";
2198                         $self->pidl("PyObject *$py_var_wrap = $py_var;");
2199                         my $ndr_pointer_typename = $self->import_type_variable("samba.dcerpc.base", "ndr_pointer");
2200                         $self->pidl("$py_var = py_dcerpc_ndr_pointer_wrap($ndr_pointer_typename, $py_var_wrap);");
2201                         $self->pidl("Py_XDECREF($py_var_wrap);");
2202                         $self->deindent;
2203                         $self->pidl("}");
2204                 }
2205         } elsif ($l->{TYPE} eq "ARRAY") {
2206                 if ($pl && $pl->{TYPE} eq "POINTER") {
2207                         $var_name = get_pointer_to($var_name);
2208                 }
2209
2210                 if (is_charset_array($e, $l)) {
2211                         # FIXME: Use Unix charset setting rather than utf-8
2212                         $self->pidl("if ($var_name == NULL) {");
2213                         $self->indent;
2214                         $self->pidl("$py_var = Py_None;");
2215                         $self->pidl("Py_INCREF($py_var);");
2216                         $self->deindent;
2217                         $self->pidl("} else {");
2218                         $self->indent;
2219                         $self->pidl("$py_var = PyUnicode_Decode($var_name, strlen($var_name), \"utf-8\", \"ignore\");");
2220                         $self->deindent;
2221                         $self->pidl("}");
2222                 } else {
2223                         die("No SIZE_IS for array $var_name") unless (defined($l->{SIZE_IS}));
2224                         my $length = $l->{SIZE_IS};
2225                         if (defined($l->{LENGTH_IS})) {
2226                                 $length = $l->{LENGTH_IS};
2227                         }
2228
2229                         $length = ParseExpr($length, $env, $e);
2230                         $self->pidl("$py_var = PyList_New($length);");
2231                         $self->fail_on_null($py_var, $fail);
2232                         $self->pidl("{");
2233                         $self->indent;
2234                         my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
2235                         $self->pidl("int $counter;");
2236                         $self->pidl("for ($counter = 0; $counter < ($length); $counter++) {");
2237                         $self->indent;
2238                         my $member_var = "py_$e->{NAME}_$l->{LEVEL_INDEX}";
2239                         $self->pidl("PyObject *$member_var;");
2240                         if (ArrayDynamicallyAllocated($e, $l)) {
2241                                 $self->ConvertObjectToPythonLevel($var_name, $env, $e, $nl, $var_name."[$counter]", $member_var, $fail, $recurse);
2242                         } else {
2243                                 $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, $nl, $var_name."[$counter]", $member_var, $fail, $recurse);
2244                         }
2245                         $self->pidl("PyList_SetItem($py_var, $counter, $member_var);");
2246                         $self->deindent;
2247                         $self->pidl("}");
2248                         $self->deindent;
2249                         $self->pidl("}");
2250                 }
2251         } elsif ($l->{TYPE} eq "SWITCH") {
2252                 $var_name = get_pointer_to($var_name);
2253                 my $switch = ParseExpr($l->{SWITCH_IS}, $env, $e);
2254                 my $conv = $self->ConvertObjectToPythonData($mem_ctx, $nl->{DATA_TYPE}, $var_name, $e->{ORIGINAL}, $switch);
2255                 $self->pidl("$py_var = $conv;");
2256                 $self->fail_on_null($py_var, $fail);
2257
2258         } elsif ($l->{TYPE} eq "DATA") {
2259                 if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE})) {
2260                         $var_name = get_pointer_to($var_name);
2261                 }
2262                 my $conv = $self->ConvertObjectToPythonData($mem_ctx, $l->{DATA_TYPE}, $var_name, $e->{ORIGINAL});
2263                 $self->pidl("$py_var = $conv;");
2264         } elsif ($l->{TYPE} eq "SUBCONTEXT") {
2265                 $self->ConvertObjectToPythonLevel($mem_ctx, $env, $e, $nl, $var_name, $py_var, $fail, $recurse);
2266         } else {
2267                 fatal($e->{ORIGINAL}, "Unknown level type $l->{TYPE} $var_name");
2268         }
2269 }
2270
2271 sub ConvertObjectToPython($$$$$$)
2272 {
2273         my ($self, $mem_ctx, $env, $ctype, $cvar, $py_var, $fail) = @_;
2274         my $recurse = 0;
2275
2276         $self->ConvertObjectToPythonLevel($mem_ctx, $env, $ctype, $ctype->{LEVELS}[0], $cvar, $py_var, $fail, $recurse);
2277 }
2278
2279 sub Parse($$$$$)
2280 {
2281     my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
2282
2283         $self->{BASENAME} = $basename;
2284
2285         my $ndr_hdr_include = "";
2286         if (defined($ndr_hdr)) {
2287                 $ndr_hdr_include = "#include \"$ndr_hdr\"";
2288         }
2289     $self->pidl_hdr("
2290 /* Python wrapper functions auto-generated by pidl */
2291 #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
2292 #include <Python.h>
2293 #include \"python/py3compat.h\"
2294 #include \"includes.h\"
2295 #include \"python/modules.h\"
2296 #include <pytalloc.h>
2297 #include \"librpc/rpc/pyrpc.h\"
2298 #include \"librpc/rpc/pyrpc_util.h\"
2299 #include \"$hdr\"
2300 $ndr_hdr_include
2301
2302 /*
2303  * Suppress compiler warnings if the generated code does not call these
2304  * functions
2305  */
2306 #ifndef _MAYBE_UNUSED_
2307 #ifdef HAVE___ATTRIBUTE__
2308 #define _MAYBE_UNUSED_ __attribute__ ((unused))
2309 #else
2310 #define _MAYBE_UNUSED_
2311 #endif
2312 #endif
2313 /*
2314  * These functions are here to ensure they can be optimized out by
2315  * the compiler based on the constant input values
2316  */
2317
2318 static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
2319 {
2320         switch (var_size) {
2321         case 8:
2322                 return UINT64_MAX;
2323         case 4:
2324                 return UINT32_MAX;
2325         case 2:
2326                 return UINT16_MAX;
2327         case 1:
2328                 return UINT8_MAX;
2329         }
2330
2331         return 0;
2332 }
2333
2334 static inline _MAYBE_UNUSED_ long long ndr_sizeof2intmax(size_t var_size)
2335 {
2336         switch (var_size) {
2337         case 8:
2338                 return INT64_MAX;
2339         case 4:
2340                 return INT32_MAX;
2341         case 2:
2342                 return INT16_MAX;
2343         case 1:
2344                 return INT8_MAX;
2345         }
2346
2347         return 0;
2348 }
2349 ");
2350
2351         foreach my $x (@$ndr) {
2352                 ($x->{TYPE} eq "IMPORT") && $self->Import(@{$x->{PATHS}});
2353             ($x->{TYPE} eq "INTERFACE") && $self->Interface($x, $basename);
2354         }
2355
2356         $self->pidl("static PyMethodDef $basename\_methods[] = {");
2357         $self->indent;
2358         foreach (@{$self->{module_methods}}) {
2359                 my ($fn_name, $pyfn_name, $flags, $doc) = @$_;
2360                 $self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },");
2361         }
2362
2363         $self->pidl("{ NULL, NULL, 0, NULL }");
2364         $self->deindent;
2365         $self->pidl("};");
2366
2367         $self->pidl("");
2368
2369         $self->pidl("static struct PyModuleDef moduledef = {");
2370         $self->indent;
2371         $self->pidl("PyModuleDef_HEAD_INIT,");
2372         $self->pidl(".m_name = \"$basename\",");
2373         $self->pidl(".m_doc = \"$basename DCE/RPC\",");
2374         $self->pidl(".m_size = -1,");
2375         $self->pidl(".m_methods = $basename\_methods,");
2376         $self->deindent;
2377         $self->pidl("};");
2378
2379         $self->pidl("MODULE_INIT_FUNC($basename)");
2380         $self->pidl("{");
2381         $self->indent;
2382         $self->pidl("PyObject *m = NULL;");
2383         foreach my $h (@{$self->{module_imports}}) {
2384                 $self->pidl("PyObject *$h->{'key'} = NULL;");
2385         }
2386         $self->pidl("");
2387
2388         foreach my $h (@{$self->{module_imports}}) {
2389                 my $var_name = $h->{'key'};
2390                 my $module_path = $h->{'val'};
2391                 $self->pidl("$var_name = PyImport_ImportModule(\"$module_path\");");
2392                 $self->pidl("if ($var_name == NULL)");
2393                 $self->pidl("\tgoto out;");
2394                 $self->pidl("");
2395         }
2396
2397         foreach my $h (@{$self->{type_imports}}) {
2398                 my $type_var = "$h->{'key'}\_Type";
2399                 my $module_path = $h->{'val'};
2400                 $self->pidl_hdr("static PyTypeObject *$type_var;");
2401                 my $pretty_name = PrettifyTypeName($h->{'key'}, $module_path);
2402                 my $module_var = "dep_$module_path";
2403                 $module_var =~ s/\./_/g;
2404                 $self->pidl("$type_var = (PyTypeObject *)PyObject_GetAttrString($module_var, \"$pretty_name\");");
2405                 $self->pidl("if ($type_var == NULL)");
2406                 $self->pidl("\tgoto out;");
2407                 $self->pidl("");
2408         }
2409
2410         $self->pidl($_) foreach (@{$self->{prereadycode}});
2411
2412         foreach (@{$self->{ready_types}}) {
2413                 $self->pidl("if (PyType_Ready($_) < 0)");
2414                 $self->pidl("\tgoto out;");
2415         }
2416
2417         $self->pidl($_) foreach (@{$self->{postreadycode}});
2418
2419         foreach (@{$self->{patch_type_calls}}) {
2420                 my ($typename, $cvar) = @$_;
2421                 $self->pidl("#ifdef PY_".uc($typename)."_PATCH");
2422                 $self->pidl("PY_".uc($typename)."_PATCH($cvar);");
2423                 $self->pidl("#endif");
2424         }
2425
2426         $self->pidl("");
2427
2428         $self->pidl("m = PyModule_Create(&moduledef);");
2429         $self->pidl("if (m == NULL)");
2430         $self->pidl("\tgoto out;");
2431         $self->pidl("");
2432         foreach my $h (@{$self->{constants}}) {
2433                 my $pretty_name = PrettifyTypeName($h->{'key'}, $basename);
2434                 my $py_obj;
2435                 my ($ctype, $cvar) = @{$h->{'val'}};
2436                 if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) {
2437                         $py_obj = "PyLong_FromUnsignedLongLong($cvar)";
2438                 } elsif ($cvar =~ /^".*"$/) {
2439                         $py_obj = "PyUnicode_FromString($cvar)";
2440                 } else {
2441                         $py_obj = $self->ConvertObjectToPythonData("NULL", expandAlias($ctype), $cvar, undef);
2442                 }
2443
2444                 $self->pidl("PyModule_AddObject(m, \"$pretty_name\", $py_obj);");
2445         }
2446
2447         foreach (@{$self->{module_objects}}) {
2448                 my ($object_name, $c_name) = @$_;
2449                 $self->pidl("Py_INCREF($c_name);");
2450                 $self->pidl("PyModule_AddObject(m, \"$object_name\", $c_name);");
2451         }
2452
2453         $self->pidl("#ifdef PY_MOD_".uc($basename)."_PATCH");
2454         $self->pidl("PY_MOD_".uc($basename)."_PATCH(m);");
2455         $self->pidl("#endif");
2456         $self->pidl("out:");
2457         foreach my $h (@{$self->{module_imports}}) {
2458                 my $mod_var = $h->{'key'};
2459                 $self->pidl("Py_XDECREF($mod_var);");
2460         }
2461         $self->pidl("return m;");
2462         $self->pidl("");
2463         $self->deindent;
2464         $self->pidl("}");
2465     return ($self->{res_hdr} . $self->{res});
2466 }
2467
2468 1;