@ISA = qw(Exporter);
use strict;
-use Parse::Pidl qw(warning fatal);
+use Parse::Pidl qw(warning fatal error);
use Parse::Pidl::Typelist qw(hasType resolveType getType mapTypeName expandAlias);
use Parse::Pidl::Util qw(has_property ParseExpr unmake_str);
use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred is_charset_array);
use Parse::Pidl::CUtil qw(get_value_of get_pointer_to);
+use Parse::Pidl::Samba4 qw(ArrayDynamicallyAllocated);
use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv EnvSubstituteValue GenerateStructEnv);
use vars qw($VERSION);
my ($class) = @_;
my $self = { res => "", res_hdr => "", tabs => "", constants => {},
module_methods => [], module_objects => [], ready_types => [],
- readycode => [] };
+ module_imports => [], type_imports => {},
+ patch_type_calls => [], readycode => [] };
bless($self, $class);
}
{
my ($self, $d) = @_;
if ($d) {
- $self->{res} .= $self->{tabs};
+ if ((!($d =~ /^#/))) {
+ $self->{res} .= $self->{tabs};
+ }
$self->{res} .= $d;
}
$self->{res} .= "\n";
$self->{tabs} = substr($self->{tabs}, 0, -1);
}
+sub PrettifyTypeName($$)
+{
+ my ($name, $basename) = @_;
+
+ $name =~ s/^$basename\_//;
+
+ return $name;
+}
+
sub Import
{
my $self = shift;
foreach (@imports) {
$_ = unmake_str($_);
s/\.idl$//;
- $self->pidl_hdr("#include \"librpc/gen_ndr/py_$_\.h\"\n");
+ $self->pidl_hdr("#include \"librpc/gen_ndr/$_\.h\"\n");
+ $self->register_module_import($_);
}
}
$self->pidl("static PyObject *py_$name\_get_$e->{NAME}(PyObject *obj, void *closure)");
$self->pidl("{");
$self->indent;
- $self->pidl("$cname *object = py_talloc_get_ptr(obj);");
+ $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(obj);");
$self->pidl("PyObject *py_$e->{NAME};");
$self->ConvertObjectToPython("py_talloc_get_mem_ctx(obj)", $env, $e, $varname, "py_$e->{NAME}", "return NULL;");
$self->pidl("return py_$e->{NAME};");
$self->pidl("static int py_$name\_set_$e->{NAME}(PyObject *py_obj, PyObject *value, void *closure)");
$self->pidl("{");
$self->indent;
- $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
+ $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
my $mem_ctx = "py_talloc_get_mem_ctx(py_obj)";
my $l = $e->{LEVELS}[0];
my $nl = GetNextLevel($e, $l);
$self->pidl("");
}
- $self->pidl("static PyObject *py_$name\_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)");
+ $self->pidl("static PyObject *py_$name\_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
$self->pidl("{");
$self->indent;
- $self->pidl("$cname *ret = talloc_zero(NULL, $cname);");
- $self->pidl("return py_talloc_import(&$name\_Type, ret);");
+ $self->pidl("return py_talloc_new($cname, type);");
$self->deindent;
$self->pidl("}");
$self->pidl("");
$self->pidl("static PyObject *py_$name\_ndr_pack(PyObject *py_obj)");
$self->pidl("{");
$self->indent;
- $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
+ $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
$self->pidl("DATA_BLOB blob;");
$self->pidl("enum ndr_err_code err;");
$self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_push_flags_fn_t)ndr_push_$name);");
$self->pidl("static PyObject *py_$name\_ndr_unpack(PyObject *py_obj, PyObject *args)");
$self->pidl("{");
$self->indent;
- $self->pidl("$cname *object = py_talloc_get_ptr(py_obj);");
+ $self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
$self->pidl("DATA_BLOB blob;");
$self->pidl("enum ndr_err_code err;");
$self->pidl("if (!PyArg_ParseTuple(args, \"s#:__ndr_unpack__\", &blob.data, &blob.length))");
$self->pidl("\treturn NULL;");
$self->pidl("");
- $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+
+ # This disgusting hack works around the fact that ndr_pull_struct_blob_all will always fail on structures with relative pointers.
+ # So, map ndr_unpack to ndr_pull_struct_blob_all only if we don't have any relative pointers in this
+ my $got_relative = 0;
+ if ($#{$d->{ELEMENTS}} > -1) {
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ my $l = $e->{LEVELS}[0];
+ if ($l->{TYPE} eq "POINTER" and ($l->{POINTER_TYPE} eq "relative")) {
+ $got_relative = 1;
+ last;
+ }
+ }
+ }
+ if ($got_relative == 0) {
+ $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+ } else {
+ $self->pidl("err = ndr_pull_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+ }
$self->pidl("if (err != NDR_ERR_SUCCESS) {");
$self->indent;
$self->pidl("PyErr_SetNdrError(err);");
$self->deindent;
$self->pidl("}");
$self->pidl("");
- $self->pidl("return Py_None;");
+ $self->pidl("Py_RETURN_NONE;");
$self->deindent;
$self->pidl("}");
$self->pidl("");
$self->pidl("");
}
- $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $name\_Type;\n");
- $self->pidl_hdr("#define $name\_Check(op) PyObject_TypeCheck(op, &$name\_Type)\n");
- $self->pidl_hdr("#define $name\_CheckExact(op) ((op)->ob_type == &$name\_Type)\n");
- $self->pidl_hdr("\n");
- my $docstring = ($self->DocString($d, $name) or "NULL");
+ $self->pidl_hdr("staticforward PyTypeObject $name\_Type;\n");
+ $self->pidl("");
+ my $docstring = $self->DocString($d, $name);
my $typeobject = "$name\_Type";
- $self->pidl("PyTypeObject $typeobject = {");
+ $self->pidl("static PyTypeObject $typeobject = {");
$self->indent;
$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
$self->pidl(".tp_name = \"$modulename.$prettyname\",");
$self->pidl(".tp_dealloc = py_talloc_dealloc,");
$self->pidl(".tp_getset = $getsetters,");
$self->pidl(".tp_repr = py_talloc_default_repr,");
- $self->pidl(".tp_doc = $docstring,");
+ if ($docstring) {
+ $self->pidl(".tp_doc = $docstring,");
+ }
$self->pidl(".tp_methods = $py_methods,");
$self->pidl(".tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,");
$self->pidl(".tp_new = py_$name\_new,");
next unless (grep(/in/,@{$e->{DIRECTION}}));
if ($metadata_args->{in}->{$e->{NAME}}) {
my $py_var = "py_".$metadata_args->{in}->{$e->{NAME}};
- $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
+ $self->pidl("PY_CHECK_TYPE(&PyList_Type, $py_var, $fail);");
my $val = "PyList_Size($py_var)";
if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
$self->pidl("r->in.$e->{NAME} = talloc_ptrtype(r, r->in.$e->{NAME});");
if ($actual_ctype->{TYPE} eq "STRUCT") {
my $typeobject;
- my $fn_name = $d->{NAME};
-
- $fn_name =~ s/^$interface->{NAME}_//;
- $fn_name =~ s/^$basename\_//;
-
+ my $fn_name = PrettifyTypeName($d->{NAME}, $basename);
if ($d->{TYPE} eq "STRUCT") {
$typeobject = $self->PythonStruct($modulename, $fn_name, $d->{NAME}, mapTypeName($d), $d);
{
my($self,$interface,$basename) = @_;
- $self->pidl_hdr("#ifndef _HEADER_PYTHON_$interface->{NAME}\n");
- $self->pidl_hdr("#define _HEADER_PYTHON_$interface->{NAME}\n\n");
-
- $self->pidl_hdr("\n");
+ if (has_property($interface, "pyhelper")) {
+ $self->pidl("#include \"".unmake_str($interface->{PROPERTIES}->{pyhelper})."\"\n");
+ }
$self->Const($_) foreach (@{$interface->{CONSTS}});
}
if (defined $interface->{PROPERTIES}->{uuid}) {
- $self->pidl_hdr("PyAPI_DATA(PyTypeObject) $interface->{NAME}_InterfaceType;\n");
+ $self->pidl_hdr("staticforward PyTypeObject $interface->{NAME}_InterfaceType;\n");
$self->pidl("");
my @fns = ();
}
$self->pidl("const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[] = {");
- $self->pidl_hdr("extern const struct PyNdrRpcMethodDef py_ndr_$interface->{NAME}\_methods[];");
$self->indent;
foreach my $d (@fns) {
my ($infn, $outfn, $callfn, $prettyname, $docstring, $opnum) = @$d;
$self->pidl("};");
$self->pidl("");
- $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)");
+ $self->pidl("static PyObject *interface_$interface->{NAME}_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)");
$self->pidl("{");
$self->indent;
- $self->pidl("dcerpc_InterfaceObject *ret;");
- $self->pidl("const char *binding_string;");
- $self->pidl("struct cli_credentials *credentials;");
- $self->pidl("struct loadparm_context *lp_ctx = NULL;");
- $self->pidl("PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;");
- $self->pidl("TALLOC_CTX *mem_ctx = NULL;");
- $self->pidl("struct event_context *event_ctx;");
- $self->pidl("NTSTATUS status;");
- $self->pidl("");
- $self->pidl("const char *kwnames[] = {");
- $self->indent;
- $self->pidl("\"binding\", \"lp_ctx\", \"credentials\", \"basis_connection\", NULL");
- $self->deindent;
- $self->pidl("};");
- $self->pidl("extern struct loadparm_context *lp_from_py_object(PyObject *py_obj);");
- $self->pidl("extern struct cli_credentials *cli_credentials_from_py_object(PyObject *py_obj);");
- $self->pidl("");
- $self->pidl("if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"s|OOO:$interface->{NAME}\", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials, &py_basis)) {");
- $self->indent;
- $self->pidl("return NULL;");
+ $self->pidl("return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_$interface->{NAME});");
$self->deindent;
$self->pidl("}");
- $self->pidl("");
- $self->pidl("lp_ctx = lp_from_py_object(py_lp_ctx);");
- $self->pidl("if (lp_ctx == NULL) {");
- $self->indent;
- $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected loadparm context\");");
- $self->pidl("return NULL;");
- $self->deindent;
- $self->pidl("}");
- $self->pidl("");
-
- $self->pidl("credentials = cli_credentials_from_py_object(py_credentials);");
- $self->pidl("if (credentials == NULL) {");
- $self->indent;
- $self->pidl("PyErr_SetString(PyExc_TypeError, \"Expected credentials\");");
- $self->pidl("return NULL;");
- $self->deindent;
- $self->pidl("}");
-
- $self->pidl("ret = PyObject_New(dcerpc_InterfaceObject, &$interface->{NAME}_InterfaceType);");
- $self->pidl("");
- $self->pidl("event_ctx = event_context_init(mem_ctx);");
- $self->pidl("");
-
- $self->pidl("if (py_basis != Py_None) {");
- $self->indent;
- $self->pidl("struct dcerpc_pipe *base_pipe;");
- $self->pidl("");
- $self->pidl("if (!PyObject_TypeCheck(py_basis, &dcerpc_InterfaceType)) {");
- $self->indent;
- $self->pidl("PyErr_SetString(PyExc_ValueError, \"basis_connection must be a DCE/RPC connection\");");
- $self->pidl("talloc_free(mem_ctx);");
- $self->pidl("return NULL;");
- $self->deindent;
- $self->pidl("}");
- $self->pidl("");
- $self->pidl("base_pipe = ((dcerpc_InterfaceObject *)py_basis)->pipe;");
- $self->pidl("");
- $self->pidl("status = dcerpc_secondary_context(base_pipe, &ret->pipe, &ndr_table_$interface->{NAME});");
- $self->deindent;
- $self->pidl("} else {");
- $self->indent;
- $self->pidl("status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, ");
- $self->pidl(" &ndr_table_$interface->{NAME}, credentials, event_ctx, lp_ctx);");
- $self->deindent;
- $self->pidl("}");
- $self->handle_ntstatus("status", "NULL", "mem_ctx");
-
- $self->pidl("ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;");
-
- $self->pidl("return (PyObject *)ret;");
- $self->deindent;
- $self->pidl("}");
-
+
$self->pidl("");
my $signature =
$docstring = $signature;
}
- $self->pidl("PyTypeObject $interface->{NAME}_InterfaceType = {");
+ $self->pidl("static PyTypeObject $interface->{NAME}_InterfaceType = {");
$self->indent;
$self->pidl("PyObject_HEAD_INIT(NULL) 0,");
$self->pidl(".tp_name = \"$basename.$interface->{NAME}\",");
}
$self->pidl_hdr("\n");
- $self->pidl_hdr("#endif /* _HEADER_NDR_$interface->{NAME} */\n");
}
sub register_module_method($$$$$)
$self->register_module_object($name, "(PyObject *)$py_name");
$self->check_ready_type($py_name);
+
+ $self->register_patch_type_call($name, $py_name);
}
sub check_ready_type($$)
push (@{$self->{ready_types}}, $py_name) unless (grep(/^$py_name$/,@{$self->{ready_types}}));
}
+sub register_module_import($$)
+{
+ my ($self, $basename) = @_;
+
+ push (@{$self->{module_imports}}, $basename) unless (grep(/^$basename$/,@{$self->{module_imports}}));
+}
+
+sub use_type_variable($$)
+{
+ my ($self, $orig_ctype) = @_;
+ my $ctype = resolveType($orig_ctype);
+ unless (defined($ctype->{BASEFILE})) {
+ return undef;
+ }
+ # If this is an external type, make sure we do the right imports.
+ if (($ctype->{BASEFILE} ne $self->{BASENAME})) {
+ $self->register_module_import($ctype->{BASEFILE});
+ unless (defined($self->{type_imports}->{$ctype->{NAME}})) {
+ $self->{type_imports}->{$ctype->{NAME}} = $ctype->{BASEFILE};
+ }
+ return "$ctype->{NAME}_Type";
+ }
+ return "&$ctype->{NAME}_Type";
+}
+
+sub register_patch_type_call($$$)
+{
+ my ($self, $typename, $cvar) = @_;
+
+ push(@{$self->{patch_type_calls}}, [$typename, $cvar]);
+
+}
+
sub register_module_readycode($$)
{
my ($self, $code) = @_;
sub assign($$$)
{
my ($self, $dest, $src) = @_;
- if ($dest =~ /^\&/) {
+ if ($dest =~ /^\&/ and $src eq "NULL") {
+ $self->pidl("memset($dest, 0, sizeof(" . get_value_of($dest) . "));");
+ } elsif ($dest =~ /^\&/) {
$self->pidl("memcpy($dest, $src, sizeof(" . get_value_of($dest) . "));");
} else {
$self->pidl("$dest = $src;");
$ctype = resolveType($ctype);
my $actual_ctype = $ctype;
- if ($ctype->{TYPE} eq "TYPEDEF") {
- $actual_ctype = $ctype->{DATA};
+ if ($actual_ctype->{TYPE} eq "TYPEDEF") {
+ $actual_ctype = $actual_ctype->{DATA};
}
if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or
$actual_ctype->{TYPE} eq "SCALAR" and (
expandAlias($actual_ctype->{NAME}) =~ /^(u?int[0-9]*|hyper|NTTIME|time_t|NTTIME_hyper|NTTIME_1sec|dlong|udlong|udlongr)$/)) {
- $self->pidl("PY_CHECK_TYPE(PyInt, $cvar, $fail);");
+ $self->pidl("PY_CHECK_TYPE(&PyInt_Type, $cvar, $fail);");
$self->pidl("$target = PyInt_AsLong($cvar);");
return;
}
if ($actual_ctype->{TYPE} eq "STRUCT" or $actual_ctype->{TYPE} eq "INTERFACE") {
- $self->pidl("PY_CHECK_TYPE($ctype->{NAME}, $cvar, $fail);");
+ my $ctype_name = $self->use_type_variable($ctype);
+ unless (defined ($ctype_name)) {
+ error(undef, "Unable to determine origin of type " . mapTypeName($ctype));
+ $self->assign($target, "NULL");
+ # FIXME:
+ return;
+ }
+ $self->pidl("PY_CHECK_TYPE($ctype_name, $cvar, $fail);");
$self->assign($target, "py_talloc_get_ptr($cvar)");
return;
}
}
if (is_charset_array($e, $l)) {
- $self->pidl("PY_CHECK_TYPE(PyUnicode, $py_var, $fail);");
+ $self->pidl("PY_CHECK_TYPE(&PyUnicode_Type, $py_var, $fail);");
# FIXME: Use Unix charset setting rather than utf-8
$self->pidl($var_name . " = PyString_AsString(PyUnicode_AsEncodedString($py_var, \"utf-8\", \"ignore\"));");
} else {
my $counter = "$e->{NAME}_cntr_$l->{LEVEL_INDEX}";
- $self->pidl("PY_CHECK_TYPE(PyList, $py_var, $fail);");
+ $self->pidl("PY_CHECK_TYPE(&PyList_Type, $py_var, $fail);");
$self->pidl("{");
$self->indent;
$self->pidl("int $counter;");
- if (!$l->{IS_FIXED}) {
+ if (ArrayDynamicallyAllocated($e, $l)) {
$self->pidl("$var_name = talloc_array_ptrtype($mem_ctx, $var_name, PyList_Size($py_var));");
}
$self->pidl("for ($counter = 0; $counter < PyList_Size($py_var); $counter++) {");
$ctype = resolveType($ctype);
my $actual_ctype = $ctype;
- if ($ctype->{TYPE} eq "TYPEDEF") {
- $actual_ctype = $ctype->{DATA};
+ if ($actual_ctype->{TYPE} eq "TYPEDEF") {
+ $actual_ctype = $actual_ctype->{DATA};
}
if ($actual_ctype->{TYPE} eq "ENUM") {
} elsif ($actual_ctype->{TYPE} eq "UNION") {
fatal($ctype, "union without discriminant: " . mapTypeName($ctype) . ": $cvar");
} elsif ($actual_ctype->{TYPE} eq "STRUCT" or $actual_ctype->{TYPE} eq "INTERFACE") {
- return "py_talloc_import_ex(&$ctype->{NAME}_Type, $mem_ctx, $cvar)";
+ my $ctype_name = $self->use_type_variable($ctype);
+ unless (defined($ctype_name)) {
+ error(undef, "Unable to determine origin of type " . mapTypeName($ctype));
+ return "NULL"; # FIXME!
+ }
+ return "py_talloc_import_ex($ctype_name, $mem_ctx, $cvar)";
}
fatal($ctype, "unknown type $actual_ctype->{TYPE} for ".mapTypeName($ctype) . ": $cvar");
sub Parse($$$$$)
{
my($self,$basename,$ndr,$ndr_hdr,$hdr) = @_;
-
- my $py_hdr = $hdr;
- $py_hdr =~ s/ndr_([^\/]+)$/py_$1/g;
- $self->pidl_hdr("/* header auto-generated by pidl */\n\n");
-
- $self->pidl("
+ $self->{BASENAME} = $basename;
+
+ $self->pidl_hdr("
/* Python wrapper functions auto-generated by pidl */
#include \"includes.h\"
#include <Python.h>
#include \"librpc/rpc/dcerpc.h\"
-#include \"scripting/python/pytalloc.h\"
+#include \"lib/talloc/pytalloc.h\"
#include \"librpc/rpc/pyrpc.h\"
-#include \"lib/events/events.h\"
#include \"$hdr\"
#include \"$ndr_hdr\"
-#include \"$py_hdr\"
+
+#ifndef Py_RETURN_NONE
+#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
+#endif
");
my ($fn_name, $pyfn_name, $flags, $doc) = @$_;
$self->pidl("{ \"$fn_name\", (PyCFunction)$pyfn_name, $flags, $doc },");
}
-
+
$self->pidl("{ NULL, NULL, 0, NULL }");
$self->deindent;
$self->pidl("};");
$self->pidl("{");
$self->indent;
$self->pidl("PyObject *m;");
+ foreach (@{$self->{module_imports}}) {
+ $self->pidl("PyObject *dep_$_;");
+ }
$self->pidl("");
+ foreach (@{$self->{module_imports}}) {
+ $self->pidl("dep_$_ = PyImport_ImportModule(\"samba.dcerpc.$_\");");
+ $self->pidl("if (dep_$_ == NULL)");
+ $self->pidl("\treturn;");
+ $self->pidl("");
+ }
+
+ foreach (keys %{$self->{type_imports}}) {
+ my $basefile = $self->{type_imports}->{$_};
+ $self->pidl_hdr("static PyTypeObject *$_\_Type;\n");
+ my $pretty_name = PrettifyTypeName($_, $basefile);
+ $self->pidl("$_\_Type = (PyTypeObject *)PyObject_GetAttrString(dep_$basefile, \"$pretty_name\");");
+ $self->pidl("if ($_\_Type == NULL)");
+ $self->pidl("\treturn;");
+ $self->pidl("");
+ }
+
foreach (@{$self->{ready_types}}) {
$self->pidl("if (PyType_Ready($_) < 0)");
$self->pidl("\treturn;");
$self->pidl($_) foreach (@{$self->{readycode}});
+ foreach (@{$self->{patch_type_calls}}) {
+ my ($typename, $cvar) = @$_;
+ $self->pidl("#ifdef PY_".uc($typename)."_PATCH");
+ $self->pidl("PY_".uc($typename)."_PATCH($cvar);");
+ $self->pidl("#endif");
+ }
+
$self->pidl("");
$self->pidl("m = Py_InitModule3(\"$basename\", $basename\_methods, \"$basename DCE/RPC\");");
$self->pidl("PyModule_AddObject(m, \"$object_name\", $c_name);");
}
+ $self->pidl("#ifdef PY_MOD_".uc($basename)."_PATCH");
+ $self->pidl("PY_MOD_".uc($basename)."_PATCH(m);");
+ $self->pidl("#endif");
+
+ $self->pidl("");
$self->deindent;
$self->pidl("}");
- return ($self->{res_hdr}, $self->{res});
+ return ($self->{res_hdr} . $self->{res});
}
1;