summaryrefslogtreecommitdiff
path: root/source4/pidl/Parse
diff options
context:
space:
mode:
Diffstat (limited to 'source4/pidl/Parse')
-rw-r--r--source4/pidl/Parse/Pidl.pm16
-rw-r--r--source4/pidl/Parse/Pidl/Compat.pm203
-rw-r--r--source4/pidl/Parse/Pidl/Dump.pm277
-rw-r--r--source4/pidl/Parse/Pidl/Ethereal/Conformance.pm161
-rw-r--r--source4/pidl/Parse/Pidl/Ethereal/NDR.pm844
-rw-r--r--source4/pidl/Parse/Pidl/IDL.pm2609
-rw-r--r--source4/pidl/Parse/Pidl/NDR.pm967
-rw-r--r--source4/pidl/Parse/Pidl/ODL.pm92
-rw-r--r--source4/pidl/Parse/Pidl/Samba/COM/Header.pm139
-rw-r--r--source4/pidl/Parse/Pidl/Samba/COM/Proxy.pm212
-rw-r--r--source4/pidl/Parse/Pidl/Samba/COM/Stub.pm324
-rw-r--r--source4/pidl/Parse/Pidl/Samba/EJS.pm835
-rw-r--r--source4/pidl/Parse/Pidl/Samba/EJSHeader.pm76
-rw-r--r--source4/pidl/Parse/Pidl/Samba/Header.pm356
-rw-r--r--source4/pidl/Parse/Pidl/Samba/NDR/Client.pm99
-rw-r--r--source4/pidl/Parse/Pidl/Samba/NDR/Header.pm166
-rw-r--r--source4/pidl/Parse/Pidl/Samba/NDR/Parser.pm2341
-rw-r--r--source4/pidl/Parse/Pidl/Samba/NDR/Server.pm322
-rw-r--r--source4/pidl/Parse/Pidl/Samba/SWIG.pm76
-rw-r--r--source4/pidl/Parse/Pidl/Samba/TDR.pm266
-rw-r--r--source4/pidl/Parse/Pidl/Samba/Template.pm88
-rw-r--r--source4/pidl/Parse/Pidl/Test.pm169
-rw-r--r--source4/pidl/Parse/Pidl/Typelist.pm336
-rw-r--r--source4/pidl/Parse/Pidl/Util.pm149
24 files changed, 11123 insertions, 0 deletions
diff --git a/source4/pidl/Parse/Pidl.pm b/source4/pidl/Parse/Pidl.pm
new file mode 100644
index 0000000000..465f3409ad
--- /dev/null
+++ b/source4/pidl/Parse/Pidl.pm
@@ -0,0 +1,16 @@
+###################################################
+# package to parse IDL files and generate code for
+# rpc functions in Samba
+# Copyright tridge@samba.org 2000-2003
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl;
+
+use strict;
+
+use vars qw ( $VERSION );
+
+$VERSION = '0.01';
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Compat.pm b/source4/pidl/Parse/Pidl/Compat.pm
new file mode 100644
index 0000000000..39cb67fd71
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Compat.pm
@@ -0,0 +1,203 @@
+###################################################
+# IDL Compatibility checker
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Compat;
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my %supported_properties = (
+ # interface
+ "helpstring" => ["INTERFACE", "FUNCTION"],
+ "version" => ["INTERFACE"],
+ "uuid" => ["INTERFACE"],
+ "endpoint" => ["INTERFACE"],
+ "pointer_default" => ["INTERFACE"],
+
+ # dcom
+ "object" => ["INTERFACE"],
+ "local" => ["INTERFACE", "FUNCTION"],
+ "iid_is" => ["ELEMENT"],
+ "call_as" => ["FUNCTION"],
+ "idempotent" => ["FUNCTION"],
+
+ # function
+ "in" => ["ELEMENT"],
+ "out" => ["ELEMENT"],
+
+ # pointer
+ "ref" => ["ELEMENT"],
+ "ptr" => ["ELEMENT"],
+ "unique" => ["ELEMENT"],
+ "ignore" => ["ELEMENT"],
+
+ "value" => ["ELEMENT"],
+
+ # generic
+ "public" => ["FUNCTION", "TYPEDEF"],
+ "nopush" => ["FUNCTION", "TYPEDEF"],
+ "nopull" => ["FUNCTION", "TYPEDEF"],
+ "noprint" => ["FUNCTION", "TYPEDEF"],
+ "noejs" => ["FUNCTION", "TYPEDEF"],
+
+ # union
+ "switch_is" => ["ELEMENT"],
+ "switch_type" => ["ELEMENT", "TYPEDEF"],
+ "case" => ["ELEMENT"],
+ "default" => ["ELEMENT"],
+
+ # subcontext
+ "subcontext" => ["ELEMENT"],
+ "subcontext_size" => ["ELEMENT"],
+
+ # enum
+ "enum16bit" => ["TYPEDEF"],
+ "v1_enum" => ["TYPEDEF"],
+
+ # bitmap
+ "bitmap8bit" => ["TYPEDEF"],
+ "bitmap16bit" => ["TYPEDEF"],
+ "bitmap32bit" => ["TYPEDEF"],
+ "bitmap64bit" => ["TYPEDEF"],
+
+ # array
+ "range" => ["ELEMENT"],
+ "size_is" => ["ELEMENT"],
+ "string" => ["ELEMENT"],
+ "noheader" => ["ELEMENT"],
+ "charset" => ["ELEMENT"],
+ "length_is" => ["ELEMENT"],
+);
+
+
+my($res);
+
+sub warning($$)
+{
+ my $l = shift;
+ my $m = shift;
+
+ print "$l->{FILE}:$l->{LINE}:Warning:$m\n";
+}
+
+sub error($$)
+{
+ my ($l,$m) = @_;
+ print "$l->{FILE}:$l->{LINE}:$m\n";
+}
+
+sub CheckTypedef($)
+{
+ my $td = shift;
+
+ if (has_property($td, "nodiscriminant")) {
+ error($td, "nodiscriminant property not supported");
+ }
+
+ if ($td->{TYPE} eq "BITMAP") {
+ warning($td, "converting bitmap to scalar");
+ #FIXME
+ }
+
+ if (has_property($td, "gensize")) {
+ warning($td, "ignoring gensize() property. ");
+ }
+
+ if (has_property($td, "enum8bit") and has_property($td, "enum16bit")) {
+ warning($td, "8 and 16 bit enums not supported, converting to scalar");
+ #FIXME
+ }
+
+ StripProperties($td);
+}
+
+sub CheckElement($)
+{
+ my $e = shift;
+
+ if (has_property($e, "noheader")) {
+ error($e, "noheader property not supported");
+ return;
+ }
+
+ if (has_property($e, "subcontext")) {
+ warning($e, "converting subcontext to byte array");
+ #FIXME
+ }
+
+ if (has_property($e, "compression")) {
+ error($e, "compression() property not supported");
+ }
+
+ if (has_property($e, "obfuscation")) {
+ error($e, "obfuscation() property not supported");
+ }
+
+ if (has_property($e, "sptr")) {
+ error($e, "sptr() pointer property not supported");
+ }
+
+ if (has_property($e, "relative")) {
+ error($e, "relative() pointer property not supported");
+ }
+
+ if (has_property($td, "flag")) {
+ warning($e, "ignoring flag() property");
+ }
+
+ if (has_property($td, "value")) {
+ warning($e, "ignoring value() property");
+ }
+
+ StripProperties($e);
+}
+
+sub CheckFunction($)
+{
+ my $fn = shift;
+
+ if (has_property($fn, "noopnum")) {
+ error($fn, "noopnum not converted. Opcodes will be out of sync.");
+ }
+
+ StripProperties($fn);
+
+
+}
+
+sub CheckInterface($)
+{
+ my $if = shift;
+
+ if (has_property($if, "pointer_default_top") and
+ $if->{PROPERTIES}->{pointer_default_top} ne "ref") {
+ error($if, "pointer_default_top() is pidl-specific");
+ }
+
+ StripProperties($if);
+
+ foreach my $x (@{$if->{DATA}}) {
+ if ($x->{TYPE} eq "DECLARE") {
+ warning($if, "the declare keyword is pidl-specific");
+ next;
+ }
+ }
+}
+
+sub Check($)
+{
+ my $pidl = shift;
+ my $nidl = [];
+ my $res = "";
+
+ foreach my $x (@{$pidl}) {
+ push (@$nidl, CheckInterface($x))
+ if ($x->{TYPE} eq "INTERFACE");
+ }
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Dump.pm b/source4/pidl/Parse/Pidl/Dump.pm
new file mode 100644
index 0000000000..bca599262a
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Dump.pm
@@ -0,0 +1,277 @@
+###################################################
+# dump function for IDL structures
+# Copyright tridge@samba.org 2000
+# released under the GNU GPL
+
+package Parse::Pidl::Dump;
+
+use Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(DumpTypedef DumpStruct DumpEnum DumpBitmap DumpUnion DumpFunction);
+
+use strict;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+
+#####################################################################
+# dump a properties list
+sub DumpProperties($)
+{
+ my($props) = shift;
+ my($res);
+
+ foreach my $d ($props) {
+ foreach my $k (keys %{$d}) {
+ if ($k eq "in") {
+ $res .= "[in] ";
+ next;
+ }
+ if ($k eq "out") {
+ $res .= "[out] ";
+ next;
+ }
+ if ($k eq "ref") {
+ $res .= "[ref] ";
+ next;
+ }
+ $res .= "[$k($d->{$k})] ";
+ }
+ }
+ return $res;
+}
+
+#####################################################################
+# dump a structure element
+sub DumpElement($)
+{
+ my($element) = shift;
+ my($res);
+
+ (defined $element->{PROPERTIES}) &&
+ ($res .= DumpProperties($element->{PROPERTIES}));
+ $res .= DumpType($element->{TYPE});
+ $res .= " ";
+ for my $i (1..$element->{POINTERS}) {
+ $res .= "*";
+ }
+ $res .= "$element->{NAME}";
+ foreach (@{$element->{ARRAY_LEN}}) {
+ $res .= "[$_]";
+ }
+
+ return $res;
+}
+
+#####################################################################
+# dump a struct
+sub DumpStruct($)
+{
+ my($struct) = shift;
+ my($res);
+
+ $res .= "struct {\n";
+ if (defined $struct->{ELEMENTS}) {
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ $res .= "\t" . DumpElement($e);
+ $res .= ";\n";
+ }
+ }
+ $res .= "}";
+
+ return $res;
+}
+
+
+#####################################################################
+# dump a struct
+sub DumpEnum($)
+{
+ my($enum) = shift;
+ my($res);
+
+ $res .= "enum {\n";
+
+ foreach (@{$enum->{ELEMENTS}}) {
+ if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+ $res .= "\t$1 = $2,\n";
+ } else {
+ $res .= "\t$_,\n";
+ }
+ }
+
+ $res.= "}";
+
+ return $res;
+}
+
+#####################################################################
+# dump a struct
+sub DumpBitmap($)
+{
+ my($bitmap) = shift;
+ my($res);
+
+ $res .= "bitmap {\n";
+
+ foreach (@{$bitmap->{ELEMENTS}}) {
+ if (/^([A-Za-z0-9_]+)[ \t]*\((.*)\)$/) {
+ $res .= "\t$1 = $2,\n";
+ } else {
+ die ("Bitmap $bitmap->{NAME} has field $_ without proper value");
+ }
+ }
+
+ $res.= "}";
+
+ return $res;
+}
+
+
+#####################################################################
+# dump a union element
+sub DumpUnionElement($)
+{
+ my($element) = shift;
+ my($res);
+
+ if (has_property($element, "default")) {
+ $res .= "[default] ;\n";
+ } else {
+ $res .= "[case($element->{PROPERTIES}->{case})] ";
+ $res .= DumpElement($element), if defined($element);
+ $res .= ";\n";
+ }
+
+ return $res;
+}
+
+#####################################################################
+# dump a union
+sub DumpUnion($)
+{
+ my($union) = shift;
+ my($res);
+
+ (defined $union->{PROPERTIES}) &&
+ ($res .= DumpProperties($union->{PROPERTIES}));
+ $res .= "union {\n";
+ foreach my $e (@{$union->{ELEMENTS}}) {
+ $res .= DumpUnionElement($e);
+ }
+ $res .= "}";
+
+ return $res;
+}
+
+#####################################################################
+# dump a type
+sub DumpType($)
+{
+ my($data) = shift;
+ my($res);
+
+ if (ref($data) eq "HASH") {
+ ($data->{TYPE} eq "STRUCT") && ($res .= DumpStruct($data));
+ ($data->{TYPE} eq "UNION") && ($res .= DumpUnion($data));
+ ($data->{TYPE} eq "ENUM") && ($res .= DumpEnum($data));
+ ($data->{TYPE} eq "BITMAP") && ($res .= DumpBitmap($data));
+ } else {
+ $res .= "$data";
+ }
+
+ return $res;
+}
+
+#####################################################################
+# dump a typedef
+sub DumpTypedef($)
+{
+ my($typedef) = shift;
+ my($res);
+
+ $res .= "typedef ";
+ $res .= DumpType($typedef->{DATA});
+ $res .= " $typedef->{NAME};\n\n";
+
+ return $res;
+}
+
+#####################################################################
+# dump a typedef
+sub DumpFunction($)
+{
+ my($function) = shift;
+ my($first) = 1;
+ my($res);
+
+ $res .= DumpType($function->{RETURN_TYPE});
+ $res .= " $function->{NAME}(\n";
+ for my $d (@{$function->{DATA}}) {
+ $first || ($res .= ",\n"); $first = 0;
+ $res .= DumpElement($d);
+ }
+ $res .= "\n);\n\n";
+
+ return $res;
+}
+
+#####################################################################
+# dump a module header
+sub DumpInterfaceProperties($)
+{
+ my($header) = shift;
+ my($data) = $header->{DATA};
+ my($first) = 1;
+ my($res);
+
+ $res .= "[\n";
+ foreach my $k (keys %{$data}) {
+ $first || ($res .= ",\n"); $first = 0;
+ $res .= "$k($data->{$k})";
+ }
+ $res .= "\n]\n";
+
+ return $res;
+}
+
+#####################################################################
+# dump the interface definitions
+sub DumpInterface($)
+{
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+ my($res);
+
+ $res .= DumpInterfaceProperties($interface->{PROPERTIES});
+
+ $res .= "interface $interface->{NAME}\n{\n";
+ foreach my $d (@{$data}) {
+ ($d->{TYPE} eq "TYPEDEF") &&
+ ($res .= DumpTypedef($d));
+ ($d->{TYPE} eq "FUNCTION") &&
+ ($res .= DumpFunction($d));
+ }
+ $res .= "}\n";
+
+ return $res;
+}
+
+
+#####################################################################
+# dump a parsed IDL structure back into an IDL file
+sub Dump($)
+{
+ my($idl) = shift;
+ my($res);
+
+ $res = "/* Dumped by pidl */\n\n";
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") &&
+ ($res .= DumpInterface($x));
+ }
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Ethereal/Conformance.pm b/source4/pidl/Parse/Pidl/Ethereal/Conformance.pm
new file mode 100644
index 0000000000..45654fe6aa
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Ethereal/Conformance.pm
@@ -0,0 +1,161 @@
+###################################################
+# parse an ethereal conformance file
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Ethereal::Conformance;
+
+require Exporter;
+
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(ReadConformance);
+
+use strict;
+
+use Parse::Pidl::Util qw(has_property);
+
+sub handle_type($$$$$$$$)
+{
+ my ($data,$name,$dissectorname,$ft_type,$base_type,$mask,$valsstring,$alignment) = @_;
+
+ $data->{types}->{$name} = {
+ NAME => $name,
+ DISSECTOR_NAME => $dissectorname,
+ FT_TYPE => $ft_type,
+ BASE_TYPE => $base_type,
+ MASK => $mask,
+ VALSSTRING => $valsstring,
+ ALIGNMENT => $alignment
+ };
+}
+
+
+sub handle_hf_rename($$$)
+{
+ my ($data,$old,$new) = @_;
+ $data->{hf_renames}{$old} = $new;
+}
+
+sub handle_param_value($$$)
+{
+ my ($data,$dissector_name,$value) = @_;
+
+ $data->{dissectorparams}->{$dissector_name} = $value;
+}
+
+sub handle_hf_field($$$$$$$$$)
+{
+ my ($data,$hf,$title,$filter,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_;
+
+ $data->{header_fields}->{$hf} = {
+ HF => $hf,
+ TITLE => $title,
+ FILTER => $filter,
+ FT_TYPE => $ft_type,
+ BASE_TYPE => $base_type,
+ VALSSTRING => $valsstring,
+ MASK => $mask,
+ BLURB => $blurb
+ };
+}
+
+sub handle_strip_prefix($$)
+{
+ my ($data,$x) = @_;
+
+ push (@{$data->{strip_prefixes}}, $x);
+}
+
+sub handle_noemit($$)
+{
+ my ($data,$type) = @_;
+
+ $data->{noemit}->{$type} = 1;
+}
+
+sub handle_protocol($$$$$)
+{
+ my ($data, $name, $longname, $shortname, $filtername) = @_;
+
+ $data->{protocols}->{$name} = {
+ LONGNAME => $longname,
+ SHORTNAME => $shortname,
+ FILTERNAME => $filtername
+ };
+}
+
+sub handle_fielddescription($$$)
+{
+ my ($data,$field,$desc) = @_;
+
+ $data->{fielddescription}->{$field} = $desc;
+}
+
+sub handle_import
+{
+ my $data = shift @_;
+ my $dissectorname = shift @_;
+
+ $data->{imports}->{$dissectorname} = join(' ', @_);
+}
+
+my %field_handlers = (
+ TYPE => \&handle_type,
+ NOEMIT => \&handle_noemit,
+ PARAM_VALUE => \&handle_param_value,
+ HF_FIELD => \&handle_hf_field,
+ HF_RENAME => \&handle_hf_rename,
+ STRIP_PREFIX => \&handle_strip_prefix,
+ PROTOCOL => \&handle_protocol,
+ FIELD_DESCRIPTION => \&handle_fielddescription,
+ IMPORT => \&handle_import
+);
+
+sub ReadConformance($$)
+{
+ my ($f,$data) = @_;
+
+ $data->{override} = "";
+
+ my $incodeblock = 0;
+
+ open(IN,"<$f") or return undef;
+
+ my $ln = 0;
+
+ foreach (<IN>) {
+ $ln++;
+ next if (/^#.*$/);
+ next if (/^$/);
+
+ s/[\r\n]//g;
+
+ if ($_ eq "CODE START") {
+ $incodeblock = 1;
+ next;
+ } elsif ($incodeblock and $_ eq "CODE END") {
+ $incodeblock = 0;
+ next;
+ } elsif ($incodeblock) {
+ $data->{override}.="$_\n";
+ next;
+ }
+
+ my @fields = split(/ /);
+
+ my $cmd = $fields[0];
+
+ shift @fields;
+
+ if (not defined($field_handlers{$cmd})) {
+ print "$f:$ln: Warning: Unknown command `$cmd'\n";
+ next;
+ }
+
+ $field_handlers{$cmd}($data, @fields);
+ }
+
+ close(IN);
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Ethereal/NDR.pm b/source4/pidl/Parse/Pidl/Ethereal/NDR.pm
new file mode 100644
index 0000000000..73dd34096e
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Ethereal/NDR.pm
@@ -0,0 +1,844 @@
+##################################################
+# Samba4 NDR parser generator for IDL structures
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# Portions based on idl2eth.c by Ronnie Sahlberg
+# released under the GNU GPL
+
+package Parse::Pidl::Ethereal::NDR;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property ParseExpr property_matches);
+use Parse::Pidl::NDR;
+use Parse::Pidl::Dump qw(DumpTypedef DumpFunction);
+use Parse::Pidl::Ethereal::Conformance qw(ReadConformance);
+
+my %types;
+
+my $conformance = {imports=>{}};
+
+my %ptrtype_mappings = (
+ "unique" => "NDR_POINTER_UNIQUE",
+ "ref" => "NDR_POINTER_REF",
+ "ptr" => "NDR_POINTER_PTR"
+);
+
+sub type2ft($)
+{
+ my($t) = shift;
+
+ return "FT_UINT$1" if $t =~ /uint(8|16|32|64)/;
+ return "FT_INT$1" if $t =~ /int(8|16|32|64)/;
+ return "FT_UINT64", if $t eq "HYPER_T" or $t eq "NTTIME"
+ or $t eq "NTTIME_1sec" or $t eq "NTTIME_hyper" or $t eq "hyper";
+
+ return "FT_STRING" if ($t eq "string");
+
+ return "FT_NONE";
+}
+
+sub StripPrefixes($)
+{
+ my ($s) = @_;
+
+ foreach (@{$conformance->{strip_prefixes}}) {
+ $s =~ s/^$_\_//g;
+ }
+
+ return $s;
+}
+
+# Convert a IDL structure field name (e.g access_mask) to a prettier
+# string like 'Access Mask'.
+
+sub field2name($)
+{
+ my($field) = shift;
+
+ $field =~ s/_/ /g; # Replace underscores with spaces
+ $field =~ s/(\w+)/\u\L$1/g; # Capitalise each word
+
+ return $field;
+}
+
+my %res = ();
+my $tabs = "";
+sub pidl_code($)
+{
+ my $d = shift;
+ if ($d) {
+ $res{code} .= $tabs;
+ $res{code} .= $d;
+ }
+ $res{code} .="\n";
+}
+
+sub pidl_hdr($) { my $x = shift; $res{hdr} .= "$x\n"; }
+sub pidl_def($) { my $x = shift; $res{def} .= "$x\n"; }
+
+sub indent()
+{
+ $tabs .= "\t";
+}
+
+sub deindent()
+{
+ $tabs = substr($tabs, 0, -1);
+}
+
+sub PrintIdl($)
+{
+ my $idl = shift;
+
+ foreach (split /\n/, $idl) {
+ pidl_code "/* IDL: $_ */";
+ }
+}
+
+#####################################################################
+# parse the interface definitions
+sub Interface($)
+{
+ my($interface) = @_;
+ Const($_,$interface->{NAME}) foreach (@{$interface->{CONSTS}});
+ Typedef($_,$interface->{NAME}) foreach (@{$interface->{TYPEDEFS}});
+ Function($_,$interface->{NAME}) foreach (@{$interface->{FUNCTIONS}});
+}
+
+sub Enum($$$)
+{
+ my ($e,$name,$ifname) = @_;
+ my $valsstring = "$ifname\_$name\_vals";
+ my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+ return if (defined($conformance->{noemit}->{$dissectorname}));
+
+ foreach (@{$e->{ELEMENTS}}) {
+ if (/([^=]*)=(.*)/) {
+ pidl_hdr "#define $1 ($2)";
+ }
+ }
+
+ pidl_hdr "extern const value_string $valsstring\[];";
+ pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);";
+
+ pidl_def "const value_string ".$valsstring."[] = {";
+ foreach (@{$e->{ELEMENTS}}) {
+ next unless (/([^=]*)=(.*)/);
+ pidl_def "\t{ $1, \"$1\" },";
+ }
+
+ pidl_def "{ 0, NULL }";
+ pidl_def "};";
+
+ pidl_code "int";
+ pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param _U_)";
+ pidl_code "{";
+ indent;
+ pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, NULL);";
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+
+ my $enum_size = $e->{BASE_TYPE};
+ $enum_size =~ s/uint//g;
+ register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "VALS($valsstring)", $enum_size / 8);
+}
+
+sub Bitmap($$$)
+{
+ my ($e,$name,$ifname) = @_;
+ my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+
+ register_ett("ett_$ifname\_$name");
+
+
+ pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int hf_index, guint32 param);";
+
+ pidl_code "int";
+ pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+ pidl_code "{";
+ indent;
+ pidl_code "proto_item *item=NULL;";
+ pidl_code "proto_tree *tree=NULL;";
+ pidl_code "";
+
+ pidl_code "g$e->{BASE_TYPE} flags;";
+ if ($e->{ALIGN} > 1) {
+ pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+ }
+
+ pidl_code "";
+
+ pidl_code "if(parent_tree) {";
+ indent;
+ pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, $e->{ALIGN}, TRUE);";
+ pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);";
+ deindent;
+ pidl_code "}\n";
+
+ pidl_code "offset=dissect_ndr_$e->{BASE_TYPE}(tvb, offset, pinfo, NULL, drep, -1, &flags);";
+
+ foreach (@{$e->{ELEMENTS}}) {
+ next unless (/([^ ]*) (.*)/);
+ my ($en,$ev) = ($1,$2);
+ my $hf_bitname = "hf_$ifname\_$name\_$en";
+ my $filtername = "$ifname\.$name\.$en";
+
+ register_hf_field($hf_bitname, field2name($en), $filtername, "FT_BOOLEAN", $e->{ALIGN} * 8, "TFS(&$name\_$en\_tfs)", $ev, "");
+
+ pidl_def "static const true_false_string $name\_$en\_tfs = {";
+ pidl_def " \"$en is SET\",";
+ pidl_def " \"$en is NOT SET\",";
+ pidl_def "};";
+
+ pidl_code "proto_tree_add_boolean(tree, $hf_bitname, tvb, offset-$e->{ALIGN}, $e->{ALIGN}, flags);";
+ pidl_code "if (flags&$ev){";
+ pidl_code "\tproto_item_append_text(item,\"$en \");";
+ pidl_code "}";
+ pidl_code "flags&=(~$ev);";
+ pidl_code "";
+ }
+
+ pidl_code "if(flags){";
+ pidl_code "\tproto_item_append_text(item, \"UNKNOWN-FLAGS\");";
+ pidl_code "}\n";
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+
+ my $size = $e->{BASE_TYPE};
+ $size =~ s/uint//g;
+ register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", type2ft($e->{BASE_TYPE}), "BASE_DEC", "0", "NULL", $size/8);
+}
+
+sub ElementLevel($$$$$)
+{
+ my ($e,$l,$hf,$myname,$pn) = @_;
+
+ my $param = 0;
+
+ if (defined($conformance->{dissectorparams}->{$myname})) {
+ $param = $conformance->{dissectorparams}->{$myname};
+ }
+
+ if ($l->{TYPE} eq "POINTER") {
+ my $type;
+ if ($l->{LEVEL} eq "TOP") {
+ $type = "toplevel";
+ } elsif ($l->{LEVEL} eq "EMBEDDED") {
+ $type = "embedded";
+ }
+ pidl_code "offset=dissect_ndr_$type\_pointer(tvb,offset,pinfo,tree,drep,$myname\_,$ptrtype_mappings{$l->{POINTER_TYPE}},\"".field2name(StripPrefixes($e->{NAME})) . " (".StripPrefixes($e->{TYPE}).")\",$hf);";
+ } elsif ($l->{TYPE} eq "ARRAY") {
+
+ if ($l->{IS_INLINE}) {
+ warn ("Inline arrays not supported");
+ pidl_code "/* FIXME: Handle inline array */";
+ } elsif ($l->{IS_FIXED}) {
+ pidl_code "int i;";
+ pidl_code "for (i = 0; i < $l->{SIZE_IS}; i++)";
+ pidl_code "\toffset=$myname\_(tvb,offset,pinfo,tree,drep);";
+ } else {
+ my $af = "";
+ ($af = "ucarray") if ($l->{IS_CONFORMANT});
+ ($af = "uvarray") if ($l->{IS_VARYING});
+ ($af = "ucvarray") if ($l->{IS_CONFORMANT} and $l->{IS_VARYING});
+
+ pidl_code "offset=dissect_ndr_$af(tvb,offset,pinfo,tree,drep,$myname\_);";
+ }
+ } elsif ($l->{TYPE} eq "DATA") {
+ if ($l->{DATA_TYPE} eq "string") {
+ my $bs = 2; # Byte size defaults to that of UCS2
+
+
+ ($bs = 1) if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_ASCII.*"));
+
+ if (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*") and property_matches($e, "flag", ".*LIBNDR_FLAG_STR_LEN4.*")) {
+ pidl_code "offset=dissect_ndr_cvstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+ } elsif (property_matches($e, "flag", ".*LIBNDR_FLAG_STR_SIZE4.*")) {
+ pidl_code "offset=dissect_ndr_vstring(tvb,offset,pinfo,tree,drep,$bs,$hf,FALSE,NULL);";
+ } else {
+ warn("Unable to handle string with flags $e->{PROPERTIES}->{flag}");
+ }
+ } else {
+ my $call;
+
+ if (defined($types{$l->{DATA_TYPE}})) {
+ $call= $types{$l->{DATA_TYPE}}->{CALL};
+ } elsif ($conformance->{imports}->{$l->{DATA_TYPE}}) {
+ $call = $conformance->{imports}->{$l->{DATA_TYPE}};
+ } else {
+ warn("Unknown data type `$l->{DATA_TYPE}'");
+ pidl_code "/* FIXME: Handle unknown data type $l->{DATA_TYPE} */";
+ if ($l->{DATA_TYPE} =~ /^([a-z]+)\_(.*)$/)
+ {
+ pidl_code "offset=$1_dissect_$2(tvb,offset,pinfo,tree,drep,$hf,$param);";
+ }
+
+ return;
+ }
+
+ $call =~ s/\@HF\@/$hf/g;
+ $call =~ s/\@PARAM\@/$param/g;
+ pidl_code "$call";
+ }
+ } elsif ($_->{TYPE} eq "SUBCONTEXT") {
+ my $num_bits = ($l->{HEADER_SIZE}*8);
+ pidl_code "guint$num_bits size;";
+ pidl_code "int start_offset=offset;";
+ pidl_code "tvbuff_t *subtvb;";
+ pidl_code "offset=dissect_ndr_uint$num_bits(tvb,offset,pinfo,tree,drep,$hf,&size);";
+ pidl_code "proto_tree_add_text(tree,tvb,start_offset,offset-start_offset+size,\"Subcontext size\");";
+
+ pidl_code "subtvb = tvb_new_subset(tvb,offset,size,-1);";
+ pidl_code "$myname\_(subtvb,0,pinfo,tree,drep);";
+ } else {
+ die("Unknown type `$_->{TYPE}'");
+ }
+}
+
+sub Element($$$)
+{
+ my ($e,$pn,$ifname) = @_;
+
+ my $dissectorname = "$ifname\_dissect\_".StripPrefixes($pn)."\_".StripPrefixes($e->{NAME});
+
+ my $call_code = "offset=$dissectorname(tvb,offset,pinfo,tree,drep);";
+
+ my $hf = register_hf_field("hf_$ifname\_$pn\_$e->{NAME}", field2name($e->{NAME}), "$ifname.$pn.$e->{NAME}", type2ft($e->{TYPE}), "BASE_HEX", "NULL", 0, "");
+
+ if (defined($conformance->{noemit}->{$dissectorname})) {
+ return $call_code;
+ }
+
+ my $add = "";
+
+ foreach (@{$e->{LEVELS}}) {
+ next if ($_->{TYPE} eq "SWITCH");
+ pidl_def "static int $dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep);";
+ pidl_code "static int";
+ pidl_code "$dissectorname$add(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep)";
+ pidl_code "{";
+ indent;
+
+ ElementLevel($e,$_,$hf,$dissectorname.$add,$pn);
+
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+ $add.="_";
+ }
+
+ return $call_code;
+}
+
+sub Function($$$)
+{
+ my ($fn,$ifname) = @_;
+
+ my %dissectornames;
+
+ foreach (@{$fn->{ELEMENTS}}) {
+ $dissectornames{$_->{NAME}} = Element($_, $fn->{NAME}, $ifname)
+ }
+
+ my $fn_name = $_->{NAME};
+ $fn_name =~ s/^${ifname}_//;
+
+ PrintIdl DumpFunction($fn->{ORIGINAL});
+ pidl_code "static int";
+ pidl_code "$ifname\_dissect\_${fn_name}_response(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)";
+ pidl_code "{";
+ indent;
+ foreach (@{$fn->{ELEMENTS}}) {
+ if (grep(/out/,@{$_->{DIRECTION}})) {
+ pidl_code "$dissectornames{$_->{NAME}}";
+ pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
+ pidl_code "";
+ }
+ }
+
+ if (not defined($fn->{RETURN_TYPE})) {
+ } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
+ pidl_code "offset=dissect_ntstatus(tvb,offset,pinfo,tree,drep,hf\_$ifname\_status, NULL);";
+ } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
+ pidl_code "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,hf\_$ifname\_werror, NULL);";
+ }
+
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+
+ pidl_code "static int";
+ pidl_code "$ifname\_dissect\_${fn_name}_request(tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, guint8 *drep _U_)";
+ pidl_code "{";
+ indent;
+ foreach (@{$fn->{ELEMENTS}}) {
+ if (grep(/in/,@{$_->{DIRECTION}})) {
+ pidl_code "$dissectornames{$_->{NAME}}";
+ pidl_code "offset=dissect_deferred_pointers(pinfo,tvb,offset,drep);";
+ }
+
+ }
+
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+}
+
+sub Struct($$$)
+{
+ my ($e,$name,$ifname) = @_;
+ my $dissectorname = "$ifname\_dissect\_".StripPrefixes($name);
+
+ return if (defined($conformance->{noemit}->{$dissectorname}));
+
+ register_ett("ett_$ifname\_$name");
+
+ my $res = "";
+ ($res.="\t".Element($_, $name, $ifname)."\n\n") foreach (@{$e->{ELEMENTS}});
+
+ pidl_hdr "int $dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_);";
+
+ pidl_code "int";
+ pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+ pidl_code "{";
+ indent;
+ pidl_code "proto_item *item = NULL;";
+ pidl_code "proto_tree *tree = NULL;";
+ pidl_code "int old_offset;";
+ pidl_code "";
+
+ if ($e->{ALIGN} > 1) {
+ pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+ }
+ pidl_code "";
+
+ pidl_code "old_offset=offset;";
+ pidl_code "";
+ pidl_code "if(parent_tree){";
+ indent;
+ pidl_code "item=proto_tree_add_item(parent_tree, hf_index, tvb, offset, -1, TRUE);";
+ pidl_code "tree=proto_item_add_subtree(item, ett_$ifname\_$name);";
+ deindent;
+ pidl_code "}";
+
+ pidl_code "\n$res";
+
+ pidl_code "proto_item_set_len(item, offset-old_offset);";
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}\n";
+
+ register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
+}
+
+sub Union($$$)
+{
+ my ($e,$name,$ifname) = @_;
+
+ my $dissectorname = "$ifname\_dissect_".StripPrefixes($name);
+ return if (defined($conformance->{noemit}->{$dissectorname}));
+
+ register_ett("ett_$ifname\_$name");
+
+ my $res = "";
+ foreach (@{$e->{ELEMENTS}}) {
+ $res.="\n\t\t$_->{CASE}:\n";
+ if ($_->{TYPE} ne "EMPTY") {
+ $res.="\t\t\t".Element($_, $name, $ifname)."\n";
+ }
+ $res.="\t\tbreak;\n";
+ }
+
+ pidl_code "static int";
+ pidl_code "$dissectorname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree, guint8 *drep, int hf_index, guint32 param _U_)";
+ pidl_code "{";
+ indent;
+ pidl_code "proto_item *item=NULL;";
+ pidl_code "proto_tree *tree=NULL;";
+ pidl_code "int old_offset;";
+ pidl_code "g$e->{SWITCH_TYPE} level;";
+ pidl_code "";
+
+ if ($e->{ALIGN} > 1) {
+ pidl_code "ALIGN_TO_$e->{ALIGN}_BYTES;";
+ }
+
+ pidl_code "";
+
+ pidl_code "old_offset=offset;";
+ pidl_code "if(parent_tree){";
+ indent;
+ pidl_code "item=proto_tree_add_text(parent_tree,tvb,offset,-1,\"$name\");";
+ pidl_code "tree=proto_item_add_subtree(item,ett_$ifname\_$name);";
+ deindent;
+ pidl_code "}";
+
+ pidl_code "";
+
+ pidl_code "offset = dissect_ndr_$e->{SWITCH_TYPE}(tvb, offset, pinfo, tree, drep, hf_index, &level);";
+
+ pidl_code "switch(level) {$res\t}";
+ pidl_code "proto_item_set_len(item, offset-old_offset);";
+ pidl_code "return offset;";
+ deindent;
+ pidl_code "}";
+
+ register_type($name, "offset=$dissectorname(tvb,offset,pinfo,tree,drep,\@HF\@,\@PARAM\@);", "FT_NONE", "BASE_NONE", 0, "NULL", 0);
+}
+
+sub Const($$)
+{
+ my ($const,$ifname) = @_;
+
+ if (!defined($const->{ARRAY_LEN}[0])) {
+ pidl_hdr "#define $const->{NAME}\t( $const->{VALUE} )\n";
+ } else {
+ pidl_hdr "#define $const->{NAME}\t $const->{VALUE}\n";
+ }
+}
+
+sub Typedef($$)
+{
+ my ($e,$ifname) = @_;
+
+ PrintIdl DumpTypedef($e->{ORIGINAL});
+
+ {
+ ENUM => \&Enum,
+ STRUCT => \&Struct,
+ UNION => \&Union,
+ BITMAP => \&Bitmap
+ }->{$e->{DATA}->{TYPE}}->($e->{DATA}, $e->{NAME}, $ifname);
+}
+
+sub RegisterInterface($)
+{
+ my ($x) = @_;
+
+ pidl_code "void proto_register_dcerpc_$x->{NAME}(void)";
+ pidl_code "{";
+ indent;
+
+ $res{code}.=DumpHfList()."\n";
+ $res{code}.="\n".DumpEttList()."\n";
+
+ if (defined($x->{UUID})) {
+ # These can be changed to non-pidl_code names if the old dissectors
+ # in epan/dissctors are deleted.
+
+ my $name = "\"" . uc($x->{NAME}) . " (pidl)\"";
+ my $short_name = $x->{NAME};
+ my $filter_name = $x->{NAME};
+
+ if (has_property($x, "helpstring")) {
+ $name = $x->{PROPERTIES}->{helpstring};
+ }
+
+ if (defined($conformance->{protocols}->{$x->{NAME}})) {
+ $short_name = $conformance->{protocols}->{$x->{NAME}}->{SHORTNAME};
+ $name = $conformance->{protocols}->{$x->{NAME}}->{LONGNAME};
+ $filter_name = $conformance->{protocols}->{$x->{NAME}}->{FILTERNAME};
+ }
+
+ pidl_code "proto_dcerpc_$x->{NAME} = proto_register_protocol($name, \"$short_name\", \"$filter_name\");";
+
+ pidl_code "proto_register_field_array(proto_dcerpc_$x->{NAME}, hf, array_length (hf));";
+ pidl_code "proto_register_subtree_array(ett, array_length(ett));";
+ } else {
+ pidl_code "proto_dcerpc = proto_get_id_by_filter_name(\"dcerpc\");";
+ pidl_code "proto_register_field_array(proto_dcerpc, hf, array_length(hf));";
+ pidl_code "proto_register_subtree_array(ett, array_length(ett));";
+ }
+
+ deindent;
+ pidl_code "}\n";
+}
+
+sub RegisterInterfaceHandoff($)
+{
+ my $x = shift;
+ pidl_code "void proto_reg_handoff_dcerpc_$x->{NAME}(void)";
+ pidl_code "{";
+ indent;
+ pidl_code "dcerpc_init_uuid(proto_dcerpc_$x->{NAME}, ett_dcerpc_$x->{NAME},";
+ pidl_code "\t&uuid_dcerpc_$x->{NAME}, ver_dcerpc_$x->{NAME},";
+ pidl_code "\t$x->{NAME}_dissectors, hf_$x->{NAME}_opnum);";
+ deindent;
+ pidl_code "}";
+}
+
+sub ProcessInterface($)
+{
+ my ($x) = @_;
+
+ push(@{$conformance->{strip_prefixes}}, $x->{NAME});
+
+ my $define = "__PACKET_DCERPC_" . uc($_->{NAME}) . "_H";
+ pidl_hdr "#ifndef $define";
+ pidl_hdr "#define $define";
+ pidl_hdr "";
+
+ if (defined $x->{PROPERTIES}->{depends}) {
+ foreach (split / /, $x->{PROPERTIES}->{depends}) {
+ next if($_ eq "security");
+ pidl_hdr "#include \"packet-dcerpc-$_\.h\"\n";
+ }
+ }
+
+ pidl_def "static gint proto_dcerpc_$x->{NAME} = -1;";
+ register_ett("ett_dcerpc_$x->{NAME}");
+ register_hf_field("hf_$x->{NAME}_opnum", "Operation", "$x->{NAME}.opnum", "FT_UINT16", "BASE_DEC", "NULL", 0, "");
+ register_hf_field("hf_$x->{NAME}_status", "Status", "$x->{NAME}.status", "FT_UINT32", "BASE_HEX", "VALS(NT_errors)", 0, "");
+ register_hf_field("hf_$x->{NAME}_werror", "Windows Error", "$x->{NAME}.werror", "FT_UINT32", "BASE_HEX", "NULL", 0, "");
+
+ if (defined($x->{UUID})) {
+ my $if_uuid = $x->{UUID};
+
+ pidl_def "/* Version information */\n\n";
+
+ pidl_def "static e_uuid_t uuid_dcerpc_$x->{NAME} = {";
+ pidl_def "\t0x" . substr($if_uuid, 1, 8)
+ . ", 0x" . substr($if_uuid, 10, 4)
+ . ", 0x" . substr($if_uuid, 15, 4) . ",";
+ pidl_def "\t{ 0x" . substr($if_uuid, 20, 2)
+ . ", 0x" . substr($if_uuid, 22, 2)
+ . ", 0x" . substr($if_uuid, 25, 2)
+ . ", 0x" . substr($if_uuid, 27, 2)
+ . ", 0x" . substr($if_uuid, 29, 2)
+ . ", 0x" . substr($if_uuid, 31, 2)
+ . ", 0x" . substr($if_uuid, 33, 2)
+ . ", 0x" . substr($if_uuid, 35, 2) . " }";
+ pidl_def "};";
+
+ my $maj = $x->{VERSION};
+ $maj =~ s/\.(.*)$//g;
+ pidl_def "static guint16 ver_dcerpc_$x->{NAME} = $maj;";
+ pidl_def "";
+ }
+
+ Interface($x);
+
+ pidl_code "\n".DumpFunctionTable($x);
+
+ RegisterInterface($x);
+ RegisterInterfaceHandoff($x);
+
+ pidl_hdr "#endif /* $define */";
+}
+
+
+sub register_type($$$$$$$)
+{
+ my ($type,$call,$ft,$base,$mask,$vals,$length) = @_;
+
+ $types{$type} = {
+ TYPE => $type,
+ CALL => $call,
+ FT_TYPE => $ft,
+ BASE => $base,
+ MASK => $mask,
+ VALSSTRING => $vals,
+ LENGTH => $length
+ };
+}
+
+# Loads the default types
+sub Initialize($)
+{
+ my $cnf_file = shift;
+
+ $conformance = {};
+
+ ReadConformance($cnf_file, $conformance) or print "Warning: Not using conformance file `$cnf_file'\n";
+
+ foreach my $bytes (qw(1 2 4 8)) {
+ my $bits = $bytes * 8;
+ register_type("uint$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT$bits", "BASE_DEC", 0, "NULL", $bytes);
+ register_type("int$bits", "offset=dissect_ndr_uint$bits(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_INT$bits", "BASE_DEC", 0, "NULL", $bytes);
+ }
+
+ register_type("udlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);", "FT_UINT64", "BASE_DEC", 0, "NULL", 4);
+ register_type("bool8", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+ register_type("char", "offset=dissect_ndr_uint8(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT8", "BASE_DEC", 0, "NULL", 1);
+ register_type("long", "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT32", "BASE_DEC", 0, "NULL", 4);
+ register_type("dlong", "offset=dissect_ndr_duint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_INT64", "BASE_DEC", 0, "NULL", 8);
+ register_type("GUID", "offset=dissect_ndr_uuid_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_GUID", "BASE_NONE", 0, "NULL", 4);
+ register_type("policy_handle", "offset=dissect_nt_policy_hnd(tvb,offset,pinfo,tree,drep,\@HF\@,NULL,NULL,\@PARAM\@&0x01,\@PARAM\@&0x02);","FT_BYTES", "BASE_NONE", 0, "NULL", 4);
+ register_type("NTTIME", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+ register_type("NTTIME_hyper", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);","FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+ register_type("time_t", "offset=dissect_ndr_time_t(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_ABSOLUTE_TIME", "BASE_DEC", 0, "NULL", 4);
+ register_type("NTTIME_1sec", "offset=dissect_ndr_nt_NTTIME(tvb,offset,pinfo,tree,drep,\@HF\@);", "FT_ABSOLUTE_TIME", "BASE_NONE", 0, "NULL", 4);
+ register_type("SID", "
+ dcerpc_info *di = (dcerpc_info *)pinfo->private_data;
+
+ di->hf_index = \@HF\@;
+
+ offset=dissect_ndr_nt_SID_with_options(tvb,offset,pinfo,tree,drep,param);
+ ","FT_STRING", "BASE_DEC", 0, "NULL", 4);
+ register_type("WERROR",
+ "offset=dissect_ndr_uint32(tvb,offset,pinfo,tree,drep,\@HF\@,NULL);","FT_UINT32", "BASE_DEC", 0, "VALS(NT_errors)", 4);
+
+}
+
+#####################################################################
+# Generate ethereal parser and header code
+sub Parse($$)
+{
+ my($ndr,$h_filename,$cnf_file) = @_;
+ Initialize($cnf_file);
+
+ $tabs = "";
+
+ %res = (code=>"",def=>"",hdr=>"");
+
+ pidl_hdr "/* header auto-generated by pidl */";
+
+ $res{headers} = "\n";
+ $res{headers} .= "#ifdef HAVE_CONFIG_H\n";
+ $res{headers} .= "#include \"config.h\"\n";
+ $res{headers} .= "#endif\n\n";
+ $res{headers} .= "#include <glib.h>\n";
+ $res{headers} .= "#include <string.h>\n";
+ $res{headers} .= "#include <epan/packet.h>\n\n";
+
+ $res{headers} .= "#include \"packet-dcerpc.h\"\n";
+ $res{headers} .= "#include \"packet-dcerpc-nt.h\"\n";
+ $res{headers} .= "#include \"packet-windows-common.h\"\n";
+ $res{headers} .= "#include \"$h_filename\"\n";
+ pidl_code "";
+
+ # Ethereal protocol registration
+
+ ProcessInterface($_) foreach (@$ndr);
+
+ $res{ett} = DumpEttDeclaration();
+ $res{hf} = DumpHfDeclaration();
+
+ my $parser = "/* parser auto-generated by pidl */";
+ $parser.= $res{headers};
+ $parser.=$res{ett};
+ $parser.=$res{hf};
+ $parser.=$res{def};
+ $parser.=$conformance->{override};
+ $parser.=$res{code};
+
+ my $header = "/* autogenerated by pidl */\n\n";
+ $header.=$res{hdr};
+
+ return ($parser,$header);
+}
+
+###############################################################################
+# ETT
+###############################################################################
+
+my @ett = ();
+
+sub register_ett($)
+{
+ my $name = shift;
+
+ push (@ett, $name);
+}
+
+sub DumpEttList()
+{
+ my $res = "\tstatic gint *ett[] = {\n";
+ foreach (@ett) {
+ $res .= "\t\t&$_,\n";
+ }
+
+ return "$res\t};\n";
+}
+
+sub DumpEttDeclaration()
+{
+ my $res = "\n/* Ett declarations */\n";
+ foreach (@ett) {
+ $res .= "static gint $_ = -1;\n";
+ }
+
+ return "$res\n";
+}
+
+###############################################################################
+# HF
+###############################################################################
+
+my %hf = ();
+
+sub register_hf_field($$$$$$$$)
+{
+ my ($index,$name,$filter_name,$ft_type,$base_type,$valsstring,$mask,$blurb) = @_;
+
+ return $conformance->{hf_renames}->{$index} if defined ($conformance->{hf_renames}->{$index});
+
+ $hf{$index} = {
+ INDEX => $index,
+ NAME => $name,
+ FILTER => $filter_name,
+ FT_TYPE => $ft_type,
+ BASE_TYPE => $base_type,
+ VALS => $valsstring,
+ MASK => $mask,
+ BLURB => $blurb
+ };
+
+ return $index;
+}
+
+sub DumpHfDeclaration()
+{
+ my $res = "";
+
+ $res = "\n/* Header field declarations */\n";
+
+ foreach (keys %hf)
+ {
+ $res .= "static gint $_ = -1;\n";
+ }
+
+ return "$res\n";
+}
+
+sub DumpHfList()
+{
+ my $res = "\tstatic hf_register_info hf[] = {\n";
+
+ foreach (values %hf)
+ {
+ $res .= "\t{ &$_->{INDEX},
+ { \"$_->{NAME}\", \"$_->{FILTER}\", $_->{FT_TYPE}, $_->{BASE_TYPE}, $_->{VALS}, $_->{MASK}, \"$_->{BLURB}\", HFILL }},
+";
+ }
+
+ return $res."\t};\n";
+}
+
+
+###############################################################################
+# Function table
+###############################################################################
+
+sub DumpFunctionTable($)
+{
+ my $if = shift;
+
+ my $res = "static dcerpc_sub_dissector $if->{NAME}\_dissectors[] = {\n";
+ foreach (@{$if->{FUNCTIONS}}) {
+ my $fn_name = $_->{NAME};
+ $fn_name =~ s/^$if->{NAME}_//;
+ $res.= "\t{ $_->{OPNUM}, \"$fn_name\",\n";
+ $res.= "\t $if->{NAME}_dissect_${fn_name}_request, $if->{NAME}_dissect_${fn_name}_response},\n";
+ }
+
+ $res .= "\t{ 0, NULL, NULL, NULL }\n";
+
+ return "$res};\n";
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/IDL.pm b/source4/pidl/Parse/Pidl/IDL.pm
new file mode 100644
index 0000000000..7f7e5bcdca
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/IDL.pm
@@ -0,0 +1,2609 @@
+####################################################################
+#
+# This file was generated using Parse::Yapp version 1.05.
+#
+# Don't edit this file, use source file instead.
+#
+# ANY CHANGE MADE HERE WILL BE LOST !
+#
+####################################################################
+package Parse::Pidl::IDL;
+use vars qw ( @ISA );
+use strict;
+
+@ISA= qw ( Parse::Yapp::Driver );
+#Included Parse/Yapp/Driver.pm file----------------------------------------
+{
+#
+# Module Parse::Yapp::Driver
+#
+# This module is part of the Parse::Yapp package available on your
+# nearest CPAN
+#
+# Any use of this module in a standalone parser make the included
+# text under the same copyright as the Parse::Yapp module itself.
+#
+# This notice should remain unchanged.
+#
+# (c) Copyright 1998-2001 Francois Desarmenien, all rights reserved.
+# (see the pod text in Parse::Yapp module for use and distribution rights)
+#
+
+package Parse::Yapp::Driver;
+
+require 5.004;
+
+use strict;
+
+use vars qw ( $VERSION $COMPATIBLE $FILENAME );
+
+$VERSION = '1.05';
+$COMPATIBLE = '0.07';
+$FILENAME=__FILE__;
+
+use Carp;
+
+#Known parameters, all starting with YY (leading YY will be discarded)
+my(%params)=(YYLEX => 'CODE', 'YYERROR' => 'CODE', YYVERSION => '',
+ YYRULES => 'ARRAY', YYSTATES => 'ARRAY', YYDEBUG => '');
+#Mandatory parameters
+my(@params)=('LEX','RULES','STATES');
+
+sub new {
+ my($class)=shift;
+ my($errst,$nberr,$token,$value,$check,$dotpos);
+ my($self)={ ERROR => \&_Error,
+ ERRST => \$errst,
+ NBERR => \$nberr,
+ TOKEN => \$token,
+ VALUE => \$value,
+ DOTPOS => \$dotpos,
+ STACK => [],
+ DEBUG => 0,
+ CHECK => \$check };
+
+ _CheckParams( [], \%params, \@_, $self );
+
+ exists($$self{VERSION})
+ and $$self{VERSION} < $COMPATIBLE
+ and croak "Yapp driver version $VERSION ".
+ "incompatible with version $$self{VERSION}:\n".
+ "Please recompile parser module.";
+
+ ref($class)
+ and $class=ref($class);
+
+ bless($self,$class);
+}
+
+sub YYParse {
+ my($self)=shift;
+ my($retval);
+
+ _CheckParams( \@params, \%params, \@_, $self );
+
+ if($$self{DEBUG}) {
+ _DBLoad();
+ $retval = eval '$self->_DBParse()';#Do not create stab entry on compile
+ $@ and die $@;
+ }
+ else {
+ $retval = $self->_Parse();
+ }
+ $retval
+}
+
+sub YYData {
+ my($self)=shift;
+
+ exists($$self{USER})
+ or $$self{USER}={};
+
+ $$self{USER};
+
+}
+
+sub YYErrok {
+ my($self)=shift;
+
+ ${$$self{ERRST}}=0;
+ undef;
+}
+
+sub YYNberr {
+ my($self)=shift;
+
+ ${$$self{NBERR}};
+}
+
+sub YYRecovering {
+ my($self)=shift;
+
+ ${$$self{ERRST}} != 0;
+}
+
+sub YYAbort {
+ my($self)=shift;
+
+ ${$$self{CHECK}}='ABORT';
+ undef;
+}
+
+sub YYAccept {
+ my($self)=shift;
+
+ ${$$self{CHECK}}='ACCEPT';
+ undef;
+}
+
+sub YYError {
+ my($self)=shift;
+
+ ${$$self{CHECK}}='ERROR';
+ undef;
+}
+
+sub YYSemval {
+ my($self)=shift;
+ my($index)= $_[0] - ${$$self{DOTPOS}} - 1;
+
+ $index < 0
+ and -$index <= @{$$self{STACK}}
+ and return $$self{STACK}[$index][1];
+
+ undef; #Invalid index
+}
+
+sub YYCurtok {
+ my($self)=shift;
+
+ @_
+ and ${$$self{TOKEN}}=$_[0];
+ ${$$self{TOKEN}};
+}
+
+sub YYCurval {
+ my($self)=shift;
+
+ @_
+ and ${$$self{VALUE}}=$_[0];
+ ${$$self{VALUE}};
+}
+
+sub YYExpect {
+ my($self)=shift;
+
+ keys %{$self->{STATES}[$self->{STACK}[-1][0]]{ACTIONS}}
+}
+
+sub YYLexer {
+ my($self)=shift;
+
+ $$self{LEX};
+}
+
+
+#################
+# Private stuff #
+#################
+
+
+sub _CheckParams {
+ my($mandatory,$checklist,$inarray,$outhash)=@_;
+ my($prm,$value);
+ my($prmlst)={};
+
+ while(($prm,$value)=splice(@$inarray,0,2)) {
+ $prm=uc($prm);
+ exists($$checklist{$prm})
+ or croak("Unknow parameter '$prm'");
+ ref($value) eq $$checklist{$prm}
+ or croak("Invalid value for parameter '$prm'");
+ $prm=unpack('@2A*',$prm);
+ $$outhash{$prm}=$value;
+ }
+ for (@$mandatory) {
+ exists($$outhash{$_})
+ or croak("Missing mandatory parameter '".lc($_)."'");
+ }
+}
+
+sub _Error {
+ print "Parse error.\n";
+}
+
+sub _DBLoad {
+ {
+ no strict 'refs';
+
+ exists(${__PACKAGE__.'::'}{_DBParse})#Already loaded ?
+ and return;
+ }
+ my($fname)=__FILE__;
+ my(@drv);
+ open(DRV,"<$fname") or die "Report this as a BUG: Cannot open $fname";
+ while(<DRV>) {
+ /^\s*sub\s+_Parse\s*{\s*$/ .. /^\s*}\s*#\s*_Parse\s*$/
+ and do {
+ s/^#DBG>//;
+ push(@drv,$_);
+ }
+ }
+ close(DRV);
+
+ $drv[0]=~s/_P/_DBP/;
+ eval join('',@drv);
+}
+
+#Note that for loading debugging version of the driver,
+#this file will be parsed from 'sub _Parse' up to '}#_Parse' inclusive.
+#So, DO NOT remove comment at end of sub !!!
+sub _Parse {
+ my($self)=shift;
+
+ my($rules,$states,$lex,$error)
+ = @$self{ 'RULES', 'STATES', 'LEX', 'ERROR' };
+ my($errstatus,$nberror,$token,$value,$stack,$check,$dotpos)
+ = @$self{ 'ERRST', 'NBERR', 'TOKEN', 'VALUE', 'STACK', 'CHECK', 'DOTPOS' };
+
+#DBG> my($debug)=$$self{DEBUG};
+#DBG> my($dbgerror)=0;
+
+#DBG> my($ShowCurToken) = sub {
+#DBG> my($tok)='>';
+#DBG> for (split('',$$token)) {
+#DBG> $tok.= (ord($_) < 32 or ord($_) > 126)
+#DBG> ? sprintf('<%02X>',ord($_))
+#DBG> : $_;
+#DBG> }
+#DBG> $tok.='<';
+#DBG> };
+
+ $$errstatus=0;
+ $$nberror=0;
+ ($$token,$$value)=(undef,undef);
+ @$stack=( [ 0, undef ] );
+ $$check='';
+
+ while(1) {
+ my($actions,$act,$stateno);
+
+ $stateno=$$stack[-1][0];
+ $actions=$$states[$stateno];
+
+#DBG> print STDERR ('-' x 40),"\n";
+#DBG> $debug & 0x2
+#DBG> and print STDERR "In state $stateno:\n";
+#DBG> $debug & 0x08
+#DBG> and print STDERR "Stack:[".
+#DBG> join(',',map { $$_[0] } @$stack).
+#DBG> "]\n";
+
+
+ if (exists($$actions{ACTIONS})) {
+
+ defined($$token)
+ or do {
+ ($$token,$$value)=&$lex($self);
+#DBG> $debug & 0x01
+#DBG> and print STDERR "Need token. Got ".&$ShowCurToken."\n";
+ };
+
+ $act= exists($$actions{ACTIONS}{$$token})
+ ? $$actions{ACTIONS}{$$token}
+ : exists($$actions{DEFAULT})
+ ? $$actions{DEFAULT}
+ : undef;
+ }
+ else {
+ $act=$$actions{DEFAULT};
+#DBG> $debug & 0x01
+#DBG> and print STDERR "Don't need token.\n";
+ }
+
+ defined($act)
+ and do {
+
+ $act > 0
+ and do { #shift
+
+#DBG> $debug & 0x04
+#DBG> and print STDERR "Shift and go to state $act.\n";
+
+ $$errstatus
+ and do {
+ --$$errstatus;
+
+#DBG> $debug & 0x10
+#DBG> and $dbgerror
+#DBG> and $$errstatus == 0
+#DBG> and do {
+#DBG> print STDERR "**End of Error recovery.\n";
+#DBG> $dbgerror=0;
+#DBG> };
+ };
+
+
+ push(@$stack,[ $act, $$value ]);
+
+ $$token ne '' #Don't eat the eof
+ and $$token=$$value=undef;
+ next;
+ };
+
+ #reduce
+ my($lhs,$len,$code,@sempar,$semval);
+ ($lhs,$len,$code)=@{$$rules[-$act]};
+
+#DBG> $debug & 0x04
+#DBG> and $act
+#DBG> and print STDERR "Reduce using rule ".-$act." ($lhs,$len): ";
+
+ $act
+ or $self->YYAccept();
+
+ $$dotpos=$len;
+
+ unpack('A1',$lhs) eq '@' #In line rule
+ and do {
+ $lhs =~ /^\@[0-9]+\-([0-9]+)$/
+ or die "In line rule name '$lhs' ill formed: ".
+ "report it as a BUG.\n";
+ $$dotpos = $1;
+ };
+
+ @sempar = $$dotpos
+ ? map { $$_[1] } @$stack[ -$$dotpos .. -1 ]
+ : ();
+
+ $semval = $code ? &$code( $self, @sempar )
+ : @sempar ? $sempar[0] : undef;
+
+ splice(@$stack,-$len,$len);
+
+ $$check eq 'ACCEPT'
+ and do {
+
+#DBG> $debug & 0x04
+#DBG> and print STDERR "Accept.\n";
+
+ return($semval);
+ };
+
+ $$check eq 'ABORT'
+ and do {
+
+#DBG> $debug & 0x04
+#DBG> and print STDERR "Abort.\n";
+
+ return(undef);
+
+ };
+
+#DBG> $debug & 0x04
+#DBG> and print STDERR "Back to state $$stack[-1][0], then ";
+
+ $$check eq 'ERROR'
+ or do {
+#DBG> $debug & 0x04
+#DBG> and print STDERR
+#DBG> "go to state $$states[$$stack[-1][0]]{GOTOS}{$lhs}.\n";
+
+#DBG> $debug & 0x10
+#DBG> and $dbgerror
+#DBG> and $$errstatus == 0
+#DBG> and do {
+#DBG> print STDERR "**End of Error recovery.\n";
+#DBG> $dbgerror=0;
+#DBG> };
+
+ push(@$stack,
+ [ $$states[$$stack[-1][0]]{GOTOS}{$lhs}, $semval ]);
+ $$check='';
+ next;
+ };
+
+#DBG> $debug & 0x04
+#DBG> and print STDERR "Forced Error recovery.\n";
+
+ $$check='';
+
+ };
+
+ #Error
+ $$errstatus
+ or do {
+
+ $$errstatus = 1;
+ &$error($self);
+ $$errstatus # if 0, then YYErrok has been called
+ or next; # so continue parsing
+
+#DBG> $debug & 0x10
+#DBG> and do {
+#DBG> print STDERR "**Entering Error recovery.\n";
+#DBG> ++$dbgerror;
+#DBG> };
+
+ ++$$nberror;
+
+ };
+
+ $$errstatus == 3 #The next token is not valid: discard it
+ and do {
+ $$token eq '' # End of input: no hope
+ and do {
+#DBG> $debug & 0x10
+#DBG> and print STDERR "**At eof: aborting.\n";
+ return(undef);
+ };
+
+#DBG> $debug & 0x10
+#DBG> and print STDERR "**Dicard invalid token ".&$ShowCurToken.".\n";
+
+ $$token=$$value=undef;
+ };
+
+ $$errstatus=3;
+
+ while( @$stack
+ and ( not exists($$states[$$stack[-1][0]]{ACTIONS})
+ or not exists($$states[$$stack[-1][0]]{ACTIONS}{error})
+ or $$states[$$stack[-1][0]]{ACTIONS}{error} <= 0)) {
+
+#DBG> $debug & 0x10
+#DBG> and print STDERR "**Pop state $$stack[-1][0].\n";
+
+ pop(@$stack);
+ }
+
+ @$stack
+ or do {
+
+#DBG> $debug & 0x10
+#DBG> and print STDERR "**No state left on stack: aborting.\n";
+
+ return(undef);
+ };
+
+ #shift the error token
+
+#DBG> $debug & 0x10
+#DBG> and print STDERR "**Shift \$error token and go to state ".
+#DBG> $$states[$$stack[-1][0]]{ACTIONS}{error}.
+#DBG> ".\n";
+
+ push(@$stack, [ $$states[$$stack[-1][0]]{ACTIONS}{error}, undef ]);
+
+ }
+
+ #never reached
+ croak("Error in driver logic. Please, report it as a BUG");
+
+}#_Parse
+#DO NOT remove comment
+
+1;
+
+}
+#End of include--------------------------------------------------
+
+
+
+
+sub new {
+ my($class)=shift;
+ ref($class)
+ and $class=ref($class);
+
+ my($self)=$class->SUPER::new( yyversion => '1.05',
+ yystates =>
+[
+ {#State 0
+ DEFAULT => -1,
+ GOTOS => {
+ 'idl' => 1
+ }
+ },
+ {#State 1
+ ACTIONS => {
+ '' => 2
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'interface' => 3,
+ 'coclass' => 4,
+ 'property_list' => 5
+ }
+ },
+ {#State 2
+ DEFAULT => 0
+ },
+ {#State 3
+ DEFAULT => -2
+ },
+ {#State 4
+ DEFAULT => -3
+ },
+ {#State 5
+ ACTIONS => {
+ "coclass" => 6,
+ "interface" => 8,
+ "[" => 7
+ }
+ },
+ {#State 6
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 10
+ }
+ },
+ {#State 7
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 11,
+ 'properties' => 13,
+ 'property' => 12
+ }
+ },
+ {#State 8
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 14
+ }
+ },
+ {#State 9
+ DEFAULT => -89
+ },
+ {#State 10
+ ACTIONS => {
+ "{" => 15
+ }
+ },
+ {#State 11
+ ACTIONS => {
+ "(" => 16
+ },
+ DEFAULT => -67
+ },
+ {#State 12
+ DEFAULT => -65
+ },
+ {#State 13
+ ACTIONS => {
+ "," => 17,
+ "]" => 18
+ }
+ },
+ {#State 14
+ ACTIONS => {
+ ":" => 19
+ },
+ DEFAULT => -8,
+ GOTOS => {
+ 'base_interface' => 20
+ }
+ },
+ {#State 15
+ DEFAULT => -5,
+ GOTOS => {
+ 'interface_names' => 21
+ }
+ },
+ {#State 16
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'listtext' => 26,
+ 'anytext' => 25,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 17
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 11,
+ 'property' => 29
+ }
+ },
+ {#State 18
+ DEFAULT => -64
+ },
+ {#State 19
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 30
+ }
+ },
+ {#State 20
+ ACTIONS => {
+ "{" => 31
+ }
+ },
+ {#State 21
+ ACTIONS => {
+ "}" => 32,
+ "interface" => 33
+ }
+ },
+ {#State 22
+ DEFAULT => -93
+ },
+ {#State 23
+ DEFAULT => -74
+ },
+ {#State 24
+ DEFAULT => -76
+ },
+ {#State 25
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -69
+ },
+ {#State 26
+ ACTIONS => {
+ "," => 46,
+ ")" => 47
+ }
+ },
+ {#State 27
+ DEFAULT => -75
+ },
+ {#State 28
+ DEFAULT => -92
+ },
+ {#State 29
+ DEFAULT => -66
+ },
+ {#State 30
+ DEFAULT => -9
+ },
+ {#State 31
+ ACTIONS => {
+ "typedef" => 48,
+ "union" => 49,
+ "enum" => 62,
+ "bitmap" => 63,
+ "declare" => 55,
+ "const" => 57,
+ "struct" => 60
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'typedecl' => 61,
+ 'function' => 50,
+ 'bitmap' => 64,
+ 'definitions' => 51,
+ 'definition' => 54,
+ 'property_list' => 53,
+ 'usertype' => 52,
+ 'declare' => 66,
+ 'const' => 65,
+ 'struct' => 56,
+ 'enum' => 58,
+ 'typedef' => 59,
+ 'union' => 67
+ }
+ },
+ {#State 32
+ ACTIONS => {
+ ";" => 68
+ },
+ DEFAULT => -94,
+ GOTOS => {
+ 'optional_semicolon' => 69
+ }
+ },
+ {#State 33
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 70
+ }
+ },
+ {#State 34
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 71,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 35
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 72,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 36
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 73,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 37
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 74,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 38
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 75,
+ 'text' => 24,
+ 'constant' => 27,
+ 'commalisttext' => 76
+ }
+ },
+ {#State 39
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 77,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 40
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 78,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 41
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 75,
+ 'text' => 24,
+ 'constant' => 27,
+ 'commalisttext' => 79
+ }
+ },
+ {#State 42
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 80,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 43
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 81,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 44
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 82,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 45
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 83,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 46
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 84,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 47
+ DEFAULT => -68
+ },
+ {#State 48
+ DEFAULT => -63,
+ GOTOS => {
+ 'property_list' => 85
+ }
+ },
+ {#State 49
+ ACTIONS => {
+ 'IDENTIFIER' => 86
+ },
+ DEFAULT => -91,
+ GOTOS => {
+ 'optional_identifier' => 87
+ }
+ },
+ {#State 50
+ DEFAULT => -12
+ },
+ {#State 51
+ ACTIONS => {
+ "}" => 88,
+ "typedef" => 48,
+ "union" => 49,
+ "enum" => 62,
+ "bitmap" => 63,
+ "declare" => 55,
+ "const" => 57,
+ "struct" => 60
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'typedecl' => 61,
+ 'function' => 50,
+ 'bitmap' => 64,
+ 'definition' => 89,
+ 'property_list' => 53,
+ 'usertype' => 52,
+ 'const' => 65,
+ 'struct' => 56,
+ 'declare' => 66,
+ 'enum' => 58,
+ 'typedef' => 59,
+ 'union' => 67
+ }
+ },
+ {#State 52
+ ACTIONS => {
+ ";" => 90
+ }
+ },
+ {#State 53
+ ACTIONS => {
+ 'IDENTIFIER' => 9,
+ "union" => 49,
+ "enum" => 62,
+ "bitmap" => 63,
+ "[" => 7,
+ 'void' => 91,
+ "struct" => 60
+ },
+ GOTOS => {
+ 'identifier' => 93,
+ 'struct' => 56,
+ 'enum' => 58,
+ 'type' => 94,
+ 'union' => 67,
+ 'bitmap' => 64,
+ 'usertype' => 92
+ }
+ },
+ {#State 54
+ DEFAULT => -10
+ },
+ {#State 55
+ DEFAULT => -63,
+ GOTOS => {
+ 'property_list' => 95
+ }
+ },
+ {#State 56
+ DEFAULT => -26
+ },
+ {#State 57
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 96
+ }
+ },
+ {#State 58
+ DEFAULT => -28
+ },
+ {#State 59
+ DEFAULT => -14
+ },
+ {#State 60
+ ACTIONS => {
+ 'IDENTIFIER' => 86
+ },
+ DEFAULT => -91,
+ GOTOS => {
+ 'optional_identifier' => 97
+ }
+ },
+ {#State 61
+ DEFAULT => -16
+ },
+ {#State 62
+ ACTIONS => {
+ 'IDENTIFIER' => 86
+ },
+ DEFAULT => -91,
+ GOTOS => {
+ 'optional_identifier' => 98
+ }
+ },
+ {#State 63
+ ACTIONS => {
+ 'IDENTIFIER' => 86
+ },
+ DEFAULT => -91,
+ GOTOS => {
+ 'optional_identifier' => 99
+ }
+ },
+ {#State 64
+ DEFAULT => -29
+ },
+ {#State 65
+ DEFAULT => -13
+ },
+ {#State 66
+ DEFAULT => -15
+ },
+ {#State 67
+ DEFAULT => -27
+ },
+ {#State 68
+ DEFAULT => -95
+ },
+ {#State 69
+ DEFAULT => -4
+ },
+ {#State 70
+ ACTIONS => {
+ ";" => 100
+ }
+ },
+ {#State 71
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -77
+ },
+ {#State 72
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "*" => 43,
+ "{" => 38,
+ "&" => 39,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -81
+ },
+ {#State 73
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "*" => 43,
+ "{" => 38,
+ "&" => 39,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -86
+ },
+ {#State 74
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -85
+ },
+ {#State 75
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "*" => 43,
+ "{" => 38,
+ "&" => 39,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -71
+ },
+ {#State 76
+ ACTIONS => {
+ "}" => 101,
+ "," => 102
+ }
+ },
+ {#State 77
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -83
+ },
+ {#State 78
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -84
+ },
+ {#State 79
+ ACTIONS => {
+ "," => 102,
+ ")" => 103
+ }
+ },
+ {#State 80
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -82
+ },
+ {#State 81
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -79
+ },
+ {#State 82
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -78
+ },
+ {#State 83
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -80
+ },
+ {#State 84
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -70
+ },
+ {#State 85
+ ACTIONS => {
+ 'IDENTIFIER' => 9,
+ "union" => 49,
+ "enum" => 62,
+ "bitmap" => 63,
+ "[" => 7,
+ 'void' => 91,
+ "struct" => 60
+ },
+ GOTOS => {
+ 'identifier' => 93,
+ 'struct' => 56,
+ 'enum' => 58,
+ 'type' => 104,
+ 'union' => 67,
+ 'bitmap' => 64,
+ 'usertype' => 92
+ }
+ },
+ {#State 86
+ DEFAULT => -90
+ },
+ {#State 87
+ ACTIONS => {
+ "{" => 105
+ }
+ },
+ {#State 88
+ ACTIONS => {
+ ";" => 68
+ },
+ DEFAULT => -94,
+ GOTOS => {
+ 'optional_semicolon' => 106
+ }
+ },
+ {#State 89
+ DEFAULT => -11
+ },
+ {#State 90
+ DEFAULT => -30
+ },
+ {#State 91
+ DEFAULT => -33
+ },
+ {#State 92
+ DEFAULT => -31
+ },
+ {#State 93
+ DEFAULT => -32
+ },
+ {#State 94
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 107
+ }
+ },
+ {#State 95
+ ACTIONS => {
+ "enum" => 111,
+ "bitmap" => 112,
+ "[" => 7
+ },
+ GOTOS => {
+ 'decl_enum' => 108,
+ 'decl_bitmap' => 109,
+ 'decl_type' => 110
+ }
+ },
+ {#State 96
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 113
+ }
+ },
+ {#State 97
+ ACTIONS => {
+ "{" => 114
+ }
+ },
+ {#State 98
+ ACTIONS => {
+ "{" => 115
+ }
+ },
+ {#State 99
+ ACTIONS => {
+ "{" => 116
+ }
+ },
+ {#State 100
+ DEFAULT => -6
+ },
+ {#State 101
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 117,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 102
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 118,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 103
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 119,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 104
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 120
+ }
+ },
+ {#State 105
+ DEFAULT => -48,
+ GOTOS => {
+ 'union_elements' => 121
+ }
+ },
+ {#State 106
+ DEFAULT => -7
+ },
+ {#State 107
+ ACTIONS => {
+ "(" => 122
+ }
+ },
+ {#State 108
+ DEFAULT => -21
+ },
+ {#State 109
+ DEFAULT => -22
+ },
+ {#State 110
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 123
+ }
+ },
+ {#State 111
+ DEFAULT => -23
+ },
+ {#State 112
+ DEFAULT => -24
+ },
+ {#State 113
+ ACTIONS => {
+ "[" => 124,
+ "=" => 126
+ },
+ GOTOS => {
+ 'array_len' => 125
+ }
+ },
+ {#State 114
+ DEFAULT => -54,
+ GOTOS => {
+ 'element_list1' => 127
+ }
+ },
+ {#State 115
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 128,
+ 'enum_element' => 129,
+ 'enum_elements' => 130
+ }
+ },
+ {#State 116
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 133,
+ 'bitmap_elements' => 132,
+ 'bitmap_element' => 131
+ }
+ },
+ {#State 117
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "*" => 43,
+ "{" => 38,
+ "&" => 39,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -88
+ },
+ {#State 118
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "*" => 43,
+ "{" => 38,
+ "&" => 39,
+ "/" => 40,
+ "(" => 41,
+ "|" => 42,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -72
+ },
+ {#State 119
+ ACTIONS => {
+ "<" => 35,
+ "~" => 36,
+ "{" => 38
+ },
+ DEFAULT => -87
+ },
+ {#State 120
+ ACTIONS => {
+ "[" => 124
+ },
+ DEFAULT => -60,
+ GOTOS => {
+ 'array_len' => 134
+ }
+ },
+ {#State 121
+ ACTIONS => {
+ "}" => 135
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'optional_base_element' => 137,
+ 'property_list' => 136
+ }
+ },
+ {#State 122
+ ACTIONS => {
+ "," => -56,
+ "void" => 141,
+ ")" => -56
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'base_element' => 138,
+ 'element_list2' => 140,
+ 'property_list' => 139
+ }
+ },
+ {#State 123
+ ACTIONS => {
+ ";" => 142
+ }
+ },
+ {#State 124
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ "]" => 143,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 144,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 125
+ ACTIONS => {
+ "=" => 145
+ }
+ },
+ {#State 126
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 146,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 127
+ ACTIONS => {
+ "}" => 147
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'base_element' => 148,
+ 'property_list' => 139
+ }
+ },
+ {#State 128
+ ACTIONS => {
+ "=" => 149
+ },
+ DEFAULT => -37
+ },
+ {#State 129
+ DEFAULT => -35
+ },
+ {#State 130
+ ACTIONS => {
+ "}" => 150,
+ "," => 151
+ }
+ },
+ {#State 131
+ DEFAULT => -40
+ },
+ {#State 132
+ ACTIONS => {
+ "}" => 152,
+ "," => 153
+ }
+ },
+ {#State 133
+ ACTIONS => {
+ "=" => 154
+ }
+ },
+ {#State 134
+ ACTIONS => {
+ ";" => 155
+ }
+ },
+ {#State 135
+ DEFAULT => -50
+ },
+ {#State 136
+ ACTIONS => {
+ "[" => 7
+ },
+ DEFAULT => -63,
+ GOTOS => {
+ 'base_or_empty' => 156,
+ 'base_element' => 157,
+ 'empty_element' => 158,
+ 'property_list' => 159
+ }
+ },
+ {#State 137
+ DEFAULT => -49
+ },
+ {#State 138
+ DEFAULT => -58
+ },
+ {#State 139
+ ACTIONS => {
+ 'IDENTIFIER' => 9,
+ "union" => 49,
+ "enum" => 62,
+ "bitmap" => 63,
+ "[" => 7,
+ 'void' => 91,
+ "struct" => 60
+ },
+ GOTOS => {
+ 'identifier' => 93,
+ 'struct' => 56,
+ 'enum' => 58,
+ 'type' => 160,
+ 'union' => 67,
+ 'bitmap' => 64,
+ 'usertype' => 92
+ }
+ },
+ {#State 140
+ ACTIONS => {
+ "," => 161,
+ ")" => 162
+ }
+ },
+ {#State 141
+ DEFAULT => -57
+ },
+ {#State 142
+ DEFAULT => -20
+ },
+ {#State 143
+ ACTIONS => {
+ "[" => 124
+ },
+ DEFAULT => -60,
+ GOTOS => {
+ 'array_len' => 163
+ }
+ },
+ {#State 144
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ "]" => 164,
+ ">" => 45
+ }
+ },
+ {#State 145
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 165,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 146
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ ";" => 166,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ }
+ },
+ {#State 147
+ DEFAULT => -43
+ },
+ {#State 148
+ ACTIONS => {
+ ";" => 167
+ }
+ },
+ {#State 149
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 168,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 150
+ DEFAULT => -34
+ },
+ {#State 151
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 128,
+ 'enum_element' => 169
+ }
+ },
+ {#State 152
+ DEFAULT => -39
+ },
+ {#State 153
+ ACTIONS => {
+ 'IDENTIFIER' => 9
+ },
+ GOTOS => {
+ 'identifier' => 133,
+ 'bitmap_element' => 170
+ }
+ },
+ {#State 154
+ ACTIONS => {
+ 'CONSTANT' => 28,
+ 'TEXT' => 22,
+ 'IDENTIFIER' => 9
+ },
+ DEFAULT => -73,
+ GOTOS => {
+ 'identifier' => 23,
+ 'anytext' => 171,
+ 'text' => 24,
+ 'constant' => 27
+ }
+ },
+ {#State 155
+ DEFAULT => -25
+ },
+ {#State 156
+ DEFAULT => -47
+ },
+ {#State 157
+ ACTIONS => {
+ ";" => 172
+ }
+ },
+ {#State 158
+ DEFAULT => -46
+ },
+ {#State 159
+ ACTIONS => {
+ 'IDENTIFIER' => 9,
+ "union" => 49,
+ ";" => 173,
+ "enum" => 62,
+ "bitmap" => 63,
+ 'void' => 91,
+ "[" => 7,
+ "struct" => 60
+ },
+ GOTOS => {
+ 'identifier' => 93,
+ 'struct' => 56,
+ 'enum' => 58,
+ 'type' => 160,
+ 'union' => 67,
+ 'bitmap' => 64,
+ 'usertype' => 92
+ }
+ },
+ {#State 160
+ DEFAULT => -52,
+ GOTOS => {
+ 'pointers' => 174
+ }
+ },
+ {#State 161
+ DEFAULT => -63,
+ GOTOS => {
+ 'base_element' => 175,
+ 'property_list' => 139
+ }
+ },
+ {#State 162
+ ACTIONS => {
+ ";" => 176
+ }
+ },
+ {#State 163
+ DEFAULT => -61
+ },
+ {#State 164
+ ACTIONS => {
+ "[" => 124
+ },
+ DEFAULT => -60,
+ GOTOS => {
+ 'array_len' => 177
+ }
+ },
+ {#State 165
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ ";" => 178,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ }
+ },
+ {#State 166
+ DEFAULT => -17
+ },
+ {#State 167
+ DEFAULT => -55
+ },
+ {#State 168
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -38
+ },
+ {#State 169
+ DEFAULT => -36
+ },
+ {#State 170
+ DEFAULT => -41
+ },
+ {#State 171
+ ACTIONS => {
+ "-" => 34,
+ "<" => 35,
+ "+" => 37,
+ "~" => 36,
+ "&" => 39,
+ "{" => 38,
+ "/" => 40,
+ "|" => 42,
+ "(" => 41,
+ "*" => 43,
+ "." => 44,
+ ">" => 45
+ },
+ DEFAULT => -42
+ },
+ {#State 172
+ DEFAULT => -45
+ },
+ {#State 173
+ DEFAULT => -44
+ },
+ {#State 174
+ ACTIONS => {
+ 'IDENTIFIER' => 9,
+ "*" => 180
+ },
+ GOTOS => {
+ 'identifier' => 179
+ }
+ },
+ {#State 175
+ DEFAULT => -59
+ },
+ {#State 176
+ DEFAULT => -19
+ },
+ {#State 177
+ DEFAULT => -62
+ },
+ {#State 178
+ DEFAULT => -18
+ },
+ {#State 179
+ ACTIONS => {
+ "[" => 124
+ },
+ DEFAULT => -60,
+ GOTOS => {
+ 'array_len' => 181
+ }
+ },
+ {#State 180
+ DEFAULT => -53
+ },
+ {#State 181
+ DEFAULT => -51
+ }
+],
+ yyrules =>
+[
+ [#Rule 0
+ '$start', 2, undef
+ ],
+ [#Rule 1
+ 'idl', 0, undef
+ ],
+ [#Rule 2
+ 'idl', 2,
+sub
+#line 19 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 3
+ 'idl', 2,
+sub
+#line 20 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 4
+ 'coclass', 7,
+sub
+#line 24 "build/pidl/idl.yp"
+{$_[3] => {
+ "TYPE" => "COCLASS",
+ "PROPERTIES" => $_[1],
+ "NAME" => $_[3],
+ "DATA" => $_[5],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 5
+ 'interface_names', 0, undef
+ ],
+ [#Rule 6
+ 'interface_names', 4,
+sub
+#line 36 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 7
+ 'interface', 8,
+sub
+#line 40 "build/pidl/idl.yp"
+{$_[3] => {
+ "TYPE" => "INTERFACE",
+ "PROPERTIES" => $_[1],
+ "NAME" => $_[3],
+ "BASE" => $_[4],
+ "DATA" => $_[6],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 8
+ 'base_interface', 0, undef
+ ],
+ [#Rule 9
+ 'base_interface', 2,
+sub
+#line 53 "build/pidl/idl.yp"
+{ $_[2] }
+ ],
+ [#Rule 10
+ 'definitions', 1,
+sub
+#line 57 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+ ],
+ [#Rule 11
+ 'definitions', 2,
+sub
+#line 58 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 12
+ 'definition', 1, undef
+ ],
+ [#Rule 13
+ 'definition', 1, undef
+ ],
+ [#Rule 14
+ 'definition', 1, undef
+ ],
+ [#Rule 15
+ 'definition', 1, undef
+ ],
+ [#Rule 16
+ 'definition', 1, undef
+ ],
+ [#Rule 17
+ 'const', 6,
+sub
+#line 66 "build/pidl/idl.yp"
+{{
+ "TYPE" => "CONST",
+ "DTYPE" => $_[2],
+ "NAME" => $_[3],
+ "VALUE" => $_[5],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 18
+ 'const', 7,
+sub
+#line 75 "build/pidl/idl.yp"
+{{
+ "TYPE" => "CONST",
+ "DTYPE" => $_[2],
+ "NAME" => $_[3],
+ "ARRAY_LEN" => $_[4],
+ "VALUE" => $_[6],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 19
+ 'function', 7,
+sub
+#line 88 "build/pidl/idl.yp"
+{{
+ "TYPE" => "FUNCTION",
+ "NAME" => $_[3],
+ "RETURN_TYPE" => $_[2],
+ "PROPERTIES" => $_[1],
+ "ELEMENTS" => $_[5],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 20
+ 'declare', 5,
+sub
+#line 100 "build/pidl/idl.yp"
+{{
+ "TYPE" => "DECLARE",
+ "PROPERTIES" => $_[2],
+ "NAME" => $_[4],
+ "DATA" => $_[3],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 21
+ 'decl_type', 1, undef
+ ],
+ [#Rule 22
+ 'decl_type', 1, undef
+ ],
+ [#Rule 23
+ 'decl_enum', 1,
+sub
+#line 114 "build/pidl/idl.yp"
+{{
+ "TYPE" => "ENUM"
+ }}
+ ],
+ [#Rule 24
+ 'decl_bitmap', 1,
+sub
+#line 120 "build/pidl/idl.yp"
+{{
+ "TYPE" => "BITMAP"
+ }}
+ ],
+ [#Rule 25
+ 'typedef', 6,
+sub
+#line 126 "build/pidl/idl.yp"
+{{
+ "TYPE" => "TYPEDEF",
+ "PROPERTIES" => $_[2],
+ "NAME" => $_[4],
+ "DATA" => $_[3],
+ "ARRAY_LEN" => $_[5],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 26
+ 'usertype', 1, undef
+ ],
+ [#Rule 27
+ 'usertype', 1, undef
+ ],
+ [#Rule 28
+ 'usertype', 1, undef
+ ],
+ [#Rule 29
+ 'usertype', 1, undef
+ ],
+ [#Rule 30
+ 'typedecl', 2,
+sub
+#line 139 "build/pidl/idl.yp"
+{ $_[1] }
+ ],
+ [#Rule 31
+ 'type', 1, undef
+ ],
+ [#Rule 32
+ 'type', 1, undef
+ ],
+ [#Rule 33
+ 'type', 1,
+sub
+#line 142 "build/pidl/idl.yp"
+{ "void" }
+ ],
+ [#Rule 34
+ 'enum', 5,
+sub
+#line 146 "build/pidl/idl.yp"
+{{
+ "TYPE" => "ENUM",
+ "NAME" => $_[2],
+ "ELEMENTS" => $_[4]
+ }}
+ ],
+ [#Rule 35
+ 'enum_elements', 1,
+sub
+#line 154 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+ ],
+ [#Rule 36
+ 'enum_elements', 3,
+sub
+#line 155 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+ ],
+ [#Rule 37
+ 'enum_element', 1, undef
+ ],
+ [#Rule 38
+ 'enum_element', 3,
+sub
+#line 159 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 39
+ 'bitmap', 5,
+sub
+#line 163 "build/pidl/idl.yp"
+{{
+ "TYPE" => "BITMAP",
+ "NAME" => $_[2],
+ "ELEMENTS" => $_[4]
+ }}
+ ],
+ [#Rule 40
+ 'bitmap_elements', 1,
+sub
+#line 171 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+ ],
+ [#Rule 41
+ 'bitmap_elements', 3,
+sub
+#line 172 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+ ],
+ [#Rule 42
+ 'bitmap_element', 3,
+sub
+#line 175 "build/pidl/idl.yp"
+{ "$_[1] ( $_[3] )" }
+ ],
+ [#Rule 43
+ 'struct', 5,
+sub
+#line 179 "build/pidl/idl.yp"
+{{
+ "TYPE" => "STRUCT",
+ "NAME" => $_[2],
+ "ELEMENTS" => $_[4]
+ }}
+ ],
+ [#Rule 44
+ 'empty_element', 2,
+sub
+#line 187 "build/pidl/idl.yp"
+{{
+ "NAME" => "",
+ "TYPE" => "EMPTY",
+ "PROPERTIES" => $_[1],
+ "POINTERS" => 0,
+ "ARRAY_LEN" => [],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 45
+ 'base_or_empty', 2, undef
+ ],
+ [#Rule 46
+ 'base_or_empty', 1, undef
+ ],
+ [#Rule 47
+ 'optional_base_element', 2,
+sub
+#line 201 "build/pidl/idl.yp"
+{ $_[2]->{PROPERTIES} = Parse::Pidl::Util::FlattenHash([$_[1],$_[2]->{PROPERTIES}]); $_[2] }
+ ],
+ [#Rule 48
+ 'union_elements', 0, undef
+ ],
+ [#Rule 49
+ 'union_elements', 2,
+sub
+#line 206 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 50
+ 'union', 5,
+sub
+#line 210 "build/pidl/idl.yp"
+{{
+ "TYPE" => "UNION",
+ "NAME" => $_[2],
+ "ELEMENTS" => $_[4]
+ }}
+ ],
+ [#Rule 51
+ 'base_element', 5,
+sub
+#line 218 "build/pidl/idl.yp"
+{{
+ "NAME" => $_[4],
+ "TYPE" => $_[2],
+ "PROPERTIES" => $_[1],
+ "POINTERS" => $_[3],
+ "ARRAY_LEN" => $_[5],
+ "FILE" => $_[0]->YYData->{INPUT_FILENAME},
+ "LINE" => $_[0]->YYData->{LINE},
+ }}
+ ],
+ [#Rule 52
+ 'pointers', 0,
+sub
+#line 232 "build/pidl/idl.yp"
+{ 0 }
+ ],
+ [#Rule 53
+ 'pointers', 2,
+sub
+#line 233 "build/pidl/idl.yp"
+{ $_[1]+1 }
+ ],
+ [#Rule 54
+ 'element_list1', 0, undef
+ ],
+ [#Rule 55
+ 'element_list1', 3,
+sub
+#line 238 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[2]); $_[1] }
+ ],
+ [#Rule 56
+ 'element_list2', 0, undef
+ ],
+ [#Rule 57
+ 'element_list2', 1, undef
+ ],
+ [#Rule 58
+ 'element_list2', 1,
+sub
+#line 244 "build/pidl/idl.yp"
+{ [ $_[1] ] }
+ ],
+ [#Rule 59
+ 'element_list2', 3,
+sub
+#line 245 "build/pidl/idl.yp"
+{ push(@{$_[1]}, $_[3]); $_[1] }
+ ],
+ [#Rule 60
+ 'array_len', 0, undef
+ ],
+ [#Rule 61
+ 'array_len', 3,
+sub
+#line 250 "build/pidl/idl.yp"
+{ push(@{$_[3]}, "*"); $_[3] }
+ ],
+ [#Rule 62
+ 'array_len', 4,
+sub
+#line 251 "build/pidl/idl.yp"
+{ push(@{$_[4]}, "$_[2]"); $_[4] }
+ ],
+ [#Rule 63
+ 'property_list', 0, undef
+ ],
+ [#Rule 64
+ 'property_list', 4,
+sub
+#line 257 "build/pidl/idl.yp"
+{ Parse::Pidl::Util::FlattenHash([$_[1],$_[3]]); }
+ ],
+ [#Rule 65
+ 'properties', 1,
+sub
+#line 260 "build/pidl/idl.yp"
+{ $_[1] }
+ ],
+ [#Rule 66
+ 'properties', 3,
+sub
+#line 261 "build/pidl/idl.yp"
+{ Parse::Pidl::Util::FlattenHash([$_[1], $_[3]]); }
+ ],
+ [#Rule 67
+ 'property', 1,
+sub
+#line 264 "build/pidl/idl.yp"
+{{ "$_[1]" => "1" }}
+ ],
+ [#Rule 68
+ 'property', 4,
+sub
+#line 265 "build/pidl/idl.yp"
+{{ "$_[1]" => "$_[3]" }}
+ ],
+ [#Rule 69
+ 'listtext', 1, undef
+ ],
+ [#Rule 70
+ 'listtext', 3,
+sub
+#line 270 "build/pidl/idl.yp"
+{ "$_[1] $_[3]" }
+ ],
+ [#Rule 71
+ 'commalisttext', 1, undef
+ ],
+ [#Rule 72
+ 'commalisttext', 3,
+sub
+#line 275 "build/pidl/idl.yp"
+{ "$_[1],$_[3]" }
+ ],
+ [#Rule 73
+ 'anytext', 0,
+sub
+#line 279 "build/pidl/idl.yp"
+{ "" }
+ ],
+ [#Rule 74
+ 'anytext', 1, undef
+ ],
+ [#Rule 75
+ 'anytext', 1, undef
+ ],
+ [#Rule 76
+ 'anytext', 1, undef
+ ],
+ [#Rule 77
+ 'anytext', 3,
+sub
+#line 281 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 78
+ 'anytext', 3,
+sub
+#line 282 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 79
+ 'anytext', 3,
+sub
+#line 283 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 80
+ 'anytext', 3,
+sub
+#line 284 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 81
+ 'anytext', 3,
+sub
+#line 285 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 82
+ 'anytext', 3,
+sub
+#line 286 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 83
+ 'anytext', 3,
+sub
+#line 287 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 84
+ 'anytext', 3,
+sub
+#line 288 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 85
+ 'anytext', 3,
+sub
+#line 289 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 86
+ 'anytext', 3,
+sub
+#line 290 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]" }
+ ],
+ [#Rule 87
+ 'anytext', 5,
+sub
+#line 291 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]$_[4]$_[5]" }
+ ],
+ [#Rule 88
+ 'anytext', 5,
+sub
+#line 292 "build/pidl/idl.yp"
+{ "$_[1]$_[2]$_[3]$_[4]$_[5]" }
+ ],
+ [#Rule 89
+ 'identifier', 1, undef
+ ],
+ [#Rule 90
+ 'optional_identifier', 1, undef
+ ],
+ [#Rule 91
+ 'optional_identifier', 0, undef
+ ],
+ [#Rule 92
+ 'constant', 1, undef
+ ],
+ [#Rule 93
+ 'text', 1,
+sub
+#line 306 "build/pidl/idl.yp"
+{ "\"$_[1]\"" }
+ ],
+ [#Rule 94
+ 'optional_semicolon', 0, undef
+ ],
+ [#Rule 95
+ 'optional_semicolon', 1, undef
+ ]
+],
+ @_);
+ bless($self,$class);
+}
+
+#line 317 "build/pidl/idl.yp"
+
+
+use Parse::Pidl::Util;
+
+#####################################################################
+# traverse a perl data structure removing any empty arrays or
+# hashes and any hash elements that map to undef
+sub CleanData($)
+{
+ sub CleanData($);
+ my($v) = shift;
+ if (ref($v) eq "ARRAY") {
+ foreach my $i (0 .. $#{$v}) {
+ CleanData($v->[$i]);
+ if (ref($v->[$i]) eq "ARRAY" && $#{$v->[$i]}==-1) {
+ $v->[$i] = undef;
+ next;
+ }
+ }
+ # this removes any undefined elements from the array
+ @{$v} = grep { defined $_ } @{$v};
+ } elsif (ref($v) eq "HASH") {
+ foreach my $x (keys %{$v}) {
+ CleanData($v->{$x});
+ if (!defined $v->{$x}) { delete($v->{$x}); next; }
+ if (ref($v->{$x}) eq "ARRAY" && $#{$v->{$x}}==-1) { delete($v->{$x}); next; }
+ }
+ }
+ return $v;
+}
+
+sub _Error {
+ if (exists $_[0]->YYData->{ERRMSG}) {
+ print $_[0]->YYData->{ERRMSG};
+ delete $_[0]->YYData->{ERRMSG};
+ return;
+ };
+ my $line = $_[0]->YYData->{LINE};
+ my $last_token = $_[0]->YYData->{LAST_TOKEN};
+ my $file = $_[0]->YYData->{INPUT_FILENAME};
+
+ print "$file:$line: Syntax error near '$last_token'\n";
+}
+
+sub _Lexer($)
+{
+ my($parser)=shift;
+
+ $parser->YYData->{INPUT} or return('',undef);
+
+again:
+ $parser->YYData->{INPUT} =~ s/^[ \t]*//;
+
+ for ($parser->YYData->{INPUT}) {
+ if (/^\#/) {
+ if (s/^\# (\d+) \"(.*?)\"( \d+|)//) {
+ $parser->YYData->{LINE} = $1-1;
+ $parser->YYData->{INPUT_FILENAME} = $2;
+ goto again;
+ }
+ if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) {
+ $parser->YYData->{LINE} = $1-1;
+ $parser->YYData->{INPUT_FILENAME} = $2;
+ goto again;
+ }
+ if (s/^(\#.*)$//m) {
+ goto again;
+ }
+ }
+ if (s/^(\n)//) {
+ $parser->YYData->{LINE}++;
+ goto again;
+ }
+ if (s/^\"(.*?)\"//) {
+ $parser->YYData->{LAST_TOKEN} = $1;
+ return('TEXT',$1);
+ }
+ if (s/^(\d+)(\W|$)/$2/) {
+ $parser->YYData->{LAST_TOKEN} = $1;
+ return('CONSTANT',$1);
+ }
+ if (s/^([\w_]+)//) {
+ $parser->YYData->{LAST_TOKEN} = $1;
+ if ($1 =~
+ /^(coclass|interface|const|typedef|declare|union
+ |struct|enum|bitmap|void)$/x) {
+ return $1;
+ }
+ return('IDENTIFIER',$1);
+ }
+ if (s/^(.)//s) {
+ $parser->YYData->{LAST_TOKEN} = $1;
+ return($1,$1);
+ }
+ }
+}
+
+sub parse_idl($$)
+{
+ my ($self,$filename) = @_;
+
+ my $saved_delim = $/;
+ undef $/;
+ my $cpp = $ENV{CPP};
+ if (! defined $cpp) {
+ $cpp = "cpp"
+ }
+ my $data = `$cpp -D__PIDL__ -xc $filename`;
+ $/ = $saved_delim;
+
+ $self->YYData->{INPUT} = $data;
+ $self->YYData->{LINE} = 0;
+ $self->YYData->{LAST_TOKEN} = "NONE";
+
+ my $idl = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
+
+ return CleanData($idl);
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/NDR.pm b/source4/pidl/Parse/Pidl/NDR.pm
new file mode 100644
index 0000000000..e00a0c9828
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/NDR.pm
@@ -0,0 +1,967 @@
+###################################################
+# Samba4 NDR info tree generator
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# released under the GNU GPL
+
+package Parse::Pidl::NDR;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred);
+
+use strict;
+use Parse::Pidl::Typelist qw(hasType getType);
+use Parse::Pidl::Util qw(has_property property_matches);
+
+sub nonfatal($$)
+{
+ my ($e,$s) = @_;
+ warn ("$e->{FILE}:$e->{LINE}: Warning: $s\n");
+}
+
+#####################################################################
+# signal a fatal validation error
+sub fatal($$)
+{
+ my ($pos,$s) = @_;
+ die("$pos->{FILE}:$pos->{LINE}:$s\n");
+}
+
+#####################################################################
+# return a table describing the order in which the parts of an element
+# should be parsed
+# Possible level types:
+# - POINTER
+# - ARRAY
+# - SUBCONTEXT
+# - SWITCH
+# - DATA
+sub GetElementLevelTable($)
+{
+ my $e = shift;
+
+ my $order = [];
+ my $is_deferred = 0;
+ my @bracket_array = ();
+ my @length_is = ();
+ my @size_is = ();
+
+ if (has_property($e, "size_is")) {
+ @size_is = split /,/, has_property($e, "size_is");
+ }
+
+ if (has_property($e, "length_is")) {
+ @length_is = split /,/, has_property($e, "length_is");
+ }
+
+ if (defined($e->{ARRAY_LEN})) {
+ @bracket_array = @{$e->{ARRAY_LEN}};
+ }
+
+ # Parse the [][][][] style array stuff
+ foreach my $d (@bracket_array) {
+ my $size = $d;
+ my $length = $d;
+ my $is_surrounding = 0;
+ my $is_varying = 0;
+ my $is_conformant = 0;
+ my $is_string = 0;
+
+ if ($d eq "*") {
+ $is_conformant = 1;
+ if ($size = shift @size_is) {
+ } elsif ((scalar(@size_is) == 0) and has_property($e, "string")) {
+ $is_string = 1;
+ delete($e->{PROPERTIES}->{string});
+ } else {
+ print "$e->{FILE}:$e->{LINE}: Must specify size_is() for conformant array!\n";
+ exit 1;
+ }
+
+ if (($length = shift @length_is) or $is_string) {
+ $is_varying = 1;
+ } else {
+ $length = $size;
+ }
+
+ if ($e == $e->{PARENT}->{ELEMENTS}[-1]
+ and $e->{PARENT}->{TYPE} ne "FUNCTION") {
+ $is_surrounding = 1;
+ }
+ }
+
+ push (@$order, {
+ TYPE => "ARRAY",
+ SIZE_IS => $size,
+ LENGTH_IS => $length,
+ IS_DEFERRED => "$is_deferred",
+ IS_SURROUNDING => "$is_surrounding",
+ IS_ZERO_TERMINATED => "$is_string",
+ IS_VARYING => "$is_varying",
+ IS_CONFORMANT => "$is_conformant",
+ IS_FIXED => (not $is_conformant and Parse::Pidl::Util::is_constant($size)),
+ IS_INLINE => (not $is_conformant and not Parse::Pidl::Util::is_constant($size))
+ });
+ }
+
+ # Next, all the pointers
+ foreach my $i (1..$e->{POINTERS}) {
+ my $pt = pointer_type($e);
+
+ my $level = "EMBEDDED";
+ # Top level "ref" pointers do not have a referrent identifier
+ $level = "TOP" if ( defined($pt)
+ and $i == 1
+ and $e->{PARENT}->{TYPE} eq "FUNCTION");
+
+ push (@$order, {
+ TYPE => "POINTER",
+ # for now, there can only be one pointer type per element
+ POINTER_TYPE => pointer_type($e),
+ IS_DEFERRED => "$is_deferred",
+ LEVEL => $level
+ });
+
+ # everything that follows will be deferred
+ $is_deferred = 1 if ($e->{PARENT}->{TYPE} ne "FUNCTION");
+
+ my $array_size = shift @size_is;
+ my $array_length;
+ my $is_varying;
+ my $is_conformant;
+ my $is_string = 0;
+ if ($array_size) {
+ $is_conformant = 1;
+ if ($array_length = shift @length_is) {
+ $is_varying = 1;
+ } else {
+ $array_length = $array_size;
+ $is_varying =0;
+ }
+ }
+
+ if (scalar(@size_is) == 0 and has_property($e, "string")) {
+ $is_string = 1;
+ $is_varying = $is_conformant = has_property($e, "noheader")?0:1;
+ delete($e->{PROPERTIES}->{string});
+ }
+
+ if ($array_size or $is_string) {
+ push (@$order, {
+ TYPE => "ARRAY",
+ IS_ZERO_TERMINATED => "$is_string",
+ SIZE_IS => $array_size,
+ LENGTH_IS => $array_length,
+ IS_DEFERRED => "$is_deferred",
+ IS_SURROUNDING => 0,
+ IS_VARYING => "$is_varying",
+ IS_CONFORMANT => "$is_conformant",
+ IS_FIXED => 0,
+ IS_INLINE => 0,
+ });
+
+ $is_deferred = 0;
+ }
+ }
+
+ if (defined(has_property($e, "subcontext"))) {
+ my $hdr_size = has_property($e, "subcontext");
+ my $subsize = has_property($e, "subcontext_size");
+ if (not defined($subsize)) {
+ $subsize = -1;
+ }
+
+ push (@$order, {
+ TYPE => "SUBCONTEXT",
+ HEADER_SIZE => $hdr_size,
+ SUBCONTEXT_SIZE => $subsize,
+ IS_DEFERRED => $is_deferred,
+ COMPRESSION => has_property($e, "compression"),
+ OBFUSCATION => has_property($e, "obfuscation")
+ });
+ }
+
+ if (my $switch = has_property($e, "switch_is")) {
+ push (@$order, {
+ TYPE => "SWITCH",
+ SWITCH_IS => $switch,
+ IS_DEFERRED => $is_deferred
+ });
+ }
+
+ if (scalar(@size_is) > 0) {
+ nonfatal($e, "size_is() on non-array element");
+ }
+
+ if (scalar(@length_is) > 0) {
+ nonfatal($e, "length_is() on non-array element");
+ }
+
+ if (has_property($e, "string")) {
+ nonfatal($e, "string() attribute on non-array element");
+ }
+
+ push (@$order, {
+ TYPE => "DATA",
+ DATA_TYPE => $e->{TYPE},
+ IS_DEFERRED => $is_deferred,
+ CONTAINS_DEFERRED => can_contain_deferred($e),
+ IS_SURROUNDING => 0 #FIXME
+ });
+
+ my $i = 0;
+ foreach (@$order) { $_->{LEVEL_INDEX} = $i; $i+=1; }
+
+ return $order;
+}
+
+#####################################################################
+# see if a type contains any deferred data
+sub can_contain_deferred
+{
+ my $e = shift;
+
+ return 0 if (Parse::Pidl::Typelist::is_scalar($e->{TYPE}));
+ return 1 unless (hasType($e->{TYPE})); # assume the worst
+
+ my $type = getType($e->{TYPE});
+
+ foreach my $x (@{$type->{DATA}->{ELEMENTS}}) {
+ return 1 if ($x->{POINTERS});
+ return 1 if (can_contain_deferred ($x));
+ }
+
+ return 0;
+}
+
+sub pointer_type($)
+{
+ my $e = shift;
+
+ return undef unless $e->{POINTERS};
+
+ return "ref" if (has_property($e, "ref"));
+ return "ptr" if (has_property($e, "ptr"));
+ return "sptr" if (has_property($e, "sptr"));
+ return "unique" if (has_property($e, "unique"));
+ return "relative" if (has_property($e, "relative"));
+ return "ignore" if (has_property($e, "ignore"));
+
+ return undef;
+}
+
+#####################################################################
+# work out the correct alignment for a structure or union
+sub find_largest_alignment($)
+{
+ my $s = shift;
+
+ my $align = 1;
+ for my $e (@{$s->{ELEMENTS}}) {
+ my $a = 1;
+
+ if ($e->{POINTERS}) {
+ $a = 4;
+ } elsif (has_property($e, "subcontext")){
+ $a = 1;
+ } else {
+ $a = align_type($e->{TYPE});
+ }
+
+ $align = $a if ($align < $a);
+ }
+
+ return $align;
+}
+
+#####################################################################
+# align a type
+sub align_type
+{
+ my $e = shift;
+
+ unless (hasType($e)) {
+ # it must be an external type - all we can do is guess
+ # print "Warning: assuming alignment of unknown type '$e' is 4\n";
+ return 4;
+ }
+
+ my $dt = getType($e)->{DATA};
+
+ if ($dt->{TYPE} eq "ENUM") {
+ return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
+ } elsif ($dt->{TYPE} eq "BITMAP") {
+ return align_type(Parse::Pidl::Typelist::bitmap_type_fn($dt));
+ } elsif (($dt->{TYPE} eq "STRUCT") or ($dt->{TYPE} eq "UNION")) {
+ return find_largest_alignment($dt);
+ } elsif ($dt->{TYPE} eq "SCALAR") {
+ return Parse::Pidl::Typelist::getScalarAlignment($dt->{NAME});
+ }
+
+ die("Unknown data type type $dt->{TYPE}");
+}
+
+sub ParseElement($)
+{
+ my $e = shift;
+
+ return {
+ NAME => $e->{NAME},
+ TYPE => $e->{TYPE},
+ PROPERTIES => $e->{PROPERTIES},
+ LEVELS => GetElementLevelTable($e),
+ ALIGN => align_type($e->{TYPE}),
+ ORIGINAL => $e
+ };
+}
+
+sub ParseStruct($)
+{
+ my $struct = shift;
+ my @elements = ();
+ my $surrounding = undef;
+
+ foreach my $x (@{$struct->{ELEMENTS}})
+ {
+ push @elements, ParseElement($x);
+ }
+
+ my $e = $elements[-1];
+ if (defined($e) and defined($e->{LEVELS}[0]->{IS_SURROUNDING}) and
+ $e->{LEVELS}[0]->{IS_SURROUNDING}) {
+ $surrounding = $e;
+ }
+
+ if (defined $e->{TYPE} && $e->{TYPE} eq "string"
+ && property_matches($e, "flag", ".*LIBNDR_FLAG_STR_CONFORMANT.*")) {
+ $surrounding = $struct->{ELEMENTS}[-1];
+ }
+
+ return {
+ TYPE => "STRUCT",
+ SURROUNDING_ELEMENT => $surrounding,
+ ELEMENTS => \@elements,
+ PROPERTIES => $struct->{PROPERTIES},
+ ORIGINAL => $struct
+ };
+}
+
+sub ParseUnion($)
+{
+ my $e = shift;
+ my @elements = ();
+ my $switch_type = has_property($e, "switch_type");
+ unless (defined($switch_type)) { $switch_type = "uint32"; }
+
+ if (has_property($e, "nodiscriminant")) { $switch_type = undef; }
+
+ foreach my $x (@{$e->{ELEMENTS}})
+ {
+ my $t;
+ if ($x->{TYPE} eq "EMPTY") {
+ $t = { TYPE => "EMPTY" };
+ } else {
+ $t = ParseElement($x);
+ }
+ if (has_property($x, "default")) {
+ $t->{CASE} = "default";
+ } elsif (defined($x->{PROPERTIES}->{case})) {
+ $t->{CASE} = "case $x->{PROPERTIES}->{case}";
+ } else {
+ die("Union element $x->{NAME} has neither default nor case property");
+ }
+ push @elements, $t;
+ }
+
+ return {
+ TYPE => "UNION",
+ SWITCH_TYPE => $switch_type,
+ ELEMENTS => \@elements,
+ PROPERTIES => $e->{PROPERTIES},
+ ORIGINAL => $e
+ };
+}
+
+sub ParseEnum($)
+{
+ my $e = shift;
+
+ return {
+ TYPE => "ENUM",
+ BASE_TYPE => Parse::Pidl::Typelist::enum_type_fn($e),
+ ELEMENTS => $e->{ELEMENTS},
+ PROPERTIES => $e->{PROPERTIES},
+ ORIGINAL => $e
+ };
+}
+
+sub ParseBitmap($)
+{
+ my $e = shift;
+
+ return {
+ TYPE => "BITMAP",
+ BASE_TYPE => Parse::Pidl::Typelist::bitmap_type_fn($e),
+ ELEMENTS => $e->{ELEMENTS},
+ PROPERTIES => $e->{PROPERTIES},
+ ORIGINAL => $e
+ };
+}
+
+sub ParseTypedef($$)
+{
+ my ($ndr,$d) = @_;
+ my $data;
+
+ if ($d->{DATA}->{TYPE} eq "STRUCT" or $d->{DATA}->{TYPE} eq "UNION") {
+ CheckPointerTypes($d->{DATA}, $ndr->{PROPERTIES}->{pointer_default});
+ }
+
+ if (defined($d->{PROPERTIES}) && !defined($d->{DATA}->{PROPERTIES})) {
+ $d->{DATA}->{PROPERTIES} = $d->{PROPERTIES};
+ }
+
+ $data = {
+ STRUCT => \&ParseStruct,
+ UNION => \&ParseUnion,
+ ENUM => \&ParseEnum,
+ BITMAP => \&ParseBitmap
+ }->{$d->{DATA}->{TYPE}}->($d->{DATA});
+
+ $data->{ALIGN} = align_type($d->{NAME});
+
+ return {
+ NAME => $d->{NAME},
+ TYPE => $d->{TYPE},
+ PROPERTIES => $d->{PROPERTIES},
+ DATA => $data,
+ ORIGINAL => $d
+ };
+}
+
+sub ParseConst($$)
+{
+ my ($ndr,$d) = @_;
+
+ return $d;
+}
+
+sub ParseFunction($$$)
+{
+ my ($ndr,$d,$opnum) = @_;
+ my @elements = ();
+ my $rettype = undef;
+ my $thisopnum = undef;
+
+ CheckPointerTypes($d, $ndr->{PROPERTIES}->{pointer_default_top});
+
+ if (not defined($d->{PROPERTIES}{noopnum})) {
+ $thisopnum = ${$opnum};
+ ${$opnum}++;
+ }
+
+ foreach my $x (@{$d->{ELEMENTS}}) {
+ my $e = ParseElement($x);
+ push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in"));
+ push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out"));
+ push (@elements, $e);
+ }
+
+ if ($d->{RETURN_TYPE} ne "void") {
+ $rettype = $d->{RETURN_TYPE};
+ }
+
+ return {
+ NAME => $d->{NAME},
+ TYPE => "FUNCTION",
+ OPNUM => $thisopnum,
+ RETURN_TYPE => $rettype,
+ PROPERTIES => $d->{PROPERTIES},
+ ELEMENTS => \@elements,
+ ORIGINAL => $d
+ };
+}
+
+sub CheckPointerTypes($$)
+{
+ my $s = shift;
+ my $default = shift;
+
+ foreach my $e (@{$s->{ELEMENTS}}) {
+ if ($e->{POINTERS} and not defined(pointer_type($e))) {
+ $e->{PROPERTIES}->{$default} = 1;
+ }
+ }
+}
+
+sub ParseInterface($)
+{
+ my $idl = shift;
+ my @typedefs = ();
+ my @consts = ();
+ my @functions = ();
+ my @endpoints;
+ my @declares = ();
+ my $opnum = 0;
+ my $version;
+
+ if (not has_property($idl, "pointer_default")) {
+ # MIDL defaults to "ptr" in DCE compatible mode (/osf)
+ # and "unique" in Microsoft Extensions mode (default)
+ $idl->{PROPERTIES}->{pointer_default} = "unique";
+ }
+
+ if (not has_property($idl, "pointer_default_top")) {
+ $idl->{PROPERTIES}->{pointer_default_top} = "ref";
+ }
+
+ foreach my $d (@{$idl->{DATA}}) {
+ if ($d->{TYPE} eq "TYPEDEF") {
+ push (@typedefs, ParseTypedef($idl, $d));
+ }
+
+ if ($d->{TYPE} eq "DECLARE") {
+ push (@declares, $d);
+ }
+
+ if ($d->{TYPE} eq "FUNCTION") {
+ push (@functions, ParseFunction($idl, $d, \$opnum));
+ }
+
+ if ($d->{TYPE} eq "CONST") {
+ push (@consts, ParseConst($idl, $d));
+ }
+ }
+
+ $version = "0.0";
+
+ if(defined $idl->{PROPERTIES}->{version}) {
+ $version = $idl->{PROPERTIES}->{version};
+ }
+
+ # If no endpoint is set, default to the interface name as a named pipe
+ if (!defined $idl->{PROPERTIES}->{endpoint}) {
+ push @endpoints, "\"ncacn_np:[\\\\pipe\\\\" . $idl->{NAME} . "]\"";
+ } else {
+ @endpoints = split / /, $idl->{PROPERTIES}->{endpoint};
+ }
+
+ return {
+ NAME => $idl->{NAME},
+ UUID => has_property($idl, "uuid"),
+ VERSION => $version,
+ TYPE => "INTERFACE",
+ PROPERTIES => $idl->{PROPERTIES},
+ FUNCTIONS => \@functions,
+ CONSTS => \@consts,
+ TYPEDEFS => \@typedefs,
+ DECLARES => \@declares,
+ ENDPOINTS => \@endpoints
+ };
+}
+
+# Convert a IDL tree to a NDR tree
+# Gives a result tree describing all that's necessary for easily generating
+# NDR parsers / generators
+sub Parse($)
+{
+ my $idl = shift;
+ my @ndr = ();
+
+ push(@ndr, ParseInterface($_)) foreach (@{$idl});
+
+ return \@ndr;
+}
+
+sub GetNextLevel($$)
+{
+ my $e = shift;
+ my $fl = shift;
+
+ my $seen = 0;
+
+ foreach my $l (@{$e->{LEVELS}}) {
+ return $l if ($seen);
+ ($seen = 1) if ($l == $fl);
+ }
+
+ return undef;
+}
+
+sub GetPrevLevel($$)
+{
+ my ($e,$fl) = @_;
+ my $prev = undef;
+
+ foreach my $l (@{$e->{LEVELS}}) {
+ (return $prev) if ($l == $fl);
+ $prev = $l;
+ }
+
+ return undef;
+}
+
+sub ContainsDeferred($$)
+{
+ my ($e,$l) = @_;
+
+ return 1 if ($l->{CONTAINS_DEFERRED});
+
+ while ($l = GetNextLevel($e,$l))
+ {
+ return 1 if ($l->{IS_DEFERRED});
+ return 1 if ($l->{CONTAINS_DEFERRED});
+ }
+
+ return 0;
+}
+
+sub el_name($)
+{
+ my $e = shift;
+
+ if ($e->{PARENT} && $e->{PARENT}->{NAME}) {
+ return "$e->{PARENT}->{NAME}.$e->{NAME}";
+ }
+
+ if ($e->{PARENT} && $e->{PARENT}->{PARENT}->{NAME}) {
+ return "$e->{PARENT}->{PARENT}->{NAME}.$e->{NAME}";
+ }
+
+ if ($e->{PARENT}) {
+ return "$e->{PARENT}->{NAME}.$e->{NAME}";
+ }
+
+ return $e->{NAME};
+}
+
+###################################
+# find a sibling var in a structure
+sub find_sibling($$)
+{
+ my($e,$name) = @_;
+ my($fn) = $e->{PARENT};
+
+ if ($name =~ /\*(.*)/) {
+ $name = $1;
+ }
+
+ for my $e2 (@{$fn->{ELEMENTS}}) {
+ return $e2 if ($e2->{NAME} eq $name);
+ }
+
+ return undef;
+}
+
+my %property_list = (
+ # interface
+ "helpstring" => ["INTERFACE", "FUNCTION"],
+ "version" => ["INTERFACE"],
+ "uuid" => ["INTERFACE"],
+ "endpoint" => ["INTERFACE"],
+ "pointer_default" => ["INTERFACE"],
+ "pointer_default_top" => ["INTERFACE"],
+ "depends" => ["INTERFACE"],
+ "authservice" => ["INTERFACE"],
+
+ # dcom
+ "object" => ["INTERFACE"],
+ "local" => ["INTERFACE", "FUNCTION"],
+ "iid_is" => ["ELEMENT"],
+ "call_as" => ["FUNCTION"],
+ "idempotent" => ["FUNCTION"],
+
+ # function
+ "noopnum" => ["FUNCTION"],
+ "in" => ["ELEMENT"],
+ "out" => ["ELEMENT"],
+
+ # pointer
+ "ref" => ["ELEMENT"],
+ "ptr" => ["ELEMENT"],
+ "sptr" => ["ELEMENT"],
+ "unique" => ["ELEMENT"],
+ "ignore" => ["ELEMENT"],
+ "relative" => ["ELEMENT"],
+ "relative_base" => ["TYPEDEF"],
+
+ "gensize" => ["TYPEDEF"],
+ "value" => ["ELEMENT"],
+ "flag" => ["ELEMENT", "TYPEDEF"],
+
+ # generic
+ "public" => ["FUNCTION", "TYPEDEF"],
+ "nopush" => ["FUNCTION", "TYPEDEF"],
+ "nopull" => ["FUNCTION", "TYPEDEF"],
+ "noprint" => ["FUNCTION", "TYPEDEF"],
+ "noejs" => ["FUNCTION", "TYPEDEF"],
+
+ # union
+ "switch_is" => ["ELEMENT"],
+ "switch_type" => ["ELEMENT", "TYPEDEF"],
+ "nodiscriminant" => ["TYPEDEF"],
+ "case" => ["ELEMENT"],
+ "default" => ["ELEMENT"],
+
+ # subcontext
+ "subcontext" => ["ELEMENT"],
+ "subcontext_size" => ["ELEMENT"],
+ "compression" => ["ELEMENT"],
+ "obfuscation" => ["ELEMENT"],
+
+ # enum
+ "enum8bit" => ["TYPEDEF"],
+ "enum16bit" => ["TYPEDEF"],
+ "v1_enum" => ["TYPEDEF"],
+
+ # bitmap
+ "bitmap8bit" => ["TYPEDEF"],
+ "bitmap16bit" => ["TYPEDEF"],
+ "bitmap32bit" => ["TYPEDEF"],
+ "bitmap64bit" => ["TYPEDEF"],
+
+ # array
+ "range" => ["ELEMENT"],
+ "size_is" => ["ELEMENT"],
+ "string" => ["ELEMENT"],
+ "noheader" => ["ELEMENT"],
+ "charset" => ["ELEMENT"],
+ "length_is" => ["ELEMENT"],
+);
+
+#####################################################################
+# check for unknown properties
+sub ValidProperties($$)
+{
+ my ($e,$t) = @_;
+
+ return unless defined $e->{PROPERTIES};
+
+ foreach my $key (keys %{$e->{PROPERTIES}}) {
+ fatal($e, el_name($e) . ": unknown property '$key'\n")
+ unless defined($property_list{$key});
+
+ fatal($e, el_name($e) . ": property '$key' not allowed on '$t'\n")
+ unless grep($t, @{$property_list{$key}});
+ }
+}
+
+sub mapToScalar($)
+{
+ my $t = shift;
+ my $ti = getType($t);
+
+ if (not defined ($ti)) {
+ return undef;
+ } elsif ($ti->{DATA}->{TYPE} eq "ENUM") {
+ return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
+ } elsif ($ti->{DATA}->{TYPE} eq "BITMAP") {
+ return Parse::Pidl::Typelist::enum_type_fn($ti->{DATA});
+ } elsif ($ti->{DATA}->{TYPE} eq "SCALAR") {
+ return $t;
+ }
+
+ return undef;
+}
+
+#####################################################################
+# parse a struct
+sub ValidElement($)
+{
+ my $e = shift;
+
+ ValidProperties($e,"ELEMENT");
+
+ if (has_property($e, "ptr")) {
+ fatal($e, el_name($e) . " : pidl does not support full NDR pointers yet\n");
+ }
+
+ # Check whether switches are used correctly.
+ if (my $switch = has_property($e, "switch_is")) {
+ my $e2 = find_sibling($e, $switch);
+ my $type = getType($e->{TYPE});
+
+ if (defined($type) and $type->{DATA}->{TYPE} ne "UNION") {
+ fatal($e, el_name($e) . ": switch_is() used on non-union type $e->{TYPE} which is a $type->{DATA}->{TYPE}");
+ }
+
+ if (!has_property($type, "nodiscriminant") and defined($e2)) {
+ my $discriminator_type = has_property($type, "switch_type");
+ $discriminator_type = "uint32" unless defined ($discriminator_type);
+
+ my $t1 = mapToScalar($discriminator_type);
+
+ if (not defined($t1)) {
+ fatal($e, el_name($e) . ": unable to map discriminator type '$discriminator_type' to scalar");
+ }
+
+ my $t2 = mapToScalar($e2->{TYPE});
+ if (not defined($t2)) {
+ fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar");
+ }
+
+ if ($t1 ne $t2) {
+ nonfatal($e, el_name($e) . ": switch_is() is of type $e2->{TYPE} ($t2), while discriminator type for union $type->{NAME} is $discriminator_type ($t1)");
+ }
+ }
+ }
+
+ if (defined (has_property($e, "subcontext_size")) and not defined(has_property($e, "subcontext"))) {
+ fatal($e, el_name($e) . " : subcontext_size() on non-subcontext element");
+ }
+
+ if (defined (has_property($e, "compression")) and not defined(has_property($e, "subcontext"))) {
+ fatal($e, el_name($e) . " : compression() on non-subcontext element");
+ }
+
+ if (defined (has_property($e, "obfuscation")) and not defined(has_property($e, "subcontext"))) {
+ fatal($e, el_name($e) . " : obfuscation() on non-subcontext element");
+ }
+
+ if (!$e->{POINTERS} && (
+ has_property($e, "ptr") or
+ has_property($e, "sptr") or
+ has_property($e, "unique") or
+ has_property($e, "relative") or
+ has_property($e, "ref"))) {
+ fatal($e, el_name($e) . " : pointer properties on non-pointer element\n");
+ }
+}
+
+#####################################################################
+# parse a struct
+sub ValidStruct($)
+{
+ my($struct) = shift;
+
+ ValidProperties($struct,"STRUCT");
+
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ $e->{PARENT} = $struct;
+ ValidElement($e);
+ }
+}
+
+#####################################################################
+# parse a union
+sub ValidUnion($)
+{
+ my($union) = shift;
+
+ ValidProperties($union,"UNION");
+
+ if (has_property($union->{PARENT}, "nodiscriminant") and has_property($union->{PARENT}, "switch_type")) {
+ fatal($union->{PARENT}, $union->{PARENT}->{NAME} . ": switch_type() on union without discriminant");
+ }
+
+ foreach my $e (@{$union->{ELEMENTS}}) {
+ $e->{PARENT} = $union;
+
+ if (defined($e->{PROPERTIES}->{default}) and
+ defined($e->{PROPERTIES}->{case})) {
+ fatal $e, "Union member $e->{NAME} can not have both default and case properties!\n";
+ }
+
+ unless (defined ($e->{PROPERTIES}->{default}) or
+ defined ($e->{PROPERTIES}->{case})) {
+ fatal $e, "Union member $e->{NAME} must have default or case property\n";
+ }
+
+ if (has_property($e, "ref")) {
+ fatal($e, el_name($e) . " : embedded ref pointers are not supported yet\n");
+ }
+
+
+ ValidElement($e);
+ }
+}
+
+#####################################################################
+# parse a typedef
+sub ValidTypedef($)
+{
+ my($typedef) = shift;
+ my $data = $typedef->{DATA};
+
+ ValidProperties($typedef,"TYPEDEF");
+
+ $data->{PARENT} = $typedef;
+
+ if (ref($data) eq "HASH") {
+ if ($data->{TYPE} eq "STRUCT") {
+ ValidStruct($data);
+ }
+
+ if ($data->{TYPE} eq "UNION") {
+ ValidUnion($data);
+ }
+ }
+}
+
+#####################################################################
+# parse a function
+sub ValidFunction($)
+{
+ my($fn) = shift;
+
+ ValidProperties($fn,"FUNCTION");
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ $e->{PARENT} = $fn;
+ if (has_property($e, "ref") && !$e->{POINTERS}) {
+ fatal $e, "[ref] variables must be pointers ($fn->{NAME}/$e->{NAME})\n";
+ }
+ ValidElement($e);
+ }
+}
+
+#####################################################################
+# parse the interface definitions
+sub ValidInterface($)
+{
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+
+ ValidProperties($interface,"INTERFACE");
+
+ if (has_property($interface, "pointer_default") &&
+ $interface->{PROPERTIES}->{pointer_default} eq "ptr") {
+ fatal $interface, "Full pointers are not supported yet\n";
+ }
+
+ if (has_property($interface, "object")) {
+ if (has_property($interface, "version") &&
+ $interface->{PROPERTIES}->{version} != 0) {
+ fatal $interface, "Object interfaces must have version 0.0 ($interface->{NAME})\n";
+ }
+
+ if (!defined($interface->{BASE}) &&
+ not ($interface->{NAME} eq "IUnknown")) {
+ fatal $interface, "Object interfaces must all derive from IUnknown ($interface->{NAME})\n";
+ }
+ }
+
+ foreach my $d (@{$data}) {
+ ($d->{TYPE} eq "TYPEDEF") &&
+ ValidTypedef($d);
+ ($d->{TYPE} eq "FUNCTION") &&
+ ValidFunction($d);
+ }
+
+}
+
+#####################################################################
+# Validate an IDL structure
+sub Validate($)
+{
+ my($idl) = shift;
+
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") &&
+ ValidInterface($x);
+ }
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/ODL.pm b/source4/pidl/Parse/Pidl/ODL.pm
new file mode 100644
index 0000000000..03d66bfc45
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/ODL.pm
@@ -0,0 +1,92 @@
+##########################################
+# Converts ODL stuctures to IDL structures
+# (C) 2004-2005 Jelmer Vernooij <jelmer@samba.org>
+
+package Parse::Pidl::ODL;
+
+use Parse::Pidl::Util qw(has_property);
+use Parse::Pidl::Typelist qw(hasType getType);
+use strict;
+
+#####################################################################
+# find an interface in an array of interfaces
+sub get_interface($$)
+{
+ my($if) = shift;
+ my($n) = shift;
+
+ foreach(@{$if}) {
+ if($_->{NAME} eq $n) { return $_; }
+ }
+
+ return 0;
+}
+
+sub FunctionAddObjArgs($)
+{
+ my $e = shift;
+
+ unshift(@{$e->{ELEMENTS}}, {
+ 'NAME' => 'ORPCthis',
+ 'POINTERS' => 0,
+ 'PROPERTIES' => { 'in' => '1' },
+ 'TYPE' => 'ORPCTHIS'
+ });
+ unshift(@{$e->{ELEMENTS}}, {
+ 'NAME' => 'ORPCthat',
+ 'POINTERS' => 0,
+ 'PROPERTIES' => { 'out' => '1' },
+ 'TYPE' => 'ORPCTHAT'
+ });
+}
+
+sub ReplaceInterfacePointers($)
+{
+ my $e = shift;
+
+ foreach my $x (@{$e->{ELEMENTS}}) {
+ next unless (hasType($x->{TYPE}));
+ next unless getType($x->{TYPE})->{DATA}->{TYPE} eq "INTERFACE";
+
+ $x->{TYPE} = "MInterfacePointer";
+ }
+}
+
+# Add ORPC specific bits to an interface.
+sub ODL2IDL($)
+{
+ my $odl = shift;
+
+ foreach my $x (@{$odl}) {
+ # Add [in] ORPCTHIS *this, [out] ORPCTHAT *that
+ # and replace interfacepointers with MInterfacePointer
+ # for 'object' interfaces
+ if (has_property($x, "object")) {
+ foreach my $e (@{$x->{DATA}}) {
+ ($e->{TYPE} eq "FUNCTION") && FunctionAddObjArgs($e);
+ ReplaceInterfacePointers($e);
+ }
+ # Object interfaces use ORPC
+ my @depends = ();
+ if(has_property($x, "depends")) {
+ @depends = split /,/, $x->{PROPERTIES}->{depends};
+ }
+ push @depends, "orpc";
+ $x->{PROPERTIES}->{depends} = join(',',@depends);
+ }
+
+ if ($x->{BASE}) {
+ my $base = get_interface($odl, $x->{BASE});
+
+ foreach my $fn (reverse @{$base->{DATA}}) {
+ next unless ($fn->{TYPE} eq "FUNCTION");
+ unshift (@{$x->{DATA}}, $fn);
+ push (@{$x->{INHERITED_FUNCTIONS}}, $fn->{NAME});
+ }
+ }
+ }
+
+ return $odl;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/COM/Header.pm b/source4/pidl/Parse/Pidl/Samba/COM/Header.pm
new file mode 100644
index 0000000000..7b6c4db212
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/COM/Header.pm
@@ -0,0 +1,139 @@
+# COM Header generation
+# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+
+package Parse::Pidl::Samba::COM::Header;
+
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+use strict;
+
+sub GetArgumentProtoList($)
+{
+ my $f = shift;
+ my $res = "";
+
+ foreach my $a (@{$f->{ELEMENTS}}) {
+
+ $res .= ", " . Parse::Pidl::Typelist::mapType($a->{TYPE}) . " ";
+
+ my $l = $a->{POINTERS};
+ $l-- if (Parse::Pidl::Typelist::scalar_is_reference($a->{TYPE}));
+ foreach my $i (1..$l) {
+ $res .= "*";
+ }
+
+ if (defined $a->{ARRAY_LEN}[0] &&
+ !Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0]) &&
+ !$a->{POINTERS}) {
+ $res .= "*";
+ }
+ $res .= $a->{NAME};
+ if (defined $a->{ARRAY_LEN}[0] && Parse::Pidl::Util::is_constant($a->{ARRAY_LEN}[0])) {
+ $res .= "[$a->{ARRAY_LEN}[0]]";
+ }
+ }
+
+ return $res;
+}
+
+sub GetArgumentList($)
+{
+ my $f = shift;
+ my $res = "";
+
+ foreach my $a (@{$f->{ELEMENTS}}) {
+ $res .= ", $a->{NAME}";
+ }
+
+ return $res;
+}
+
+#####################################################################
+# generate vtable structure for COM interface
+sub HeaderVTable($)
+{
+ my $interface = shift;
+ my $res;
+ $res .= "#define " . uc($interface->{NAME}) . "_METHODS \\\n";
+ if (defined($interface->{BASE})) {
+ $res .= "\t" . uc($interface->{BASE} . "_METHODS") . "\\\n";
+ }
+
+ my $data = $interface->{DATA};
+ foreach my $d (@{$data}) {
+ $res .= "\t" . Parse::Pidl::Typelist::mapType($d->{RETURN_TYPE}) . " (*$d->{NAME}) (struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . GetArgumentProtoList($d) . ");\\\n" if ($d->{TYPE} eq "FUNCTION");
+ }
+ $res .= "\n";
+ $res .= "struct $interface->{NAME}_vtable {\n";
+ $res .= "\tstruct GUID iid;\n";
+ $res .= "\t" . uc($interface->{NAME}) . "_METHODS\n";
+ $res .= "};\n\n";
+
+ return $res;
+}
+
+sub ParseInterface($)
+{
+ my $if = shift;
+ my $res;
+
+ $res .="\n\n/* $if->{NAME} */\n";
+
+ $res .="#define COM_" . uc($if->{NAME}) . "_UUID $if->{PROPERTIES}->{uuid}\n\n";
+
+ $res .="struct $if->{NAME}_vtable;\n\n";
+
+ $res .="struct $if->{NAME} {
+ struct com_context *ctx;
+ struct $if->{NAME}_vtable *vtable;
+ void *object_data;
+};\n\n";
+
+ $res.=HeaderVTable($if);
+
+ foreach my $d (@{$if->{DATA}}) {
+ next if ($d->{TYPE} ne "FUNCTION");
+
+ $res .= "#define $if->{NAME}_$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . ") ";
+
+ $res .= "((interface)->vtable->$d->{NAME}(interface, mem_ctx" . GetArgumentList($d) . "))";
+
+ $res .="\n";
+ }
+
+ return $res;
+}
+
+sub ParseCoClass($)
+{
+ my $c = shift;
+ my $res = "";
+ $res .= "#define CLSID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{uuid}\n";
+ if (has_property($c, "progid")) {
+ $res .= "#define PROGID_" . uc($c->{NAME}) . " $c->{PROPERTIES}->{progid}\n";
+ }
+ $res .= "\n";
+ return $res;
+}
+
+sub Parse($)
+{
+ my $idl = shift;
+ my $res = "";
+
+ foreach my $x (@{$idl})
+ {
+ if ($x->{TYPE} eq "INTERFACE" && has_property($x, "object")) {
+ $res.=ParseInterface($x);
+ }
+
+ if ($x->{TYPE} eq "COCLASS") {
+ $res.=ParseCoClass($x);
+ }
+ }
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/COM/Proxy.pm b/source4/pidl/Parse/Pidl/Samba/COM/Proxy.pm
new file mode 100644
index 0000000000..c94ef59ae9
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/COM/Proxy.pm
@@ -0,0 +1,212 @@
+###################################################
+# DCOM parser for Samba
+# Basically the glue between COM and DCE/RPC with NDR
+# Copyright jelmer@samba.org 2003-2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::COM::Proxy;
+
+use Parse::Pidl::Samba::COM::Header;
+use Parse::Pidl::Util qw(has_property);
+
+use strict;
+
+my($res);
+
+sub ParseVTable($$)
+{
+ my $interface = shift;
+ my $name = shift;
+
+ # Generate the vtable
+ $res .="\tstruct $interface->{NAME}_vtable $name = {";
+
+ if (defined($interface->{BASE})) {
+ $res .= "\n\t\t{},";
+ }
+
+ my $data = $interface->{DATA};
+
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") {
+ $res .= "\n\t\tdcom_proxy_$interface->{NAME}_$d->{NAME}";
+ $res .= ",";
+ }
+ }
+
+ $res .= "\n\t};\n\n";
+}
+
+sub ParseRegFunc($)
+{
+ my $interface = shift;
+
+ $res .= "static NTSTATUS dcom_proxy_$interface->{NAME}_init(void)
+{
+ struct GUID base_iid;
+ struct $interface->{NAME}_vtable *proxy_vtable = talloc(talloc_autofree_context(), struct $interface->{NAME}_vtable);
+";
+
+ if (defined($interface->{BASE})) {
+ $res.= "
+ const void *base_vtable;
+
+ GUID_from_string(DCERPC_" . (uc $interface->{BASE}) . "_UUID, &base_iid);
+
+ base_vtable = dcom_proxy_vtable_by_iid(&base_iid);
+ if (base_vtable == NULL) {
+ DEBUG(0, (\"No proxy registered for base interface '$interface->{BASE}'\\n\"));
+ return NT_STATUS_FOOBAR;
+ }
+
+ memcpy(&proxy_vtable, base_vtable, sizeof(struct $interface->{BASE}_vtable));
+
+";
+ }
+ foreach my $x (@{$interface->{DATA}}) {
+ next unless ($x->{TYPE} eq "FUNCTION");
+
+ $res .= "\tproxy_vtable.$x->{NAME} = dcom_proxy_$interface->{NAME}_$x->{NAME};\n";
+ }
+
+ $res.= "
+ GUID_from_string(DCERPC_" . (uc $interface->{NAME}) . "_UUID, &proxy_vtable.iid);
+
+ return dcom_register_proxy(&proxy_vtable);
+}\n\n";
+}
+
+#####################################################################
+# parse a function
+sub ParseFunction($$)
+{
+ my $interface = shift;
+ my $fn = shift;
+ my $name = $fn->{NAME};
+ my $uname = uc $name;
+
+ $res.="
+static $fn->{RETURN_TYPE} dcom_proxy_$interface->{NAME}_$name(struct $interface->{NAME} *d, TALLOC_CTX *mem_ctx" . Parse::Pidl::Samba::COM::Header::GetArgumentProtoList($fn) . ")
+{
+ struct dcerpc_pipe *p;
+ NTSTATUS status = dcom_get_pipe(d, &p);
+ struct $name r;
+ struct rpc_request *req;
+
+ if (NT_STATUS_IS_ERR(status)) {
+ return status;
+ }
+
+ ZERO_STRUCT(r.in.ORPCthis);
+ r.in.ORPCthis.version.MajorVersion = COM_MAJOR_VERSION;
+ r.in.ORPCthis.version.MinorVersion = COM_MINOR_VERSION;
+";
+
+ # Put arguments into r
+ foreach my $a (@{$fn->{ELEMENTS}}) {
+ next unless (has_property($a, "in"));
+ if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+ $res .="\tNDR_CHECK(dcom_OBJREF_from_IUnknown(&r.in.$a->{NAME}.obj, $a->{NAME}));\n";
+ } else {
+ $res .= "\tr.in.$a->{NAME} = $a->{NAME};\n";
+ }
+ }
+
+ $res .="
+ if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
+ NDR_PRINT_IN_DEBUG($name, &r);
+ }
+
+ status = dcerpc_ndr_request(p, &d->ipid, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, &r);
+
+ if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
+ NDR_PRINT_OUT_DEBUG($name, r);
+ }
+
+";
+
+ # Put r info back into arguments
+ foreach my $a (@{$fn->{ELEMENTS}}) {
+ next unless (has_property($a, "out"));
+
+ if (Parse::Pidl::Typelist::typeIs($a->{TYPE}, "INTERFACE")) {
+ $res .="\tNDR_CHECK(dcom_IUnknown_from_OBJREF(d->ctx, &$a->{NAME}, r.out.$a->{NAME}.obj));\n";
+ } else {
+ $res .= "\t*$a->{NAME} = r.out.$a->{NAME};\n";
+ }
+
+ }
+
+ if ($fn->{RETURN_TYPE} eq "NTSTATUS") {
+ $res .= "\tif (NT_STATUS_IS_OK(status)) status = r.out.result;\n";
+ }
+
+ $res .=
+ "
+ return r.out.result;
+}\n\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($)
+{
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+ $res = "/* DCOM proxy for $interface->{NAME} generated by pidl */\n\n";
+ foreach my $d (@{$data}) {
+ ($d->{TYPE} eq "FUNCTION") &&
+ ParseFunction($interface, $d);
+ }
+
+ ParseRegFunc($interface);
+}
+
+sub RegistrationFunction($$)
+{
+ my $idl = shift;
+ my $basename = shift;
+
+ my $res = "\n\nNTSTATUS dcom_$basename\_init(void)\n";
+ $res .= "{\n";
+ $res .="\tNTSTATUS status = NT_STATUS_OK;\n";
+ foreach my $interface (@{$idl}) {
+ next if $interface->{TYPE} ne "INTERFACE";
+ next if not has_property($interface, "object");
+
+ my $data = $interface->{DATA};
+ my $count = 0;
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") { $count++; }
+ }
+
+ next if ($count == 0);
+
+ $res .= "\tstatus = dcom_$interface->{NAME}_init();\n";
+ $res .= "\tif (NT_STATUS_IS_ERR(status)) {\n";
+ $res .= "\t\treturn status;\n";
+ $res .= "\t}\n\n";
+ }
+ $res .= "\treturn status;\n";
+ $res .= "}\n\n";
+
+ return $res;
+}
+
+sub Parse($)
+{
+ my $pidl = shift;
+ my $res = "";
+
+ foreach my $x (@{$pidl}) {
+ next if ($x->{TYPE} ne "INTERFACE");
+ next if has_property($x, "local");
+ next unless has_property($x, "object");
+
+ $res .= ParseInterface($x);
+ }
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/COM/Stub.pm b/source4/pidl/Parse/Pidl/Samba/COM/Stub.pm
new file mode 100644
index 0000000000..785c34fc77
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/COM/Stub.pm
@@ -0,0 +1,324 @@
+###################################################
+# DCOM stub boilerplate generator
+# Copyright jelmer@samba.org 2004-2005
+# Copyright tridge@samba.org 2003
+# Copyright metze@samba.org 2004
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::COM::Stub;
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my($res);
+
+sub pidl($)
+{
+ $res .= shift;
+}
+
+#####################################################
+# generate the switch statement for function dispatch
+sub gen_dispatch_switch($)
+{
+ my $data = shift;
+
+ my $count = 0;
+ foreach my $d (@{$data}) {
+ next if ($d->{TYPE} ne "FUNCTION");
+
+ pidl "\tcase $count: {\n";
+ if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
+ pidl "\t\tNTSTATUS result;\n";
+ }
+ pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
+ pidl "\t\tif (DEBUGLEVEL > 10) {\n";
+ pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_IN, r2);\n";
+ pidl "\t\t}\n";
+ if ($d->{RETURN_TYPE} && $d->{RETURN_TYPE} ne "void") {
+ pidl "\t\tresult = vtable->$d->{NAME}(iface, mem_ctx, r2);\n";
+ } else {
+ pidl "\t\tvtable->$d->{NAME}(iface, mem_ctx, r2);\n";
+ }
+ pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+ pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} will reply async\\n\"));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tbreak;\n\t}\n";
+ $count++;
+ }
+}
+
+#####################################################
+# generate the switch statement for function reply
+sub gen_reply_switch($)
+{
+ my $data = shift;
+
+ my $count = 0;
+ foreach my $d (@{$data}) {
+ next if ($d->{TYPE} ne "FUNCTION");
+
+ pidl "\tcase $count: {\n";
+ pidl "\t\tstruct $d->{NAME} *r2 = r;\n";
+ pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+ pidl "\t\t\tDEBUG(5,(\"function $d->{NAME} replied async\\n\"));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tif (DEBUGLEVEL > 10 && dce_call->fault_code == 0) {\n";
+ pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($d->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n";
+ pidl "\t\t}\n";
+ pidl "\t\tif (dce_call->fault_code != 0) {\n";
+ pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $d->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tbreak;\n\t}\n";
+ $count++;
+ }
+}
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Boilerplate_Iface($)
+{
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+ my $name = $interface->{NAME};
+ my $uname = uc $name;
+ my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
+ my $if_version = $interface->{PROPERTIES}->{version};
+
+ pidl "
+static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_BIND
+ return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface);
+#else
+ return NT_STATUS_OK;
+#endif
+}
+
+static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_UNBIND
+ DCESRV_INTERFACE_$uname\_UNBIND(context, iface);
+#else
+ return;
+#endif
+}
+
+static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
+{
+ NTSTATUS status;
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ dce_call->fault_code = 0;
+
+ if (opnum >= dcerpc_table_$name.num_calls) {
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size);
+ NT_STATUS_HAVE_NO_MEMORY(*r);
+
+ /* unravel the NDR for the packet */
+ status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r);
+ if (!NT_STATUS_IS_OK(status)) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ dce_call->fault_code = DCERPC_FAULT_NDR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+ struct GUID ipid = dce_call->pkt.u.request.object.object;
+ struct dcom_interface_p *iface = dcom_get_local_iface_p(&ipid);
+ const struct dcom_$name\_vtable *vtable = iface->vtable;
+
+ switch (opnum) {
+";
+ gen_dispatch_switch($data);
+
+pidl "
+ default:
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ break;
+ }
+
+ if (dce_call->fault_code != 0) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ switch (opnum) {
+";
+ gen_reply_switch($data);
+
+pidl "
+ default:
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ break;
+ }
+
+ if (dce_call->fault_code != 0) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
+{
+ NTSTATUS status;
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r);
+ if (!NT_STATUS_IS_OK(status)) {
+ dce_call->fault_code = DCERPC_FAULT_NDR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static const struct dcesrv_interface $name\_interface = {
+ .name = \"$name\",
+ .uuid = $uuid,
+ .if_version = $if_version,
+ .bind = $name\__op_bind,
+ .unbind = $name\__op_unbind,
+ .ndr_pull = $name\__op_ndr_pull,
+ .dispatch = $name\__op_dispatch,
+ .reply = $name\__op_reply,
+ .ndr_push = $name\__op_ndr_push
+};
+
+";
+}
+
+#####################################################################
+# produce boilerplate code for an endpoint server
+sub Boilerplate_Ep_Server($)
+{
+ my($interface) = shift;
+ my $name = $interface->{NAME};
+ my $uname = uc $name;
+
+ pidl "
+static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
+{
+ int i;
+
+ for (i=0;i<dcerpc_table_$name.endpoints->count;i++) {
+ NTSTATUS ret;
+ const char *name = dcerpc_table_$name.endpoints->names[i];
+
+ ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL);
+ if (!NT_STATUS_IS_OK(ret)) {
+ DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name));
+ return ret;
+ }
+ }
+
+ return NT_STATUS_OK;
+}
+
+static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version)
+{
+ if (dcerpc_table_$name.if_version == if_version &&
+ strcmp(dcerpc_table_$name.uuid, uuid)==0) {
+ memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
+ return True;
+ }
+
+ return False;
+}
+
+static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
+{
+ if (strcmp(dcerpc_table_$name.name, name)==0) {
+ memcpy(iface,&dcerpc_table_$name, sizeof(*iface));
+ return True;
+ }
+
+ return False;
+}
+
+NTSTATUS dcerpc_server_$name\_init(void)
+{
+ NTSTATUS ret;
+ struct dcesrv_endpoint_server ep_server;
+
+ /* fill in our name */
+ ep_server.name = \"$name\";
+
+ /* fill in all the operations */
+ ep_server.init_server = $name\__op_init_server;
+
+ ep_server.interface_by_uuid = $name\__op_interface_by_uuid;
+ ep_server.interface_by_name = $name\__op_interface_by_name;
+
+ /* register ourselves with the DCERPC subsystem. */
+ ret = dcerpc_register_ep_server(&ep_server);
+
+ if (!NT_STATUS_IS_OK(ret)) {
+ DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\"));
+ return ret;
+ }
+
+ return ret;
+}
+
+";
+}
+
+#####################################################################
+# dcom interface stub from a parsed IDL structure
+sub ParseInterface($)
+{
+ my($interface) = shift;
+
+ return "" if has_property($interface, "local");
+
+ my($data) = $interface->{DATA};
+ my $count = 0;
+
+ $res = "";
+
+ if (!defined $interface->{PROPERTIES}->{uuid}) {
+ return $res;
+ }
+
+ if (!defined $interface->{PROPERTIES}->{version}) {
+ $interface->{PROPERTIES}->{version} = "0.0";
+ }
+
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") { $count++; }
+ }
+
+ if ($count == 0) {
+ return $res;
+ }
+
+ $res = "/* dcom interface stub generated by pidl */\n\n";
+ Boilerplate_Iface($interface);
+ Boilerplate_Ep_Server($interface);
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/EJS.pm b/source4/pidl/Parse/Pidl/Samba/EJS.pm
new file mode 100644
index 0000000000..743139c8cd
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/EJS.pm
@@ -0,0 +1,835 @@
+###################################################
+# EJS function wrapper generator
+# Copyright jelmer@samba.org 2005
+# Copyright Andrew Tridgell 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::EJS;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+my %constants;
+
+my $tabs = "";
+sub pidl($)
+{
+ my $d = shift;
+ if ($d) {
+ $res .= $tabs;
+ $res .= $d;
+ }
+ $res .= "\n";
+}
+
+sub indent()
+{
+ $tabs .= "\t";
+}
+
+sub deindent()
+{
+ $tabs = substr($tabs, 0, -1);
+}
+
+# this should probably be in ndr.pm
+sub GenerateStructEnv($)
+{
+ my $x = shift;
+ my %env;
+
+ foreach my $e (@{$x->{ELEMENTS}}) {
+ if ($e->{NAME}) {
+ $env{$e->{NAME}} = "r->$e->{NAME}";
+ }
+ }
+
+ $env{"this"} = "r";
+
+ return \%env;
+}
+
+sub GenerateFunctionInEnv($)
+{
+ my $fn = shift;
+ my %env;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep (/in/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->in.$e->{NAME}";
+ }
+ }
+
+ return \%env;
+}
+
+sub GenerateFunctionOutEnv($)
+{
+ my $fn = shift;
+ my %env;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep (/out/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->out.$e->{NAME}";
+ } elsif (grep (/in/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->in.$e->{NAME}";
+ }
+ }
+
+ return \%env;
+}
+
+sub get_pointer_to($)
+{
+ my $var_name = shift;
+
+ if ($var_name =~ /^\*(.*)$/) {
+ return $1;
+ } elsif ($var_name =~ /^\&(.*)$/) {
+ return "&($var_name)";
+ } else {
+ return "&$var_name";
+ }
+}
+
+sub get_value_of($)
+{
+ my $var_name = shift;
+
+ if ($var_name =~ /^\&(.*)$/) {
+ return $1;
+ } else {
+ return "*$var_name";
+ }
+}
+
+#####################################################################
+# work out is a parse function should be declared static or not
+sub fn_prefix($)
+{
+ my $fn = shift;
+
+ return "" if (has_property($fn, "public"));
+ return "static ";
+}
+
+###########################
+# pull a scalar element
+sub EjsPullScalar($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+
+ return if (has_property($e, "value"));
+
+ my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+ $var = get_pointer_to($var);
+ # have to handle strings specially :(
+ if ($e->{TYPE} eq "string" && $pl && $pl->{TYPE} eq "POINTER") {
+ $var = get_pointer_to($var);
+ }
+ pidl "NDR_CHECK(ejs_pull_$e->{TYPE}(ejs, v, $name, $var));";
+}
+
+###########################
+# pull a pointer element
+sub EjsPullPointer($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ pidl "if (ejs_pull_null(ejs, v, $name)) {";
+ indent;
+ pidl "$var = NULL;";
+ deindent;
+ pidl "} else {";
+ indent;
+ pidl "EJS_ALLOC(ejs, $var);";
+ $var = get_value_of($var);
+ EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+ deindent;
+ pidl "}";
+}
+
+###########################
+# pull a string element
+sub EjsPullString($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ $var = get_pointer_to($var);
+ pidl "NDR_CHECK(ejs_pull_string(ejs, v, $name, $var));";
+}
+
+
+###########################
+# pull an array element
+sub EjsPullArray($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+ my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+ my $size = Parse::Pidl::Util::ParseExpr($l->{SIZE_IS}, $env);
+ my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+ if ($pl && $pl->{TYPE} eq "POINTER") {
+ $var = get_pointer_to($var);
+ }
+ # uint8 arrays are treated as data blobs
+ if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
+ if (!$l->{IS_FIXED}) {
+ pidl "EJS_ALLOC_N(ejs, $var, $size);";
+ }
+ pidl "ejs_pull_array_uint8(ejs, v, $name, $var, $length);";
+ return;
+ }
+ my $avar = $var . "[i]";
+ pidl "{";
+ indent;
+ pidl "uint32_t i;";
+ if (!$l->{IS_FIXED}) {
+ pidl "EJS_ALLOC_N(ejs, $var, $size);";
+ }
+ pidl "for (i=0;i<$length;i++) {";
+ indent;
+ pidl "char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
+ EjsPullElement($e, $nl, $avar, "id", $env);
+ pidl "talloc_free(id);";
+ deindent;
+ pidl "}";
+ pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
+ deindent;
+ pidl "}";
+}
+
+###########################
+# pull a switch element
+sub EjsPullSwitch($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
+ pidl "ejs_set_switch(ejs, $switch_var);";
+ EjsPullElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+}
+
+###########################
+# pull a structure element
+sub EjsPullElement($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ if (has_property($e, "charset")) {
+ EjsPullString($e, $l, $var, $name, $env);
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ EjsPullArray($e, $l, $var, $name, $env);
+ } elsif ($l->{TYPE} eq "DATA") {
+ EjsPullScalar($e, $l, $var, $name, $env);
+ } elsif (($l->{TYPE} eq "POINTER")) {
+ EjsPullPointer($e, $l, $var, $name, $env);
+ } elsif (($l->{TYPE} eq "SWITCH")) {
+ EjsPullSwitch($e, $l, $var, $name, $env);
+ } else {
+ pidl "return ejs_panic(ejs, \"unhandled pull type $l->{TYPE}\");";
+ }
+}
+
+#############################################
+# pull a structure/union element at top level
+sub EjsPullElementTop($$)
+{
+ my $e = shift;
+ my $env = shift;
+ my $l = $e->{LEVELS}[0];
+ my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
+ my $name = "\"$e->{NAME}\"";
+ EjsPullElement($e, $l, $var, $name, $env);
+}
+
+###########################
+# pull a struct
+sub EjsStructPull($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $env = GenerateStructEnv($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, struct $name *r)\n{";
+ indent;
+ pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ EjsPullElementTop($e, $env);
+ }
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+###########################
+# pull a union
+sub EjsUnionPull($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $have_default = 0;
+ my $env = GenerateStructEnv($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, union $name *r)\n{";
+ indent;
+ pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, name));";
+ pidl "switch (ejs->switch_var) {";
+ indent;
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ if ($e->{CASE} eq "default") {
+ $have_default = 1;
+ }
+ pidl "$e->{CASE}:";
+ indent;
+ if ($e->{TYPE} ne "EMPTY") {
+ EjsPullElementTop($e, $env);
+ }
+ pidl "break;";
+ deindent;
+ }
+ if (! $have_default) {
+ pidl "default:";
+ indent;
+ pidl "return ejs_panic(ejs, \"Bad switch value\");";
+ deindent;
+ }
+ deindent;
+ pidl "}";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+}
+
+##############################################
+# put the enum elements in the constants array
+sub EjsEnumConstant($)
+{
+ my $d = shift;
+ my $v = 0;
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ my $el = $e;
+ chomp $el;
+ if ($el =~ /^(.*)=\s*(.*)\s*$/) {
+ $el = $1;
+ $v = $2;
+ }
+ $constants{$el} = $v;
+ $v++;
+ }
+}
+
+###########################
+# pull a enum
+sub EjsEnumPull($$)
+{
+ my $name = shift;
+ my $d = shift;
+ EjsEnumConstant($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, enum $name *r)\n{";
+ indent;
+ pidl "unsigned e;";
+ pidl "NDR_CHECK(ejs_pull_enum(ejs, v, name, &e));";
+ pidl "*r = e;";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+###########################
+# pull a bitmap
+sub EjsBitmapPull($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $type_fn = $d->{BASE_TYPE};
+ my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, $type_decl *r)\n{";
+ indent;
+ pidl "return ejs_pull_$type_fn(ejs, v, name, r);";
+ deindent;
+ pidl "}";
+}
+
+
+###########################
+# generate a structure pull
+sub EjsTypedefPull($)
+{
+ my $d = shift;
+ return if (has_property($d, "noejs"));
+ if ($d->{DATA}->{TYPE} eq 'STRUCT') {
+ EjsStructPull($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
+ EjsUnionPull($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
+ EjsEnumPull($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
+ EjsBitmapPull($d->{NAME}, $d->{DATA});
+ } else {
+ warn "Unhandled pull typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
+ }
+}
+
+#####################
+# generate a function
+sub EjsPullFunction($)
+{
+ my $d = shift;
+ my $env = GenerateFunctionInEnv($d);
+ my $name = $d->{NAME};
+
+ pidl "\nstatic NTSTATUS ejs_pull_$name(struct ejs_rpc *ejs, struct MprVar *v, struct $name *r)";
+ pidl "{";
+ indent;
+ pidl "NDR_CHECK(ejs_pull_struct_start(ejs, &v, \"input\"));";
+
+ # we pull non-array elements before array elements as arrays
+ # may have length_is() or size_is() properties that depend
+ # on the non-array elements
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ next unless (grep(/in/, @{$e->{DIRECTION}}));
+ next if (has_property($e, "length_is") ||
+ has_property($e, "size_is"));
+ EjsPullElementTop($e, $env);
+ }
+
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ next unless (grep(/in/, @{$e->{DIRECTION}}));
+ next unless (has_property($e, "length_is") ||
+ has_property($e, "size_is"));
+ EjsPullElementTop($e, $env);
+ }
+
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+
+###########################
+# push a scalar element
+sub EjsPushScalar($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ # have to handle strings specially :(
+ my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+ if ($e->{TYPE} ne "string" || ($pl && $pl->{TYPE} eq "POINTER")) {
+ $var = get_pointer_to($var);
+ }
+ pidl "NDR_CHECK(ejs_push_$e->{TYPE}(ejs, v, $name, $var));";
+}
+
+###########################
+# push a string element
+sub EjsPushString($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ pidl "NDR_CHECK(ejs_push_string(ejs, v, $name, $var));";
+}
+
+###########################
+# push a pointer element
+sub EjsPushPointer($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ pidl "if (NULL == $var) {";
+ indent;
+ pidl "NDR_CHECK(ejs_push_null(ejs, v, $name));";
+ deindent;
+ pidl "} else {";
+ indent;
+ $var = get_value_of($var);
+ EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+ deindent;
+ pidl "}";
+}
+
+###########################
+# push a switch element
+sub EjsPushSwitch($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ my $switch_var = Parse::Pidl::Util::ParseExpr($l->{SWITCH_IS}, $env);
+ pidl "ejs_set_switch(ejs, $switch_var);";
+ EjsPushElement($e, Parse::Pidl::NDR::GetNextLevel($e, $l), $var, $name, $env);
+}
+
+
+###########################
+# push an array element
+sub EjsPushArray($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ my $nl = Parse::Pidl::NDR::GetNextLevel($e, $l);
+ my $length = Parse::Pidl::Util::ParseExpr($l->{LENGTH_IS}, $env);
+ my $pl = Parse::Pidl::NDR::GetPrevLevel($e, $l);
+ if ($pl && $pl->{TYPE} eq "POINTER") {
+ $var = get_pointer_to($var);
+ }
+ # uint8 arrays are treated as data blobs
+ if ($nl->{TYPE} eq 'DATA' && $e->{TYPE} eq 'uint8') {
+ pidl "ejs_push_array_uint8(ejs, v, $name, $var, $length);";
+ return;
+ }
+ my $avar = $var . "[i]";
+ pidl "{";
+ indent;
+ pidl "uint32_t i;";
+ pidl "for (i=0;i<$length;i++) {";
+ indent;
+ pidl "const char *id = talloc_asprintf(ejs, \"%s.%u\", $name, i);";
+ EjsPushElement($e, $nl, $avar, "id", $env);
+ deindent;
+ pidl "}";
+ pidl "ejs_push_uint32(ejs, v, $name \".length\", &i);";
+ deindent;
+ pidl "}";
+}
+
+################################
+# push a structure/union element
+sub EjsPushElement($$$$$)
+{
+ my ($e, $l, $var, $name, $env) = @_;
+ if (has_property($e, "charset")) {
+ EjsPushString($e, $l, $var, $name, $env);
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ EjsPushArray($e, $l, $var, $name, $env);
+ } elsif ($l->{TYPE} eq "DATA") {
+ EjsPushScalar($e, $l, $var, $name, $env);
+ } elsif (($l->{TYPE} eq "POINTER")) {
+ EjsPushPointer($e, $l, $var, $name, $env);
+ } elsif (($l->{TYPE} eq "SWITCH")) {
+ EjsPushSwitch($e, $l, $var, $name, $env);
+ } else {
+ pidl "return ejs_panic(ejs, \"unhandled push type $l->{TYPE}\");";
+ }
+}
+
+#############################################
+# push a structure/union element at top level
+sub EjsPushElementTop($$)
+{
+ my $e = shift;
+ my $env = shift;
+ my $l = $e->{LEVELS}[0];
+ my $var = Parse::Pidl::Util::ParseExpr($e->{NAME}, $env);
+ my $name = "\"$e->{NAME}\"";
+ EjsPushElement($e, $l, $var, $name, $env);
+}
+
+###########################
+# push a struct
+sub EjsStructPush($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $env = GenerateStructEnv($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const struct $name *r)\n{";
+ indent;
+ pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ EjsPushElementTop($e, $env);
+ }
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+###########################
+# push a union
+sub EjsUnionPush($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $have_default = 0;
+ my $env = GenerateStructEnv($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const union $name *r)\n{";
+ indent;
+ pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, name));";
+ pidl "switch (ejs->switch_var) {";
+ indent;
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ if ($e->{CASE} eq "default") {
+ $have_default = 1;
+ }
+ pidl "$e->{CASE}:";
+ indent;
+ if ($e->{TYPE} ne "EMPTY") {
+ EjsPushElementTop($e, $env);
+ }
+ pidl "break;";
+ deindent;
+ }
+ if (! $have_default) {
+ pidl "default:";
+ indent;
+ pidl "return ejs_panic(ejs, \"Bad switch value\");";
+ deindent;
+ }
+ deindent;
+ pidl "}";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+}
+
+###########################
+# push a enum
+sub EjsEnumPush($$)
+{
+ my $name = shift;
+ my $d = shift;
+ EjsEnumConstant($d);
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const enum $name *r)\n{";
+ indent;
+ pidl "unsigned e = *r;";
+ pidl "NDR_CHECK(ejs_push_enum(ejs, v, name, &e));";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+###########################
+# push a bitmap
+sub EjsBitmapPush($$)
+{
+ my $name = shift;
+ my $d = shift;
+ my $type_fn = $d->{BASE_TYPE};
+ my($type_decl) = Parse::Pidl::Typelist::mapType($d->{BASE_TYPE});
+ # put the bitmap elements in the constants array
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ if ($e =~ /^(\w*)\s*(.*)\s*$/) {
+ my $bname = $1;
+ my $v = $2;
+ $constants{$bname} = $v;
+ }
+ }
+ pidl fn_prefix($d);
+ pidl "NTSTATUS ejs_push_$name(struct ejs_rpc *ejs, struct MprVar *v, const char *name, const $type_decl *r)\n{";
+ indent;
+ pidl "return ejs_push_$type_fn(ejs, v, name, r);";
+ deindent;
+ pidl "}";
+}
+
+
+###########################
+# generate a structure push
+sub EjsTypedefPush($)
+{
+ my $d = shift;
+ return if (has_property($d, "noejs"));
+ if ($d->{DATA}->{TYPE} eq 'STRUCT') {
+ EjsStructPush($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'UNION') {
+ EjsUnionPush($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'ENUM') {
+ EjsEnumPush($d->{NAME}, $d->{DATA});
+ } elsif ($d->{DATA}->{TYPE} eq 'BITMAP') {
+ EjsBitmapPush($d->{NAME}, $d->{DATA});
+ } else {
+ warn "Unhandled push typedef $d->{NAME} of type $d->{DATA}->{TYPE}";
+ }
+}
+
+
+#####################
+# generate a function
+sub EjsPushFunction($)
+{
+ my $d = shift;
+ my $env = GenerateFunctionOutEnv($d);
+
+ pidl "\nstatic NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const struct $d->{NAME} *r)";
+ pidl "{";
+ indent;
+ pidl "NDR_CHECK(ejs_push_struct_start(ejs, &v, \"output\"));";
+
+ foreach my $e (@{$d->{ELEMENTS}}) {
+ next unless (grep(/out/, @{$e->{DIRECTION}}));
+ EjsPushElementTop($e, $env);
+ }
+
+ if ($d->{RETURN_TYPE}) {
+ my $t = $d->{RETURN_TYPE};
+ pidl "NDR_CHECK(ejs_push_$t(ejs, v, \"result\", &r->out.result));";
+ }
+
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}\n";
+}
+
+
+#################################
+# generate a ejs mapping function
+sub EjsFunction($$)
+{
+ my $d = shift;
+ my $iface = shift;
+ my $name = $d->{NAME};
+ my $callnum = uc("DCERPC_$name");
+ my $table = "&dcerpc_table_$iface";
+
+ pidl "static int ejs_$name(int eid, int argc, struct MprVar **argv)";
+ pidl "{";
+ indent;
+ pidl "return ejs_rpc_call(eid, argc, argv, $table, $callnum, (ejs_pull_function_t)ejs_pull_$name, (ejs_push_function_t)ejs_push_$name);";
+ deindent;
+ pidl "}\n";
+}
+
+###################
+# handle a constant
+sub EjsConst($)
+{
+ my $const = shift;
+ $constants{$const->{NAME}} = $const->{VALUE};
+}
+
+#####################################################################
+# parse the interface definitions
+sub EjsInterface($$)
+{
+ my($interface,$needed) = @_;
+ my @fns = ();
+ my $name = $interface->{NAME};
+
+ %constants = ();
+
+ foreach my $d (@{$interface->{TYPEDEFS}}) {
+ ($needed->{"push_$d->{NAME}"}) && EjsTypedefPush($d);
+ ($needed->{"pull_$d->{NAME}"}) && EjsTypedefPull($d);
+ }
+
+ foreach my $d (@{$interface->{FUNCTIONS}}) {
+ next if not defined($d->{OPNUM});
+
+ EjsPullFunction($d);
+ EjsPushFunction($d);
+ EjsFunction($d, $name);
+
+ push (@fns, $d->{NAME});
+ }
+
+ foreach my $d (@{$interface->{CONSTS}}) {
+ EjsConst($d);
+ }
+
+ pidl "static int ejs_$name\_init(int eid, int argc, struct MprVar **argv)";
+ pidl "{";
+ indent;
+ pidl "struct MprVar *obj = mprInitObject(eid, \"$name\", argc, argv);";
+ foreach (@fns) {
+ pidl "mprSetCFunction(obj, \"$_\", ejs_$_);";
+ }
+ foreach my $v (keys %constants) {
+ my $value = $constants{$v};
+ if (substr($value, 0, 1) eq "\"") {
+ pidl "mprSetVar(obj, \"$v\", mprString($value));";
+ } else {
+ pidl "mprSetVar(obj, \"$v\", mprCreateNumberVar($value));";
+ }
+ }
+ pidl "return ejs_rpc_init(obj, \"$name\");";
+ deindent;
+ pidl "}\n";
+
+ pidl "NTSTATUS ejs_init_$name(void)";
+ pidl "{";
+ indent;
+ pidl "return smbcalls_register_ejs(\"$name\_init\", ejs_$name\_init);";
+ deindent;
+ pidl "}";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($$)
+{
+ my($ndr,$hdr) = @_;
+
+ my $ejs_hdr = $hdr;
+ $ejs_hdr =~ s/.h$/_ejs.h/;
+ $res = "";
+ pidl "
+/* EJS wrapper functions auto-generated by pidl */
+#include \"includes.h\"
+#include \"lib/appweb/ejs/ejs.h\"
+#include \"scripting/ejs/ejsrpc.h\"
+#include \"scripting/ejs/smbcalls.h\"
+#include \"librpc/gen_ndr/ndr_misc_ejs.h\"
+#include \"$hdr\"
+#include \"$ejs_hdr\"
+
+";
+
+ my %needed = ();
+
+ foreach my $x (@{$ndr}) {
+ ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
+ }
+
+ foreach my $x (@{$ndr}) {
+ ($x->{TYPE} eq "INTERFACE") && EjsInterface($x, \%needed);
+ }
+
+ return $res;
+}
+
+sub NeededFunction($$)
+{
+ my ($fn,$needed) = @_;
+ $needed->{"pull_$fn->{NAME}"} = 1;
+ $needed->{"push_$fn->{NAME}"} = 1;
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep (/in/, @{$e->{DIRECTION}})) {
+ $needed->{"pull_$e->{TYPE}"} = 1;
+ }
+ if (grep (/out/, @{$e->{DIRECTION}})) {
+ $needed->{"push_$e->{TYPE}"} = 1;
+ }
+ }
+}
+
+sub NeededTypedef($$)
+{
+ my ($t,$needed) = @_;
+ if (Parse::Pidl::Util::has_property($t, "public")) {
+ $needed->{"pull_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
+ $needed->{"push_$t->{NAME}"} = not Parse::Pidl::Util::has_property($t, "noejs");
+ }
+ if ($t->{DATA}->{TYPE} ne "STRUCT" &&
+ $t->{DATA}->{TYPE} ne "UNION") {
+ return;
+ }
+ for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+ if ($needed->{"pull_$t->{NAME}"}) {
+ $needed->{"pull_$e->{TYPE}"} = 1;
+ }
+ if ($needed->{"push_$t->{NAME}"}) {
+ $needed->{"push_$e->{TYPE}"} = 1;
+ }
+ }
+}
+
+#####################################################################
+# work out what parse functions are needed
+sub NeededInterface($$)
+{
+ my ($interface,$needed) = @_;
+ foreach my $d (@{$interface->{FUNCTIONS}}) {
+ NeededFunction($d, $needed);
+ }
+ foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
+ NeededTypedef($d, $needed);
+ }
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/EJSHeader.pm b/source4/pidl/Parse/Pidl/Samba/EJSHeader.pm
new file mode 100644
index 0000000000..81c75705de
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/EJSHeader.pm
@@ -0,0 +1,76 @@
+###################################################
+# create C header files for an EJS mapping functions
+# Copyright tridge@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::EJSHeader;
+
+use strict;
+use Parse::Pidl::Typelist;
+use Parse::Pidl::Util qw(has_property);
+
+my($res);
+
+sub pidl ($)
+{
+ $res .= shift;
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+ my $d = shift;
+ my $name = $d->{NAME};
+
+ return unless has_property($d, "public");
+
+ my $type_decl = Parse::Pidl::Typelist::mapType($name);
+
+ pidl "NTSTATUS ejs_push_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, const $type_decl *);\n";
+ pidl "NTSTATUS ejs_pull_$d->{NAME}(struct ejs_rpc *, struct MprVar *, const char *, $type_decl *);\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+ my($interface) = shift;
+
+ my $count = 0;
+
+ pidl "#ifndef _HEADER_EJS_$interface->{NAME}\n";
+ pidl "#define _HEADER_EJS_$interface->{NAME}\n\n";
+
+ if (defined $interface->{PROPERTIES}->{depends}) {
+ my @d = split / /, $interface->{PROPERTIES}->{depends};
+ foreach my $i (@d) {
+ pidl "#include \"librpc/gen_ndr/ndr_$i\_ejs\.h\"\n";
+ }
+ }
+
+ pidl "\n";
+
+ foreach my $d (@{$interface->{TYPEDEFS}}) {
+ HeaderTypedefProto($d);
+ }
+
+ pidl "\n";
+ pidl "#endif /* _HEADER_EJS_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($)
+{
+ my($idl) = shift;
+
+ $res = "";
+ pidl "/* header auto-generated by pidl */\n\n";
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+ }
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/Header.pm b/source4/pidl/Parse/Pidl/Samba/Header.pm
new file mode 100644
index 0000000000..d88b37e229
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/Header.pm
@@ -0,0 +1,356 @@
+###################################################
+# create C header files for an IDL structure
+# Copyright tridge@samba.org 2000
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::Header;
+
+use strict;
+use Parse::Pidl::Typelist qw(mapType);
+use Parse::Pidl::Util qw(has_property is_constant);
+use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+ $res .= shift;
+}
+
+sub tabs()
+{
+ my $res = "";
+ $res .="\t" foreach (1..$tab_depth);
+ return $res;
+}
+
+#####################################################################
+# parse a properties list
+sub HeaderProperties($$)
+{
+ my($props,$ignores) = @_;
+ my $ret = "";
+
+ foreach my $d (keys %{$props}) {
+ next if (grep(/^$d$/, @$ignores));
+ if($props->{$d} ne "1") {
+ $ret.= "$d($props->{$d}),";
+ } else {
+ $ret.="$d,";
+ }
+ }
+
+ if ($ret) {
+ pidl "/* [" . substr($ret, 0, -1) . "] */";
+ }
+}
+
+#####################################################################
+# parse a structure element
+sub HeaderElement($)
+{
+ my($element) = shift;
+
+ pidl tabs();
+ HeaderType($element, $element->{TYPE}, "");
+ pidl " ";
+ my $numstar = $element->{POINTERS};
+ foreach (@{$element->{ARRAY_LEN}})
+ {
+ next if is_constant($_) and
+ not has_property($element, "charset");
+ $numstar++;
+ }
+ $numstar-- if Parse::Pidl::Typelist::scalar_is_reference($element->{TYPE});
+ pidl "*" foreach (1..$numstar);
+ pidl $element->{NAME};
+ foreach (@{$element->{ARRAY_LEN}}) {
+ next unless (is_constant($_) and
+ not has_property($element, "charset"));
+ pidl "[$_]";
+ }
+
+ pidl ";";
+ if (defined $element->{PROPERTIES}) {
+ HeaderProperties($element->{PROPERTIES}, ["in", "out"]);
+ }
+ pidl "\n";
+}
+
+#####################################################################
+# parse a struct
+sub HeaderStruct($$)
+{
+ my($struct,$name) = @_;
+ pidl "struct $name {\n";
+ $tab_depth++;
+ my $el_count=0;
+ if (defined $struct->{ELEMENTS}) {
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ HeaderElement($e);
+ $el_count++;
+ }
+ }
+ if ($el_count == 0) {
+ # some compilers can't handle empty structures
+ pidl tabs()."char _empty_;\n";
+ }
+ $tab_depth--;
+ pidl tabs()."}";
+ if (defined $struct->{PROPERTIES}) {
+ HeaderProperties($struct->{PROPERTIES}, []);
+ }
+}
+
+#####################################################################
+# parse a enum
+sub HeaderEnum($$)
+{
+ my($enum,$name) = @_;
+ my $first = 1;
+
+ if (not Parse::Pidl::Util::useUintEnums()) {
+ pidl "enum $name {\n";
+ $tab_depth++;
+ foreach my $e (@{$enum->{ELEMENTS}}) {
+ unless ($first) { pidl ",\n"; }
+ $first = 0;
+ pidl tabs();
+ pidl $e;
+ }
+ pidl "\n";
+ $tab_depth--;
+ pidl "}";
+ } else {
+ my $count = 0;
+ pidl "enum $name { __donnot_use_enum_$name=0x7FFFFFFF};\n";
+ my $with_val = 0;
+ my $without_val = 0;
+ foreach my $e (@{$enum->{ELEMENTS}}) {
+ my $t = "$e";
+ my $name;
+ my $value;
+ if ($t =~ /(.*)=(.*)/) {
+ $name = $1;
+ $value = $2;
+ $with_val = 1;
+ die ("you can't mix enum member with values and without values when using --uint-enums!")
+ unless ($without_val == 0);
+ } else {
+ $name = $t;
+ $value = $count++;
+ $without_val = 1;
+ die ("you can't mix enum member with values and without values when using --uint-enums!")
+ unless ($with_val == 0);
+ }
+ pidl "#define $name ( $value )\n";
+ }
+ pidl "\n";
+ }
+}
+
+#####################################################################
+# parse a bitmap
+sub HeaderBitmap($$)
+{
+ my($bitmap,$name) = @_;
+
+ pidl "/* bitmap $name */\n";
+ pidl "#define $_\n" foreach (@{$bitmap->{ELEMENTS}});
+ pidl "\n";
+}
+
+#####################################################################
+# parse a union
+sub HeaderUnion($$)
+{
+ my($union,$name) = @_;
+ my %done = ();
+
+ pidl "union $name {\n";
+ $tab_depth++;
+ foreach my $e (@{$union->{ELEMENTS}}) {
+ if ($e->{TYPE} ne "EMPTY") {
+ if (! defined $done{$e->{NAME}}) {
+ HeaderElement($e);
+ }
+ $done{$e->{NAME}} = 1;
+ }
+ }
+ $tab_depth--;
+ pidl "}";
+
+ if (defined $union->{PROPERTIES}) {
+ HeaderProperties($union->{PROPERTIES}, []);
+ }
+}
+
+#####################################################################
+# parse a type
+sub HeaderType($$$)
+{
+ my($e,$data,$name) = @_;
+ if (ref($data) eq "HASH") {
+ ($data->{TYPE} eq "ENUM") && HeaderEnum($data, $name);
+ ($data->{TYPE} eq "BITMAP") && HeaderBitmap($data, $name);
+ ($data->{TYPE} eq "STRUCT") && HeaderStruct($data, $name);
+ ($data->{TYPE} eq "UNION") && HeaderUnion($data, $name);
+ return;
+ }
+
+ if (has_property($e, "charset")) {
+ pidl "const char";
+ } else {
+ pidl mapType($e->{TYPE});
+ }
+}
+
+#####################################################################
+# parse a typedef
+sub HeaderTypedef($)
+{
+ my($typedef) = shift;
+ HeaderType($typedef, $typedef->{DATA}, $typedef->{NAME});
+ pidl ";\n\n" unless ($typedef->{DATA}->{TYPE} eq "BITMAP");
+}
+
+#####################################################################
+# parse a const
+sub HeaderConst($)
+{
+ my($const) = shift;
+ if (!defined($const->{ARRAY_LEN}[0])) {
+ pidl "#define $const->{NAME}\t( $const->{VALUE} )\n";
+ } else {
+ pidl "#define $const->{NAME}\t $const->{VALUE}\n";
+ }
+}
+
+#####################################################################
+# parse a function
+sub HeaderFunctionInOut($$)
+{
+ my($fn,$prop) = @_;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (has_property($e, $prop)) {
+ HeaderElement($e);
+ }
+ }
+}
+
+#####################################################################
+# determine if we need an "in" or "out" section
+sub HeaderFunctionInOut_needed($$)
+{
+ my($fn,$prop) = @_;
+
+ return 1 if ($prop eq "out" && $fn->{RETURN_TYPE} ne "void");
+
+ foreach (@{$fn->{ELEMENTS}}) {
+ return 1 if (has_property($_, $prop));
+ }
+
+ return undef;
+}
+
+my %headerstructs = ();
+
+#####################################################################
+# parse a function
+sub HeaderFunction($)
+{
+ my($fn) = shift;
+
+ return if ($headerstructs{$fn->{NAME}});
+
+ $headerstructs{$fn->{NAME}} = 1;
+
+ pidl "\nstruct $fn->{NAME} {\n";
+ $tab_depth++;
+ my $needed = 0;
+
+ if (HeaderFunctionInOut_needed($fn, "in")) {
+ pidl tabs()."struct {\n";
+ $tab_depth++;
+ HeaderFunctionInOut($fn, "in");
+ $tab_depth--;
+ pidl tabs()."} in;\n\n";
+ $needed++;
+ }
+
+ if (HeaderFunctionInOut_needed($fn, "out")) {
+ pidl tabs()."struct {\n";
+ $tab_depth++;
+ HeaderFunctionInOut($fn, "out");
+ if ($fn->{RETURN_TYPE} ne "void") {
+ pidl tabs().mapType($fn->{RETURN_TYPE}) . " result;\n";
+ }
+ $tab_depth--;
+ pidl tabs()."} out;\n\n";
+ $needed++;
+ }
+
+ if (! $needed) {
+ # sigh - some compilers don't like empty structures
+ pidl tabs()."int _dummy_element;\n";
+ }
+
+ $tab_depth--;
+ pidl "};\n\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+ my($interface) = shift;
+
+ my $count = 0;
+
+ pidl "#ifndef _HEADER_$interface->{NAME}\n";
+ pidl "#define _HEADER_$interface->{NAME}\n\n";
+
+ if (defined $interface->{PROPERTIES}->{depends}) {
+ my @d = split / /, $interface->{PROPERTIES}->{depends};
+ foreach my $i (@d) {
+ pidl "#include \"librpc/gen_ndr/$i\.h\"\n";
+ }
+ }
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if ($d->{TYPE} ne "CONST");
+ HeaderConst($d);
+ }
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if ($d->{TYPE} ne "TYPEDEF");
+ HeaderTypedef($d);
+ }
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if ($d->{TYPE} ne "FUNCTION");
+ HeaderFunction($d);
+ }
+
+ pidl "#endif /* _HEADER_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($)
+{
+ my($idl) = shift;
+ $tab_depth = 0;
+
+ $res = "";
+ pidl "/* header auto-generated by pidl */\n\n";
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+ }
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/NDR/Client.pm b/source4/pidl/Parse/Pidl/Samba/NDR/Client.pm
new file mode 100644
index 0000000000..126dbc3ba9
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/NDR/Client.pm
@@ -0,0 +1,99 @@
+###################################################
+# client calls generator
+# Copyright tridge@samba.org 2003
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Client;
+
+use strict;
+
+my($res);
+
+#####################################################################
+# parse a function
+sub ParseFunction($$)
+{
+ my ($interface, $fn) = @_;
+ my $name = $fn->{NAME};
+ my $uname = uc $name;
+
+ $res .= "
+struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)
+{
+ if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
+ NDR_PRINT_IN_DEBUG($name, r);
+ }
+
+ return dcerpc_ndr_request_send(p, NULL, &dcerpc_table_$interface->{NAME}, DCERPC_$uname, mem_ctx, r);
+}
+
+NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)
+{
+ struct rpc_request *req;
+ NTSTATUS status;
+
+ req = dcerpc_$name\_send(p, mem_ctx, r);
+ if (req == NULL) return NT_STATUS_NO_MEMORY;
+
+ status = dcerpc_ndr_request_recv(req);
+
+ if (NT_STATUS_IS_OK(status) && (p->conn->flags & DCERPC_DEBUG_PRINT_OUT)) {
+ NDR_PRINT_OUT_DEBUG($name, r);
+ }
+";
+
+ if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
+ $res .= "\tif (NT_STATUS_IS_OK(status)) status = r->out.result;\n";
+ }
+ $res .=
+"
+ return status;
+}
+";
+}
+
+my %done;
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($)
+{
+ my($interface) = shift;
+ $res .= "/* $interface->{NAME} - client functions generated by pidl */\n\n";
+
+ foreach my $fn (@{$interface->{FUNCTIONS}}) {
+ next if not defined($fn->{OPNUM});
+ next if defined($done{$fn->{NAME}});
+ ParseFunction($interface, $fn);
+ $done{$fn->{NAME}} = 1;
+ }
+
+ return $res;
+}
+
+sub Parse($$)
+{
+ my($ndr) = shift;
+ my($filename) = shift;
+
+ my $h_filename = $filename;
+ $res = "";
+
+ if ($h_filename =~ /(.*)\.c/) {
+ $h_filename = "$1.h";
+ }
+
+ $res .= "/* client functions auto-generated by pidl */\n";
+ $res .= "\n";
+ $res .= "#include \"includes.h\"\n";
+ $res .= "#include \"$h_filename\"\n";
+ $res .= "\n";
+
+ foreach my $x (@{$ndr}) {
+ ($x->{TYPE} eq "INTERFACE") && ParseInterface($x);
+ }
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/NDR/Header.pm b/source4/pidl/Parse/Pidl/Samba/NDR/Header.pm
new file mode 100644
index 0000000000..9aa0ed8daf
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/NDR/Header.pm
@@ -0,0 +1,166 @@
+###################################################
+# create C header files for an IDL structure
+# Copyright tridge@samba.org 2000
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Header;
+
+use strict;
+use Parse::Pidl::Typelist qw(mapType);
+use Parse::Pidl::Util qw(has_property is_constant);
+use Parse::Pidl::NDR qw(GetNextLevel GetPrevLevel);
+use Parse::Pidl::Samba::NDR::Parser;
+
+my($res);
+my($tab_depth);
+
+sub pidl ($)
+{
+ $res .= shift;
+}
+
+sub tabs()
+{
+ my $res = "";
+ $res .="\t" foreach (1..$tab_depth);
+ return $res;
+}
+
+#####################################################################
+# prototype a typedef
+sub HeaderTypedefProto($)
+{
+ my($d) = shift;
+
+ my $tf = Parse::Pidl::Samba::NDR::Parser::get_typefamily($d->{DATA}{TYPE});
+
+ if (has_property($d, "gensize")) {
+ my $size_args = $tf->{SIZE_FN_ARGS}->($d);
+ pidl "size_t ndr_size_$d->{NAME}($size_args);\n";
+ }
+
+ return unless has_property($d, "public");
+
+ unless (has_property($d, "nopush")) {
+ pidl "NTSTATUS ndr_push_$d->{NAME}(struct ndr_push *ndr, int ndr_flags, " . $tf->{DECL}->($d, "push") . ");\n";
+ }
+ unless (has_property($d, "nopull")) {
+ pidl "NTSTATUS ndr_pull_$d->{NAME}(struct ndr_pull *ndr, int ndr_flags, " . $tf->{DECL}->($d, "pull") . ");\n";
+ }
+ unless (has_property($d, "noprint")) {
+ pidl "void ndr_print_$d->{NAME}(struct ndr_print *ndr, const char *name, " . $tf->{DECL}->($d, "print") . ");\n";
+ }
+}
+
+#####################################################################
+# output prototypes for a IDL function
+sub HeaderFnProto($$)
+{
+ my ($interface,$fn) = @_;
+ my $name = $fn->{NAME};
+
+ pidl "void ndr_print_$name(struct ndr_print *ndr, const char *name, int flags, const struct $name *r);\n";
+
+ unless (has_property($fn, "noopnum")) {
+ pidl "NTSTATUS dcerpc_$name(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
+ pidl "struct rpc_request *dcerpc_$name\_send(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r);\n";
+ }
+
+ return unless has_property($fn, "public");
+
+ pidl "NTSTATUS ndr_push_$name(struct ndr_push *ndr, int flags, const struct $name *r);\n";
+ pidl "NTSTATUS ndr_pull_$name(struct ndr_pull *ndr, int flags, struct $name *r);\n";
+
+ pidl "\n";
+}
+
+#####################################################################
+# parse the interface definitions
+sub HeaderInterface($)
+{
+ my($interface) = shift;
+
+ if (defined $interface->{PROPERTIES}->{depends}) {
+ my @d = split / /, $interface->{PROPERTIES}->{depends};
+ foreach my $i (@d) {
+ pidl "#include \"librpc/gen_ndr/ndr_$i\.h\"\n";
+ }
+ }
+
+ my $count = 0;
+
+ pidl "#ifndef _HEADER_NDR_$interface->{NAME}\n";
+ pidl "#define _HEADER_NDR_$interface->{NAME}\n\n";
+
+ if (defined $interface->{PROPERTIES}->{uuid}) {
+ my $name = uc $interface->{NAME};
+ pidl "#define DCERPC_$name\_UUID " .
+ Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid}) . "\n";
+
+ if(!defined $interface->{PROPERTIES}->{version}) { $interface->{PROPERTIES}->{version} = "0.0"; }
+ pidl "#define DCERPC_$name\_VERSION $interface->{PROPERTIES}->{version}\n";
+
+ pidl "#define DCERPC_$name\_NAME \"$interface->{NAME}\"\n";
+
+ if(!defined $interface->{PROPERTIES}->{helpstring}) { $interface->{PROPERTIES}->{helpstring} = "NULL"; }
+ pidl "#define DCERPC_$name\_HELPSTRING $interface->{PROPERTIES}->{helpstring}\n";
+
+ pidl "\nextern const struct dcerpc_interface_table dcerpc_table_$interface->{NAME};\n";
+ pidl "NTSTATUS dcerpc_server_$interface->{NAME}_init(void);\n\n";
+ }
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if $d->{TYPE} ne "FUNCTION";
+ next if has_property($d, "noopnum");
+ next if grep(/$d->{NAME}/,@{$interface->{INHERITED_FUNCTIONS}});
+ my $u_name = uc $d->{NAME};
+ pidl "#define DCERPC_$u_name (";
+
+ if (defined($interface->{BASE})) {
+ pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
+ }
+
+ pidl sprintf("0x%02x", $count) . ")\n";
+ $count++;
+ }
+
+ pidl "\n#define DCERPC_" . uc $interface->{NAME} . "_CALL_COUNT (";
+
+ if (defined($interface->{BASE})) {
+ pidl "DCERPC_" . uc $interface->{BASE} . "_CALL_COUNT + ";
+ }
+
+ pidl "$count)\n\n";
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if ($d->{TYPE} ne "TYPEDEF");
+ HeaderTypedefProto($d);
+ }
+
+ foreach my $d (@{$interface->{DATA}}) {
+ next if ($d->{TYPE} ne "FUNCTION");
+ HeaderFnProto($interface, $d);
+ }
+
+ pidl "#endif /* _HEADER_NDR_$interface->{NAME} */\n";
+}
+
+#####################################################################
+# parse a parsed IDL into a C header
+sub Parse($$)
+{
+ my($idl,$basename) = @_;
+ $tab_depth = 0;
+
+ $res = "";
+ pidl "/* header auto-generated by pidl */\n";
+ pidl "#include \"librpc/gen_ndr/$basename\.h\"\n\n";
+
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") && HeaderInterface($x);
+ }
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/NDR/Parser.pm b/source4/pidl/Parse/Pidl/Samba/NDR/Parser.pm
new file mode 100644
index 0000000000..ef22ff9788
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/NDR/Parser.pm
@@ -0,0 +1,2341 @@
+###################################################
+# Samba4 NDR parser generator for IDL structures
+# Copyright tridge@samba.org 2000-2003
+# Copyright tpot@samba.org 2001
+# Copyright jelmer@samba.org 2004-2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Parser;
+
+use strict;
+use Parse::Pidl::Typelist qw(hasType getType mapType);
+use Parse::Pidl::Util qw(has_property ParseExpr);
+use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
+
+# list of known types
+my %typefamily;
+
+sub get_typefamily($)
+{
+ my $n = shift;
+ return $typefamily{$n};
+}
+
+sub append_prefix($$)
+{
+ my ($e, $var_name) = @_;
+ my $pointers = 0;
+
+ foreach my $l (@{$e->{LEVELS}}) {
+ if ($l->{TYPE} eq "POINTER") {
+ $pointers++;
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ if (($pointers == 0) and
+ (not $l->{IS_FIXED}) and
+ (not $l->{IS_INLINE})) {
+ return get_value_of($var_name);
+ }
+ } elsif ($l->{TYPE} eq "DATA") {
+ if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+ return get_value_of($var_name) unless ($pointers);
+ }
+ }
+ }
+
+ return $var_name;
+}
+
+sub has_fast_array($$)
+{
+ my ($e,$l) = @_;
+
+ return 0 if ($l->{TYPE} ne "ARRAY");
+
+ my $nl = GetNextLevel($e,$l);
+ return 0 unless ($nl->{TYPE} eq "DATA");
+ return 0 unless (hasType($nl->{DATA_TYPE}));
+
+ my $t = getType($nl->{DATA_TYPE});
+
+ # Only uint8 and string have fast array functions at the moment
+ return ($t->{NAME} eq "uint8") or ($t->{NAME} eq "string");
+}
+
+sub is_charset_array($$)
+{
+ my ($e,$l) = @_;
+
+ return 0 if ($l->{TYPE} ne "ARRAY");
+
+ my $nl = GetNextLevel($e,$l);
+
+ return 0 unless ($nl->{TYPE} eq "DATA");
+
+ return has_property($e, "charset");
+}
+
+sub get_pointer_to($)
+{
+ my $var_name = shift;
+
+ if ($var_name =~ /^\*(.*)$/) {
+ return $1;
+ } elsif ($var_name =~ /^\&(.*)$/) {
+ return "&($var_name)";
+ } else {
+ return "&$var_name";
+ }
+}
+
+sub get_value_of($)
+{
+ my $var_name = shift;
+
+ if ($var_name =~ /^\&(.*)$/) {
+ return $1;
+ } else {
+ return "*$var_name";
+ }
+}
+
+my $res = "";
+my $deferred = "";
+my $tabs = "";
+
+####################################
+# pidl() is our basic output routine
+sub pidl($)
+{
+ my $d = shift;
+ if ($d) {
+ $res .= $tabs;
+ $res .= $d;
+ }
+ $res .="\n";
+}
+
+####################################
+# defer() is like pidl(), but adds to
+# a deferred buffer which is then added to the
+# output buffer at the end of the structure/union/function
+# This is needed to cope with code that must be pushed back
+# to the end of a block of elements
+sub defer($)
+{
+ my $d = shift;
+ if ($d) {
+ $deferred .= $tabs;
+ $deferred .= $d;
+ }
+ $deferred .="\n";
+}
+
+########################################
+# add the deferred content to the current
+# output
+sub add_deferred()
+{
+ $res .= $deferred;
+ $deferred = "";
+}
+
+sub indent()
+{
+ $tabs .= "\t";
+}
+
+sub deindent()
+{
+ $tabs = substr($tabs, 0, -1);
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+sub check_null_pointer($)
+{
+ my $size = shift;
+ if ($size =~ /^\*/) {
+ my $size2 = substr($size, 1);
+ pidl "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
+ }
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer,
+# putting the check at the end of the structure/function
+sub check_null_pointer_deferred($)
+{
+ my $size = shift;
+ if ($size =~ /^\*/) {
+ my $size2 = substr($size, 1);
+ defer "if ($size2 == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;";
+ }
+}
+
+#####################################################################
+# check that a variable we get from ParseExpr isn't a null pointer
+# void return varient
+sub check_null_pointer_void($)
+{
+ my $size = shift;
+ if ($size =~ /^\*/) {
+ my $size2 = substr($size, 1);
+ pidl "if ($size2 == NULL) return;";
+ }
+}
+
+#####################################################################
+# work out is a parse function should be declared static or not
+sub fn_prefix($)
+{
+ my $fn = shift;
+
+ return "" if (has_property($fn, "public"));
+ return "static ";
+}
+
+###################################################################
+# setup any special flags for an element or structure
+sub start_flags($)
+{
+ my $e = shift;
+ my $flags = has_property($e, "flag");
+ if (defined $flags) {
+ pidl "{";
+ indent;
+ pidl "uint32_t _flags_save_$e->{TYPE} = ndr->flags;";
+ pidl "ndr_set_flags(&ndr->flags, $flags);";
+ }
+}
+
+###################################################################
+# end any special flags for an element or structure
+sub end_flags($)
+{
+ my $e = shift;
+ my $flags = has_property($e, "flag");
+ if (defined $flags) {
+ pidl "ndr->flags = _flags_save_$e->{TYPE};";
+ deindent;
+ pidl "}";
+ }
+}
+
+sub GenerateStructEnv($)
+{
+ my $x = shift;
+ my %env;
+
+ foreach my $e (@{$x->{ELEMENTS}}) {
+ $env{$e->{NAME}} = "r->$e->{NAME}";
+ }
+
+ $env{"this"} = "r";
+
+ return \%env;
+}
+
+sub GenerateFunctionInEnv($)
+{
+ my $fn = shift;
+ my %env;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep (/in/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->in.$e->{NAME}";
+ }
+ }
+
+ return \%env;
+}
+
+sub GenerateFunctionOutEnv($)
+{
+ my $fn = shift;
+ my %env;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep (/out/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->out.$e->{NAME}";
+ } elsif (grep (/in/, @{$e->{DIRECTION}})) {
+ $env{$e->{NAME}} = "r->in.$e->{NAME}";
+ }
+ }
+
+ return \%env;
+}
+
+#####################################################################
+# parse the data of an array - push side
+sub ParseArrayPushHeader($$$$$)
+{
+ my ($e,$l,$ndr,$var_name,$env) = @_;
+
+ my $size;
+ my $length;
+
+ if ($l->{IS_ZERO_TERMINATED}) {
+ $size = $length = "ndr_string_length($var_name, sizeof(*$var_name))";
+ } else {
+ $size = ParseExpr($l->{SIZE_IS}, $env);
+ $length = ParseExpr($l->{LENGTH_IS}, $env);
+ }
+
+ if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
+ pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $size));";
+ }
+
+ if ($l->{IS_VARYING}) {
+ pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, 0));"; # array offset
+ pidl "NDR_CHECK(ndr_push_uint32($ndr, NDR_SCALARS, $length));";
+ }
+
+ return $length;
+}
+
+#####################################################################
+# parse an array - pull side
+sub ParseArrayPullHeader($$$$$)
+{
+ my ($e,$l,$ndr,$var_name,$env) = @_;
+
+ my $length;
+ my $size;
+
+ if ($l->{IS_CONFORMANT}) {
+ $length = $size = "ndr_get_array_size($ndr, " . get_pointer_to($var_name) . ")";
+ } elsif ($l->{IS_ZERO_TERMINATED}) { # Noheader arrays
+ $length = $size = "ndr_get_string_size($ndr, sizeof(*$var_name))";
+ } else {
+ $length = $size = ParseExpr($l->{SIZE_IS}, $env);
+ }
+
+ if ((!$l->{IS_SURROUNDING}) and $l->{IS_CONFORMANT}) {
+ pidl "NDR_CHECK(ndr_pull_array_size(ndr, " . get_pointer_to($var_name) . "));";
+ }
+
+
+ if ($l->{IS_VARYING}) {
+ pidl "NDR_CHECK(ndr_pull_array_length($ndr, " . get_pointer_to($var_name) . "));";
+ $length = "ndr_get_array_length($ndr, " . get_pointer_to($var_name) .")";
+ }
+
+ check_null_pointer($length);
+
+ if ($length ne $size) {
+ pidl "if ($length > $size) {";
+ indent;
+ pidl "return ndr_pull_error($ndr, NDR_ERR_ARRAY_SIZE, \"Bad array size %u should exceed array length %u\", $size, $length);";
+ deindent;
+ pidl "}";
+ }
+
+ if ($l->{IS_CONFORMANT} and not $l->{IS_ZERO_TERMINATED}) {
+ my $size = ParseExpr($l->{SIZE_IS}, $env);
+ defer "if ($var_name) {";
+ check_null_pointer_deferred($size);
+ defer "NDR_CHECK(ndr_check_array_size(ndr, (void*)" . get_pointer_to($var_name) . ", $size));";
+ defer "}";
+ }
+
+ if ($l->{IS_VARYING} and not $l->{IS_ZERO_TERMINATED}) {
+ my $length = ParseExpr($l->{LENGTH_IS}, $env);
+ defer "if ($var_name) {";
+ check_null_pointer_deferred($length);
+ defer "NDR_CHECK(ndr_check_array_length(ndr, (void*)" . get_pointer_to($var_name) . ", $length));";
+ defer "}"
+ }
+
+ if (not $l->{IS_FIXED} and not is_charset_array($e, $l)) {
+ AllocateArrayLevel($e,$l,$ndr,$env,$size);
+ }
+
+ return $length;
+}
+
+sub compression_alg($$)
+{
+ my ($e,$l) = @_;
+ my $compression = $l->{COMPRESSION};
+ my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+ return $alg;
+}
+
+sub compression_clen($$$)
+{
+ my ($e,$l,$env) = @_;
+ my $compression = $l->{COMPRESSION};
+ my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+ return ParseExpr($clen, $env);
+}
+
+sub compression_dlen($$$)
+{
+ my ($e,$l,$env) = @_;
+ my $compression = $l->{COMPRESSION};
+ my ($alg, $clen, $dlen) = split(/ /, $compression);
+
+ return ParseExpr($dlen, $env);
+}
+
+sub ParseCompressionPushStart($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $comndr = "$ndr\_compressed";
+ my $alg = compression_alg($e, $l);
+ my $dlen = compression_dlen($e, $l, $env);
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_push *$comndr;";
+ pidl "NDR_CHECK(ndr_push_compression_start($ndr, &$comndr, $alg, $dlen));";
+
+ return $comndr;
+}
+
+sub ParseCompressionPushEnd($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $comndr = "$ndr\_compressed";
+ my $alg = compression_alg($e, $l);
+ my $dlen = compression_dlen($e, $l, $env);
+
+ pidl "NDR_CHECK(ndr_push_compression_end($ndr, $comndr, $alg, $dlen));";
+ deindent;
+ pidl "}";
+}
+
+sub ParseCompressionPullStart($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $comndr = "$ndr\_compressed";
+ my $alg = compression_alg($e, $l);
+ my $dlen = compression_dlen($e, $l, $env);
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_pull *$comndr;";
+ pidl "NDR_CHECK(ndr_pull_compression_start($ndr, &$comndr, $alg, $dlen));";
+
+ return $comndr;
+}
+
+sub ParseCompressionPullEnd($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $comndr = "$ndr\_compressed";
+ my $alg = compression_alg($e, $l);
+ my $dlen = compression_dlen($e, $l, $env);
+
+ pidl "NDR_CHECK(ndr_pull_compression_end($ndr, $comndr, $alg, $dlen));";
+ deindent;
+ pidl "}";
+}
+
+sub ParseObfuscationPushStart($$)
+{
+ my ($e,$ndr) = @_;
+ my $obfuscation = has_property($e, "obfuscation");
+
+ pidl "NDR_CHECK(ndr_push_obfuscation_start($ndr, $obfuscation));";
+
+ return $ndr;
+}
+
+sub ParseObfuscationPushEnd($$)
+{
+ my ($e,$ndr) = @_;
+ my $obfuscation = has_property($e, "obfuscation");
+
+ pidl "NDR_CHECK(ndr_push_obfuscation_end($ndr, $obfuscation));";
+}
+
+sub ParseObfuscationPullStart($$)
+{
+ my ($e,$ndr) = @_;
+ my $obfuscation = has_property($e, "obfuscation");
+
+ pidl "NDR_CHECK(ndr_pull_obfuscation_start($ndr, $obfuscation));";
+
+ return $ndr;
+}
+
+sub ParseObfuscationPullEnd($$)
+{
+ my ($e,$ndr) = @_;
+ my $obfuscation = has_property($e, "obfuscation");
+
+ pidl "NDR_CHECK(ndr_pull_obfuscation_end($ndr, $obfuscation));";
+}
+
+sub ParseSubcontextPushStart($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $subndr = "_ndr_$e->{NAME}";
+ my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_push *$subndr;";
+ pidl "NDR_CHECK(ndr_push_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+
+ if (defined $l->{COMPRESSION}) {
+ $subndr = ParseCompressionPushStart($e, $l, $subndr, $env);
+ }
+
+ if (defined $l->{OBFUSCATION}) {
+ $subndr = ParseObfuscationPushStart($e, $subndr);
+ }
+
+ return $subndr;
+}
+
+sub ParseSubcontextPushEnd($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $subndr = "_ndr_$e->{NAME}";
+ my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+ if (defined $l->{COMPRESSION}) {
+ ParseCompressionPushEnd($e, $l, $subndr, $env);
+ }
+
+ if (defined $l->{OBFUSCATION}) {
+ ParseObfuscationPushEnd($e, $subndr);
+ }
+
+ pidl "NDR_CHECK(ndr_push_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+ deindent;
+ pidl "}";
+}
+
+sub ParseSubcontextPullStart($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $subndr = "_ndr_$e->{NAME}";
+ my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+ pidl "{";
+ indent;
+ pidl "struct ndr_pull *$subndr;";
+ pidl "NDR_CHECK(ndr_pull_subcontext_start($ndr, &$subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+
+ if (defined $l->{COMPRESSION}) {
+ $subndr = ParseCompressionPullStart($e, $l, $subndr, $env);
+ }
+
+ if (defined $l->{OBFUSCATION}) {
+ $subndr = ParseObfuscationPullStart($e, $subndr);
+ }
+
+ return $subndr;
+}
+
+sub ParseSubcontextPullEnd($$$$)
+{
+ my ($e,$l,$ndr,$env) = @_;
+ my $subndr = "_ndr_$e->{NAME}";
+ my $subcontext_size = ParseExpr($l->{SUBCONTEXT_SIZE},$env);
+
+ if (defined $l->{COMPRESSION}) {
+ ParseCompressionPullEnd($e, $l, $subndr, $env);
+ }
+
+ if (defined $l->{OBFUSCATION}) {
+ ParseObfuscationPullEnd($e, $subndr);
+ }
+
+ pidl "NDR_CHECK(ndr_pull_subcontext_end($ndr, $subndr, $l->{HEADER_SIZE}, $subcontext_size));";
+ deindent;
+ pidl "}";
+}
+
+sub ParseElementPushLevel
+{
+ my ($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+ my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+ if ($l->{TYPE} eq "ARRAY" and ($l->{IS_CONFORMANT} or $l->{IS_VARYING}
+ or is_charset_array($e, $l))) {
+ $var_name = get_pointer_to($var_name);
+ }
+
+ if (defined($ndr_flags)) {
+ if ($l->{TYPE} eq "SUBCONTEXT") {
+ my $subndr = ParseSubcontextPushStart($e, $l, $ndr, $env);
+ ParseElementPushLevel($e, GetNextLevel($e, $l), $subndr, $var_name, $env, 1, 1);
+ ParseSubcontextPushEnd($e, $l, $ndr, $env);
+ } elsif ($l->{TYPE} eq "POINTER") {
+ ParsePtrPush($e, $l, $var_name);
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ my $length = ParseArrayPushHeader($e, $l, $ndr, $var_name, $env);
+
+ my $nl = GetNextLevel($e, $l);
+
+ # Allow speedups for arrays of scalar types
+ if (is_charset_array($e,$l)) {
+ pidl "NDR_CHECK(ndr_push_charset($ndr, $ndr_flags, $var_name, $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+ return;
+ } elsif (has_fast_array($e,$l)) {
+ pidl "NDR_CHECK(ndr_push_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
+ return;
+ }
+ } elsif ($l->{TYPE} eq "SWITCH") {
+ ParseSwitchPush($e, $l, $ndr, $var_name, $ndr_flags, $env);
+ } elsif ($l->{TYPE} eq "DATA") {
+ ParseDataPush($e, $l, $ndr, $var_name, $ndr_flags);
+ }
+ }
+
+ if ($l->{TYPE} eq "POINTER" and $deferred) {
+ if ($l->{POINTER_TYPE} ne "ref") {
+ pidl "if ($var_name) {";
+ indent;
+ if ($l->{POINTER_TYPE} eq "relative") {
+ pidl "NDR_CHECK(ndr_push_relative_ptr2(ndr, $var_name));";
+ }
+ }
+ $var_name = get_value_of($var_name);
+ ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 1);
+
+ if ($l->{POINTER_TYPE} ne "ref") {
+ deindent;
+ pidl "}";
+ }
+ } elsif ($l->{TYPE} eq "ARRAY" and not has_fast_array($e,$l) and
+ not is_charset_array($e, $l)) {
+ my $length = ParseExpr($l->{LENGTH_IS}, $env);
+ my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+ $var_name = $var_name . "[$counter]";
+
+ if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+ pidl "for ($counter = 0; $counter < $length; $counter++) {";
+ indent;
+ ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 1, 0);
+ deindent;
+ pidl "}";
+ }
+
+ if ($deferred and ContainsDeferred($e, $l)) {
+ pidl "for ($counter = 0; $counter < $length; $counter++) {";
+ indent;
+ ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, 0, 1);
+ deindent;
+ pidl "}";
+ }
+ } elsif ($l->{TYPE} eq "SWITCH") {
+ ParseElementPushLevel($e, GetNextLevel($e, $l), $ndr, $var_name, $env, $primitives, $deferred);
+ }
+}
+
+#####################################################################
+# parse scalars in a structure element
+sub ParseElementPush($$$$$$)
+{
+ my ($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
+ my $subndr = undef;
+
+ my $var_name = $var_prefix.$e->{NAME};
+
+ $var_name = append_prefix($e, $var_name);
+
+ return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
+
+ start_flags($e);
+
+ if (my $value = has_property($e, "value")) {
+ $var_name = ParseExpr($value, $env);
+ }
+
+ ParseElementPushLevel($e, $e->{LEVELS}[0], $ndr, $var_name, $env, $primitives, $deferred);
+
+ end_flags($e);
+}
+
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPush($$$)
+{
+ my ($e,$l,$var_name) = @_;
+
+ if ($l->{POINTER_TYPE} eq "ref") {
+ if ($l->{LEVEL} eq "EMBEDDED") {
+ pidl "NDR_CHECK(ndr_push_ref_ptr(ndr, $var_name));";
+ } else {
+ check_null_pointer(get_value_of($var_name));
+ }
+ } elsif ($l->{POINTER_TYPE} eq "relative") {
+ pidl "NDR_CHECK(ndr_push_relative_ptr1(ndr, $var_name));";
+ } elsif ($l->{POINTER_TYPE} eq "unique") {
+ pidl "NDR_CHECK(ndr_push_unique_ptr(ndr, $var_name));";
+ } elsif ($l->{POINTER_TYPE} eq "sptr") {
+ pidl "NDR_CHECK(ndr_push_sptr_ptr(ndr, $var_name));";
+ } else {
+ die("Unhandled pointer type $l->{POINTER_TYPE}");
+ }
+}
+
+#####################################################################
+# print scalars in a structure element
+sub ParseElementPrint($$$)
+{
+ my($e,$var_name,$env) = @_;
+
+ $var_name = append_prefix($e, $var_name);
+ return if (has_property($e, "noprint"));
+
+ if (my $value = has_property($e, "value")) {
+ $var_name = "(ndr->flags & LIBNDR_PRINT_SET_VALUES)?" . ParseExpr($value,$env) . ":$var_name";
+ }
+
+ foreach my $l (@{$e->{LEVELS}}) {
+ if ($l->{TYPE} eq "POINTER") {
+ pidl "ndr_print_ptr(ndr, \"$e->{NAME}\", $var_name);";
+ pidl "ndr->depth++;";
+ if ($l->{POINTER_TYPE} ne "ref") {
+ pidl "if ($var_name) {";
+ indent;
+ }
+ $var_name = get_value_of($var_name);
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ my $length;
+
+ if ($l->{IS_CONFORMANT} or $l->{IS_VARYING} or
+ is_charset_array($e,$l)) {
+ $var_name = get_pointer_to($var_name);
+ }
+
+ if ($l->{IS_ZERO_TERMINATED}) {
+ $length = "ndr_string_length($var_name, sizeof(*$var_name))";
+ } else {
+ $length = ParseExpr($l->{LENGTH_IS}, $env);
+ }
+
+ if (is_charset_array($e,$l)) {
+ pidl "ndr_print_string(ndr, \"$e->{NAME}\", $var_name);";
+ last;
+ } elsif (has_fast_array($e, $l)) {
+ my $nl = GetNextLevel($e, $l);
+ pidl "ndr_print_array_$nl->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name, $length);";
+ last;
+ } else {
+ my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+
+ pidl "ndr->print(ndr, \"\%s: ARRAY(\%d)\", \"$e->{NAME}\", $length);";
+ pidl 'ndr->depth++;';
+ pidl "for ($counter=0;$counter<$length;$counter++) {";
+ indent;
+ pidl "char *idx_$l->{LEVEL_INDEX}=NULL;";
+ pidl "asprintf(&idx_$l->{LEVEL_INDEX}, \"[\%d]\", $counter);";
+ pidl "if (idx_$l->{LEVEL_INDEX}) {";
+ indent;
+
+ $var_name = $var_name . "[$counter]";
+ }
+ } elsif ($l->{TYPE} eq "DATA") {
+ if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+ $var_name = get_pointer_to($var_name);
+ }
+ pidl "ndr_print_$l->{DATA_TYPE}(ndr, \"$e->{NAME}\", $var_name);";
+ } elsif ($l->{TYPE} eq "SWITCH") {
+ my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+ check_null_pointer_void($switch_var);
+ pidl "ndr_print_set_switch_value(ndr, " . get_pointer_to($var_name) . ", $switch_var);";
+ }
+ }
+
+ foreach my $l (reverse @{$e->{LEVELS}}) {
+ if ($l->{TYPE} eq "POINTER") {
+ if ($l->{POINTER_TYPE} ne "ref") {
+ deindent;
+ pidl "}";
+ }
+ pidl "ndr->depth--;";
+ } elsif (($l->{TYPE} eq "ARRAY")
+ and not is_charset_array($e,$l)
+ and not has_fast_array($e,$l)) {
+ pidl "free(idx_$l->{LEVEL_INDEX});";
+ deindent;
+ pidl "}";
+ deindent;
+ pidl "}";
+ pidl "ndr->depth--;";
+ }
+ }
+}
+
+#####################################################################
+# parse scalars in a structure element - pull size
+sub ParseSwitchPull($$$$$$)
+{
+ my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
+ my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+
+ check_null_pointer($switch_var);
+
+ $var_name = get_pointer_to($var_name);
+ pidl "NDR_CHECK(ndr_pull_set_switch_value($ndr, $var_name, $switch_var));";
+}
+
+#####################################################################
+# push switch element
+sub ParseSwitchPush($$$$$$)
+{
+ my($e,$l,$ndr,$var_name,$ndr_flags,$env) = @_;
+ my $switch_var = ParseExpr($l->{SWITCH_IS}, $env);
+
+ check_null_pointer($switch_var);
+ $var_name = get_pointer_to($var_name);
+ pidl "NDR_CHECK(ndr_push_set_switch_value($ndr, $var_name, $switch_var));";
+}
+
+sub ParseDataPull($$$$$)
+{
+ my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
+
+ if (Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+ $var_name = get_pointer_to($var_name);
+ }
+
+ $var_name = get_pointer_to($var_name);
+
+ pidl "NDR_CHECK(ndr_pull_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
+
+ if (my $range = has_property($e, "range")) {
+ $var_name = get_value_of($var_name);
+ my ($low, $high) = split(/ /, $range, 2);
+ pidl "if ($var_name < $low || $var_name > $high) {";
+ pidl "\treturn ndr_pull_error($ndr, NDR_ERR_RANGE, \"value out of range\");";
+ pidl "}";
+ }
+}
+
+sub ParseDataPush($$$$$)
+{
+ my ($e,$l,$ndr,$var_name,$ndr_flags) = @_;
+
+ # strings are passed by value rather then reference
+ if (not Parse::Pidl::Typelist::is_scalar($l->{DATA_TYPE}) or Parse::Pidl::Typelist::scalar_is_reference($l->{DATA_TYPE})) {
+ $var_name = get_pointer_to($var_name);
+ }
+
+ pidl "NDR_CHECK(ndr_push_$l->{DATA_TYPE}($ndr, $ndr_flags, $var_name));";
+}
+
+sub CalcNdrFlags($$$)
+{
+ my ($l,$primitives,$deferred) = @_;
+
+ my $scalars = 0;
+ my $buffers = 0;
+
+ # Add NDR_SCALARS if this one is deferred
+ # and deferreds may be pushed
+ $scalars = 1 if ($l->{IS_DEFERRED} and $deferred);
+
+ # Add NDR_SCALARS if this one is not deferred and
+ # primitives may be pushed
+ $scalars = 1 if (!$l->{IS_DEFERRED} and $primitives);
+
+ # Add NDR_BUFFERS if this one contains deferred stuff
+ # and deferreds may be pushed
+ $buffers = 1 if ($l->{CONTAINS_DEFERRED} and $deferred);
+
+ return "NDR_SCALARS|NDR_BUFFERS" if ($scalars and $buffers);
+ return "NDR_SCALARS" if ($scalars);
+ return "NDR_BUFFERS" if ($buffers);
+ return undef;
+}
+
+sub ParseMemCtxPullStart($$$)
+{
+ my $e = shift;
+ my $l = shift;
+ my $ptr_name = shift;
+
+ my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
+ my $mem_c_ctx = $ptr_name;
+ my $mem_c_flags = "0";
+
+ return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
+
+ if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+ my $nl = GetNextLevel($e, $l);
+ my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+ my $next_is_string = (($nl->{TYPE} eq "DATA") and
+ ($nl->{DATA_TYPE} eq "string"));
+ if ($next_is_array or $next_is_string) {
+ return;
+ } else {
+ $mem_c_flags = "LIBNDR_FLAG_REF_ALLOC";
+ }
+ }
+
+ pidl "$mem_r_ctx = NDR_PULL_GET_MEM_CTX(ndr);";
+ pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_c_ctx, $mem_c_flags);";
+}
+
+sub ParseMemCtxPullEnd($$)
+{
+ my $e = shift;
+ my $l = shift;
+
+ my $mem_r_ctx = "_mem_save_$e->{NAME}_$l->{LEVEL_INDEX}";
+ my $mem_r_flags = "0";
+
+ return if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED});
+
+ if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+ my $nl = GetNextLevel($e, $l);
+ my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+ my $next_is_string = (($nl->{TYPE} eq "DATA") and
+ ($nl->{DATA_TYPE} eq "string"));
+ if ($next_is_array or $next_is_string) {
+ return;
+ } else {
+ $mem_r_flags = "LIBNDR_FLAG_REF_ALLOC";
+ }
+ }
+
+ pidl "NDR_PULL_SET_MEM_CTX(ndr, $mem_r_ctx, $mem_r_flags);";
+}
+
+sub ParseElementPullLevel
+{
+ my($e,$l,$ndr,$var_name,$env,$primitives,$deferred) = @_;
+
+ my $ndr_flags = CalcNdrFlags($l, $primitives, $deferred);
+
+ if ($l->{TYPE} eq "ARRAY" and ($l->{IS_VARYING} or $l->{IS_CONFORMANT}
+ or is_charset_array($e,$l))) {
+ $var_name = get_pointer_to($var_name);
+ }
+
+ # Only pull something if there's actually something to be pulled
+ if (defined($ndr_flags)) {
+ if ($l->{TYPE} eq "SUBCONTEXT") {
+ my $subndr = ParseSubcontextPullStart($e, $l, $ndr, $env);
+ ParseElementPullLevel($e, GetNextLevel($e,$l), $subndr, $var_name, $env, 1, 1);
+ ParseSubcontextPullEnd($e, $l, $ndr, $env);
+ } elsif ($l->{TYPE} eq "ARRAY") {
+ my $length = ParseArrayPullHeader($e, $l, $ndr, $var_name, $env);
+
+ my $nl = GetNextLevel($e, $l);
+
+ if (is_charset_array($e,$l)) {
+ pidl "NDR_CHECK(ndr_pull_charset($ndr, $ndr_flags, ".get_pointer_to($var_name).", $length, sizeof(" . mapType($nl->{DATA_TYPE}) . "), CH_$e->{PROPERTIES}->{charset}));";
+ return;
+ } elsif (has_fast_array($e, $l)) {
+ pidl "NDR_CHECK(ndr_pull_array_$nl->{DATA_TYPE}($ndr, $ndr_flags, $var_name, $length));";
+ if ($l->{IS_ZERO_TERMINATED}) {
+ # Make sure last element is zero!
+ pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
+ }
+ return;
+ }
+ } elsif ($l->{TYPE} eq "POINTER") {
+ ParsePtrPull($e, $l, $ndr, $var_name);
+ } elsif ($l->{TYPE} eq "SWITCH") {
+ ParseSwitchPull($e, $l, $ndr, $var_name, $ndr_flags, $env);
+ } elsif ($l->{TYPE} eq "DATA") {
+ ParseDataPull($e, $l, $ndr, $var_name, $ndr_flags);
+ }
+ }
+
+ # add additional constructions
+ if ($l->{TYPE} eq "POINTER" and $deferred) {
+ if ($l->{POINTER_TYPE} ne "ref") {
+ pidl "if ($var_name) {";
+ indent;
+
+ if ($l->{POINTER_TYPE} eq "relative") {
+ pidl "struct ndr_pull_save _relative_save;";
+ pidl "ndr_pull_save(ndr, &_relative_save);";
+ pidl "NDR_CHECK(ndr_pull_relative_ptr2(ndr, $var_name));";
+ }
+ }
+
+ ParseMemCtxPullStart($e,$l, $var_name);
+
+ $var_name = get_value_of($var_name);
+ ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 1);
+
+ ParseMemCtxPullEnd($e,$l);
+
+ if ($l->{POINTER_TYPE} ne "ref") {
+ if ($l->{POINTER_TYPE} eq "relative") {
+ pidl "ndr_pull_restore(ndr, &_relative_save);";
+ }
+ deindent;
+ pidl "}";
+ }
+ } elsif ($l->{TYPE} eq "ARRAY" and
+ not has_fast_array($e,$l) and not is_charset_array($e, $l)) {
+ my $length = ParseExpr($l->{LENGTH_IS}, $env);
+ my $counter = "cntr_$e->{NAME}_$l->{LEVEL_INDEX}";
+ my $array_name = $var_name;
+
+ $var_name = $var_name . "[$counter]";
+
+ ParseMemCtxPullStart($e,$l, $array_name);
+
+ if (($primitives and not $l->{IS_DEFERRED}) or ($deferred and $l->{IS_DEFERRED})) {
+ pidl "for ($counter = 0; $counter < $length; $counter++) {";
+ indent;
+ ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 1, 0);
+ deindent;
+ pidl "}";
+
+ if ($l->{IS_ZERO_TERMINATED}) {
+ # Make sure last element is zero!
+ pidl "NDR_CHECK(ndr_check_string_terminator($ndr, $var_name, $length, sizeof(*$var_name)));";
+ }
+ }
+
+ if ($deferred and ContainsDeferred($e, $l)) {
+ pidl "for ($counter = 0; $counter < $length; $counter++) {";
+ indent;
+ ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, 0, 1);
+ deindent;
+ pidl "}";
+ }
+
+ ParseMemCtxPullEnd($e,$l);
+
+ } elsif ($l->{TYPE} eq "SWITCH") {
+ ParseElementPullLevel($e,GetNextLevel($e,$l), $ndr, $var_name, $env, $primitives, $deferred);
+ }
+}
+
+#####################################################################
+# parse scalars in a structure element - pull size
+sub ParseElementPull($$$$$$)
+{
+ my($e,$ndr,$var_prefix,$env,$primitives,$deferred) = @_;
+
+ my $var_name = $var_prefix.$e->{NAME};
+
+ $var_name = append_prefix($e, $var_name);
+
+ return unless $primitives or ($deferred and ContainsDeferred($e, $e->{LEVELS}[0]));
+
+ start_flags($e);
+
+ ParseElementPullLevel($e,$e->{LEVELS}[0],$ndr,$var_name,$env,$primitives,$deferred);
+
+ end_flags($e);
+}
+
+#####################################################################
+# parse a pointer in a struct element or function
+sub ParsePtrPull($$$$)
+{
+ my($e,$l,$ndr,$var_name) = @_;
+
+ my $nl = GetNextLevel($e, $l);
+ my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+ my $next_is_string = (($nl->{TYPE} eq "DATA") and
+ ($nl->{DATA_TYPE} eq "string"));
+
+ if ($l->{POINTER_TYPE} eq "ref") {
+ unless ($l->{LEVEL} eq "TOP") {
+ pidl "NDR_CHECK(ndr_pull_ref_ptr($ndr, &_ptr_$e->{NAME}));";
+ }
+
+ unless ($next_is_array or $next_is_string) {
+ pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+ pidl "\tNDR_PULL_ALLOC($ndr, $var_name);";
+ pidl "}";
+ }
+
+ return;
+ } elsif (($l->{POINTER_TYPE} eq "unique") or
+ ($l->{POINTER_TYPE} eq "relative") or
+ ($l->{POINTER_TYPE} eq "sptr")) {
+ pidl "NDR_CHECK(ndr_pull_generic_ptr($ndr, &_ptr_$e->{NAME}));";
+ pidl "if (_ptr_$e->{NAME}) {";
+ indent;
+ } else {
+ die("Unhandled pointer type $l->{POINTER_TYPE}");
+ }
+
+ # Don't do this for arrays, they're allocated at the actual level
+ # of the array
+ unless ($next_is_array or $next_is_string) {
+ pidl "NDR_PULL_ALLOC($ndr, $var_name);";
+ } else {
+ # FIXME: Yes, this is nasty.
+ # We allocate an array twice
+ # - once just to indicate that it's there,
+ # - then the real allocation...
+ pidl "NDR_PULL_ALLOC_SIZE($ndr, $var_name, 1);";
+ }
+
+ #pidl "memset($var_name, 0, sizeof($var_name));";
+ if ($l->{POINTER_TYPE} eq "relative") {
+ pidl "NDR_CHECK(ndr_pull_relative_ptr1($ndr, $var_name, _ptr_$e->{NAME}));";
+ }
+ deindent;
+ pidl "} else {";
+ pidl "\t$var_name = NULL;";
+ pidl "}";
+}
+
+#####################################################################
+# parse a struct
+sub ParseStructPush($$)
+{
+ my($struct,$name) = @_;
+
+ return unless defined($struct->{ELEMENTS});
+
+ my $env = GenerateStructEnv($struct);
+
+ # save the old relative_base_offset
+ pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
+
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ DeclareArrayVariables($e);
+ }
+
+ start_flags($struct);
+
+ # see if the structure contains a conformant array. If it
+ # does, then it must be the last element of the structure, and
+ # we need to push the conformant length early, as it fits on
+ # the wire before the structure (and even before the structure
+ # alignment)
+ my $e = $struct->{ELEMENTS}[-1];
+ if (defined($struct->{SURROUNDING_ELEMENT})) {
+ my $e = $struct->{SURROUNDING_ELEMENT};
+
+ if (defined($e->{LEVELS}[0]) and
+ $e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
+ my $size = ParseExpr($e->{LEVELS}[0]->{SIZE_IS}, $env);
+
+ pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, $size));";
+ } else {
+ pidl "NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_string_array_size(ndr, r->$e->{NAME})));";
+ }
+ }
+
+ pidl "if (ndr_flags & NDR_SCALARS) {";
+ indent;
+
+ pidl "NDR_CHECK(ndr_push_align(ndr, $struct->{ALIGN}));";
+
+ if (defined($struct->{PROPERTIES}{relative_base})) {
+ # set the current offset as base for relative pointers
+ # and store it based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
+ }
+
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ ParseElementPush($e, "ndr", "r->", $env, 1, 0);
+ }
+
+ deindent;
+ pidl "}";
+
+ pidl "if (ndr_flags & NDR_BUFFERS) {";
+ indent;
+ if (defined($struct->{PROPERTIES}{relative_base})) {
+ # retrieve the current offset as base for relative pointers
+ # based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
+ }
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ ParseElementPush($e, "ndr", "r->", $env, 0, 1);
+ }
+
+ deindent;
+ pidl "}";
+
+ end_flags($struct);
+ # restore the old relative_base_offset
+ pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# generate a push function for an enum
+sub ParseEnumPush($$)
+{
+ my($enum,$name) = @_;
+ my($type_fn) = $enum->{BASE_TYPE};
+
+ start_flags($enum);
+ pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
+ end_flags($enum);
+}
+
+#####################################################################
+# generate a pull function for an enum
+sub ParseEnumPull($$)
+{
+ my($enum,$name) = @_;
+ my($type_fn) = $enum->{BASE_TYPE};
+ my($type_v_decl) = mapType($type_fn);
+
+ pidl "$type_v_decl v;";
+ start_flags($enum);
+ pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+ pidl "*r = v;";
+
+ end_flags($enum);
+}
+
+#####################################################################
+# generate a print function for an enum
+sub ParseEnumPrint($$)
+{
+ my($enum,$name) = @_;
+
+ pidl "const char *val = NULL;";
+ pidl "";
+
+ start_flags($enum);
+
+ pidl "switch (r) {";
+ indent;
+ my $els = \@{$enum->{ELEMENTS}};
+ foreach my $i (0 .. $#{$els}) {
+ my $e = ${$els}[$i];
+ chomp $e;
+ if ($e =~ /^(.*)=/) {
+ $e = $1;
+ }
+ pidl "case $e: val = \"$e\"; break;";
+ }
+
+ deindent;
+ pidl "}";
+
+ pidl "ndr_print_enum(ndr, name, \"$enum->{TYPE}\", val, r);";
+
+ end_flags($enum);
+}
+
+sub DeclEnum($)
+{
+ my ($e,$t) = @_;
+ return "enum $e->{NAME} " .
+ ($t eq "pull"?"*":"") . "r";
+}
+
+$typefamily{ENUM} = {
+ DECL => \&DeclEnum,
+ PUSH_FN_BODY => \&ParseEnumPush,
+ PULL_FN_BODY => \&ParseEnumPull,
+ PRINT_FN_BODY => \&ParseEnumPrint,
+};
+
+#####################################################################
+# generate a push function for a bitmap
+sub ParseBitmapPush($$)
+{
+ my($bitmap,$name) = @_;
+ my($type_fn) = $bitmap->{BASE_TYPE};
+
+ start_flags($bitmap);
+
+ pidl "NDR_CHECK(ndr_push_$type_fn(ndr, NDR_SCALARS, r));";
+
+ end_flags($bitmap);
+}
+
+#####################################################################
+# generate a pull function for an bitmap
+sub ParseBitmapPull($$)
+{
+ my($bitmap,$name) = @_;
+ my $type_fn = $bitmap->{BASE_TYPE};
+ my($type_decl) = mapType($bitmap->{BASE_TYPE});
+
+ pidl "$type_decl v;";
+ start_flags($bitmap);
+ pidl "NDR_CHECK(ndr_pull_$type_fn(ndr, NDR_SCALARS, &v));";
+ pidl "*r = v;";
+
+ end_flags($bitmap);
+}
+
+#####################################################################
+# generate a print function for an bitmap
+sub ParseBitmapPrintElement($$$)
+{
+ my($e,$bitmap,$name) = @_;
+ my($type_decl) = mapType($bitmap->{BASE_TYPE});
+ my($type_fn) = $bitmap->{BASE_TYPE};
+ my($flag);
+
+ if ($e =~ /^(\w+) .*$/) {
+ $flag = "$1";
+ } else {
+ die "Bitmap: \"$name\" invalid Flag: \"$e\"";
+ }
+
+ pidl "ndr_print_bitmap_flag(ndr, sizeof($type_decl), \"$flag\", $flag, r);";
+}
+
+#####################################################################
+# generate a print function for an bitmap
+sub ParseBitmapPrint($$)
+{
+ my($bitmap,$name) = @_;
+ my($type_decl) = mapType($bitmap->{TYPE});
+ my($type_fn) = $bitmap->{BASE_TYPE};
+
+ start_flags($bitmap);
+
+ pidl "ndr_print_$type_fn(ndr, name, r);";
+
+ pidl "ndr->depth++;";
+ foreach my $e (@{$bitmap->{ELEMENTS}}) {
+ ParseBitmapPrintElement($e, $bitmap, $name);
+ }
+ pidl "ndr->depth--;";
+
+ end_flags($bitmap);
+}
+
+sub DeclBitmap($$)
+{
+ my ($e,$t) = @_;
+ return mapType(Parse::Pidl::Typelist::bitmap_type_fn($e->{DATA})) .
+ ($t eq "pull"?" *":" ") . "r";
+}
+
+$typefamily{BITMAP} = {
+ DECL => \&DeclBitmap,
+ PUSH_FN_BODY => \&ParseBitmapPush,
+ PULL_FN_BODY => \&ParseBitmapPull,
+ PRINT_FN_BODY => \&ParseBitmapPrint,
+};
+
+#####################################################################
+# generate a struct print function
+sub ParseStructPrint($$)
+{
+ my($struct,$name) = @_;
+
+ return unless defined $struct->{ELEMENTS};
+
+ my $env = GenerateStructEnv($struct);
+
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ DeclareArrayVariables($e);
+ }
+
+ pidl "ndr_print_struct(ndr, name, \"$name\");";
+
+ start_flags($struct);
+
+ pidl "ndr->depth++;";
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ ParseElementPrint($e, "r->$e->{NAME}", $env);
+ }
+ pidl "ndr->depth--;";
+
+ end_flags($struct);
+}
+
+sub DeclarePtrVariables($)
+{
+ my $e = shift;
+ foreach my $l (@{$e->{LEVELS}}) {
+ if ($l->{TYPE} eq "POINTER" and
+ not ($l->{POINTER_TYPE} eq "ref" and $l->{LEVEL} eq "TOP")) {
+ pidl "uint32_t _ptr_$e->{NAME};";
+ last;
+ }
+ }
+}
+
+sub DeclareArrayVariables($)
+{
+ my $e = shift;
+
+ foreach my $l (@{$e->{LEVELS}}) {
+ next if has_fast_array($e,$l);
+ next if is_charset_array($e,$l);
+ if ($l->{TYPE} eq "ARRAY") {
+ pidl "uint32_t cntr_$e->{NAME}_$l->{LEVEL_INDEX};";
+ }
+ }
+}
+
+sub need_decl_mem_ctx($$)
+{
+ my $e = shift;
+ my $l = shift;
+
+ return 0 if has_fast_array($e,$l);
+ return 0 if is_charset_array($e,$l);
+ return 1 if (($l->{TYPE} eq "ARRAY") and not $l->{IS_FIXED});
+
+ if (($l->{TYPE} eq "POINTER") and ($l->{POINTER_TYPE} eq "ref")) {
+ my $nl = GetNextLevel($e, $l);
+ my $next_is_array = ($nl->{TYPE} eq "ARRAY");
+ my $next_is_string = (($nl->{TYPE} eq "DATA") and
+ ($nl->{DATA_TYPE} eq "string"));
+ return 0 if ($next_is_array or $next_is_string);
+ }
+ return 1 if ($l->{TYPE} eq "POINTER");
+
+ return 0;
+}
+
+sub DeclareMemCtxVariables($)
+{
+ my $e = shift;
+ foreach my $l (@{$e->{LEVELS}}) {
+ if (need_decl_mem_ctx($e, $l)) {
+ pidl "TALLOC_CTX *_mem_save_$e->{NAME}_$l->{LEVEL_INDEX};";
+ }
+ }
+}
+
+#####################################################################
+# parse a struct - pull side
+sub ParseStructPull($$)
+{
+ my($struct,$name) = @_;
+
+ return unless defined $struct->{ELEMENTS};
+
+ my $env = GenerateStructEnv($struct);
+
+ # declare any internal pointers we need
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ DeclarePtrVariables($e);
+ DeclareArrayVariables($e);
+ DeclareMemCtxVariables($e);
+ }
+
+ # save the old relative_base_offset
+ pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($struct->{PROPERTIES}{relative_base});
+
+ start_flags($struct);
+
+ pidl "if (ndr_flags & NDR_SCALARS) {";
+ indent;
+
+ if (defined $struct->{SURROUNDING_ELEMENT}) {
+ pidl "NDR_CHECK(ndr_pull_array_size(ndr, &r->$struct->{SURROUNDING_ELEMENT}->{NAME}));";
+ }
+
+ pidl "NDR_CHECK(ndr_pull_align(ndr, $struct->{ALIGN}));";
+
+ if (defined($struct->{PROPERTIES}{relative_base})) {
+ # set the current offset as base for relative pointers
+ # and store it based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
+ }
+
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ ParseElementPull($e, "ndr", "r->", $env, 1, 0);
+ }
+
+ add_deferred();
+
+ deindent;
+ pidl "}";
+ pidl "if (ndr_flags & NDR_BUFFERS) {";
+ indent;
+ if (defined($struct->{PROPERTIES}{relative_base})) {
+ # retrieve the current offset as base for relative pointers
+ # based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
+ }
+ foreach my $e (@{$struct->{ELEMENTS}}) {
+ ParseElementPull($e, "ndr", "r->", $env, 0, 1);
+ }
+
+ add_deferred();
+
+ deindent;
+ pidl "}";
+
+ end_flags($struct);
+ # restore the old relative_base_offset
+ pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($struct->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseStructNdrSize($)
+{
+ my $t = shift;
+ my $sizevar;
+
+ if (my $flags = has_property($t, "flag")) {
+ pidl "flags |= $flags;";
+ }
+ pidl "return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+sub DeclStruct($)
+{
+ my ($e,$t) = @_;
+ return ($t ne "pull"?"const ":"") . "struct $e->{NAME} *r";
+}
+
+sub ArgsStructNdrSize($)
+{
+ my $d = shift;
+ return "const struct $d->{NAME} *r, int flags";
+}
+
+$typefamily{STRUCT} = {
+ PUSH_FN_BODY => \&ParseStructPush,
+ DECL => \&DeclStruct,
+ PULL_FN_BODY => \&ParseStructPull,
+ PRINT_FN_BODY => \&ParseStructPrint,
+ SIZE_FN_BODY => \&ParseStructNdrSize,
+ SIZE_FN_ARGS => \&ArgsStructNdrSize,
+};
+
+#####################################################################
+# calculate size of ndr struct
+sub ParseUnionNdrSize($)
+{
+ my $t = shift;
+ my $sizevar;
+
+ if (my $flags = has_property($t, "flag")) {
+ pidl "flags |= $flags;";
+ }
+
+ pidl "return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_$t->{NAME});";
+}
+
+#####################################################################
+# parse a union - push side
+sub ParseUnionPush($$)
+{
+ my ($e,$name) = @_;
+ my $have_default = 0;
+
+ # save the old relative_base_offset
+ pidl "uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
+ pidl "int level;";
+
+ start_flags($e);
+
+ pidl "level = ndr_push_get_switch_value(ndr, r);";
+
+ pidl "if (ndr_flags & NDR_SCALARS) {";
+ indent;
+
+ if (defined($e->{SWITCH_TYPE})) {
+ pidl "NDR_CHECK(ndr_push_$e->{SWITCH_TYPE}(ndr, NDR_SCALARS, level));";
+ }
+
+ pidl "switch (level) {";
+ indent;
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ if ($el->{CASE} eq "default") {
+ $have_default = 1;
+ }
+ pidl "$el->{CASE}:";
+
+ if ($el->{TYPE} ne "EMPTY") {
+ indent;
+ if (defined($e->{PROPERTIES}{relative_base})) {
+ pidl "NDR_CHECK(ndr_push_align(ndr, $el->{ALIGN}));";
+ # set the current offset as base for relative pointers
+ # and store it based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));";
+ }
+ DeclareArrayVariables($el);
+ ParseElementPush($el, "ndr", "r->", {}, 1, 0);
+ deindent;
+ }
+ pidl "break;";
+ pidl "";
+ }
+ if (! $have_default) {
+ pidl "default:";
+ pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+ deindent;
+ pidl "}";
+ pidl "if (ndr_flags & NDR_BUFFERS) {";
+ indent;
+ if (defined($e->{PROPERTIES}{relative_base})) {
+ # retrieve the current offset as base for relative pointers
+ # based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));";
+ }
+ pidl "switch (level) {";
+ indent;
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ pidl "$el->{CASE}:";
+ if ($el->{TYPE} ne "EMPTY") {
+ indent;
+ ParseElementPush($el, "ndr", "r->", {}, 0, 1);
+ deindent;
+ }
+ pidl "break;";
+ pidl "";
+ }
+ if (! $have_default) {
+ pidl "default:";
+ pidl "\treturn ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+
+ deindent;
+ pidl "}";
+ end_flags($e);
+ # restore the old relative_base_offset
+ pidl "ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
+}
+
+#####################################################################
+# print a union
+sub ParseUnionPrint($$)
+{
+ my ($e,$name) = @_;
+ my $have_default = 0;
+
+ pidl "int level = ndr_print_get_switch_value(ndr, r);";
+
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ DeclareArrayVariables($el);
+ }
+
+ pidl "ndr_print_union(ndr, name, level, \"$name\");";
+ start_flags($e);
+
+ pidl "switch (level) {";
+ indent;
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ if ($el->{CASE} eq "default") {
+ $have_default = 1;
+ }
+ pidl "$el->{CASE}:";
+ if ($el->{TYPE} ne "EMPTY") {
+ indent;
+ ParseElementPrint($el, "r->$el->{NAME}", {});
+ deindent;
+ }
+ pidl "break;";
+ pidl "";
+ }
+ if (! $have_default) {
+ pidl "default:";
+ pidl "\tndr_print_bad_level(ndr, name, level);";
+ }
+ deindent;
+ pidl "}";
+
+ end_flags($e);
+}
+
+#####################################################################
+# parse a union - pull side
+sub ParseUnionPull($$)
+{
+ my ($e,$name) = @_;
+ my $have_default = 0;
+ my $switch_type = $e->{SWITCH_TYPE};
+
+ # save the old relative_base_offset
+ pidl "uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);" if defined($e->{PROPERTIES}{relative_base});
+ pidl "int level;";
+ if (defined($switch_type)) {
+ if (Parse::Pidl::Typelist::typeIs($switch_type, "ENUM")) {
+ $switch_type = Parse::Pidl::Typelist::enum_type_fn(getType($switch_type));
+ }
+ pidl mapType($switch_type) . " _level;";
+ }
+
+ my %double_cases = ();
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ next if ($el->{TYPE} eq "EMPTY");
+ next if ($double_cases{"$el->{NAME}"});
+ DeclareMemCtxVariables($el);
+ $double_cases{"$el->{NAME}"} = 1;
+ }
+
+ start_flags($e);
+
+ pidl "level = ndr_pull_get_switch_value(ndr, r);";
+
+ pidl "if (ndr_flags & NDR_SCALARS) {";
+ indent;
+
+ if (defined($switch_type)) {
+ pidl "NDR_CHECK(ndr_pull_$switch_type(ndr, NDR_SCALARS, &_level));";
+ pidl "if (_level != level) {";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value %u for $name\", _level);";
+ pidl "}";
+ }
+
+ pidl "switch (level) {";
+ indent;
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ if ($el->{CASE} eq "default") {
+ $have_default = 1;
+ }
+ pidl "$el->{CASE}: {";
+
+ if ($el->{TYPE} ne "EMPTY") {
+ indent;
+ DeclarePtrVariables($el);
+ DeclareArrayVariables($el);
+ if (defined($e->{PROPERTIES}{relative_base})) {
+ pidl "NDR_CHECK(ndr_pull_align(ndr, $el->{ALIGN}));";
+ # set the current offset as base for relative pointers
+ # and store it based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));";
+ }
+ ParseElementPull($el, "ndr", "r->", {}, 1, 0);
+ deindent;
+ }
+ pidl "break; }";
+ pidl "";
+ }
+ if (! $have_default) {
+ pidl "default:";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+ deindent;
+ pidl "}";
+ pidl "if (ndr_flags & NDR_BUFFERS) {";
+ indent;
+ if (defined($e->{PROPERTIES}{relative_base})) {
+ # retrieve the current offset as base for relative pointers
+ # based on the toplevel struct/union
+ pidl "NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));";
+ }
+ pidl "switch (level) {";
+ indent;
+ foreach my $el (@{$e->{ELEMENTS}}) {
+ pidl "$el->{CASE}:";
+ if ($el->{TYPE} ne "EMPTY") {
+ indent;
+ ParseElementPull($el, "ndr", "r->", {}, 0, 1);
+ deindent;
+ }
+ pidl "break;";
+ pidl "";
+ }
+ if (! $have_default) {
+ pidl "default:";
+ pidl "\treturn ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, \"Bad switch value \%u\", level);";
+ }
+ deindent;
+ pidl "}";
+
+ deindent;
+ pidl "}";
+
+ add_deferred();
+
+ end_flags($e);
+ # restore the old relative_base_offset
+ pidl "ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);" if defined($e->{PROPERTIES}{relative_base});
+}
+
+sub DeclUnion($$)
+{
+ my ($e,$t) = @_;
+ return ($t ne "pull"?"const ":"") . "union $e->{NAME} *r";
+}
+
+sub ArgsUnionNdrSize($)
+{
+ my $d = shift;
+ return "const union $d->{NAME} *r, uint32_t level, int flags";
+}
+
+$typefamily{UNION} = {
+ PUSH_FN_BODY => \&ParseUnionPush,
+ DECL => \&DeclUnion,
+ PULL_FN_BODY => \&ParseUnionPull,
+ PRINT_FN_BODY => \&ParseUnionPrint,
+ SIZE_FN_ARGS => \&ArgsUnionNdrSize,
+ SIZE_FN_BODY => \&ParseUnionNdrSize,
+};
+
+#####################################################################
+# parse a typedef - push side
+sub ParseTypedefPush($)
+{
+ my($e) = shift;
+
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"push");
+ pidl fn_prefix($e) . "NTSTATUS ndr_push_$e->{NAME}(struct ndr_push *ndr, int ndr_flags, $args)";
+
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PUSH_FN_BODY}->($e->{DATA}, $e->{NAME});
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";;
+}
+
+#####################################################################
+# parse a typedef - pull side
+sub ParseTypedefPull($)
+{
+ my($e) = shift;
+
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"pull");
+
+ pidl fn_prefix($e) . "NTSTATUS ndr_pull_$e->{NAME}(struct ndr_pull *ndr, int ndr_flags, $args)";
+
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PULL_FN_BODY}->($e->{DATA}, $e->{NAME});
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# parse a typedef - print side
+sub ParseTypedefPrint($)
+{
+ my($e) = shift;
+
+ my $args = $typefamily{$e->{DATA}->{TYPE}}->{DECL}->($e,"print");
+
+ pidl "void ndr_print_$e->{NAME}(struct ndr_print *ndr, const char *name, $args)";
+ pidl "{";
+ indent;
+ $typefamily{$e->{DATA}->{TYPE}}->{PRINT_FN_BODY}->($e->{DATA}, $e->{NAME});
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+## calculate the size of a structure
+sub ParseTypedefNdrSize($)
+{
+ my($t) = shift;
+
+ my $tf = $typefamily{$t->{DATA}->{TYPE}};
+ my $args = $tf->{SIZE_FN_ARGS}->($t);
+
+ pidl "size_t ndr_size_$t->{NAME}($args)";
+ pidl "{";
+ indent;
+ $typefamily{$t->{DATA}->{TYPE}}->{SIZE_FN_BODY}->($t);
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# parse a function - print side
+sub ParseFunctionPrint($)
+{
+ my($fn) = shift;
+
+ return if has_property($fn, "noprint");
+
+ pidl "void ndr_print_$fn->{NAME}(struct ndr_print *ndr, const char *name, int flags, const struct $fn->{NAME} *r)";
+ pidl "{";
+ indent;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ DeclareArrayVariables($e);
+ }
+
+ pidl "ndr_print_struct(ndr, name, \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
+
+ pidl "if (flags & NDR_SET_VALUES) {";
+ pidl "\tndr->flags |= LIBNDR_PRINT_SET_VALUES;";
+ pidl "}";
+
+ pidl "if (flags & NDR_IN) {";
+ indent;
+ pidl "ndr_print_struct(ndr, \"in\", \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
+
+ my $env = GenerateFunctionInEnv($fn);
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/in/,@{$e->{DIRECTION}})) {
+ ParseElementPrint($e, "r->in.$e->{NAME}", $env);
+ }
+ }
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
+
+ pidl "if (flags & NDR_OUT) {";
+ indent;
+ pidl "ndr_print_struct(ndr, \"out\", \"$fn->{NAME}\");";
+ pidl "ndr->depth++;";
+
+ $env = GenerateFunctionOutEnv($fn);
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/out/,@{$e->{DIRECTION}})) {
+ ParseElementPrint($e, "r->out.$e->{NAME}", $env);
+ }
+ }
+ if ($fn->{RETURN_TYPE}) {
+ pidl "ndr_print_$fn->{RETURN_TYPE}(ndr, \"result\", r->out.result);";
+ }
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
+
+ pidl "ndr->depth--;";
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# parse a function
+sub ParseFunctionPush($)
+{
+ my($fn) = shift;
+
+ return if has_property($fn, "nopush");
+
+ pidl fn_prefix($fn) . "NTSTATUS ndr_push_$fn->{NAME}(struct ndr_push *ndr, int flags, const struct $fn->{NAME} *r)";
+ pidl "{";
+ indent;
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ DeclareArrayVariables($e);
+ }
+
+ pidl "if (flags & NDR_IN) {";
+ indent;
+
+ my $env = GenerateFunctionInEnv($fn);
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/in/,@{$e->{DIRECTION}})) {
+ ParseElementPush($e, "ndr", "r->in.", $env, 1, 1);
+ }
+ }
+
+ deindent;
+ pidl "}";
+
+ pidl "if (flags & NDR_OUT) {";
+ indent;
+
+ $env = GenerateFunctionOutEnv($fn);
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ if (grep(/out/,@{$e->{DIRECTION}})) {
+ ParseElementPush($e, "ndr", "r->out.", $env, 1, 1);
+ }
+ }
+
+ if ($fn->{RETURN_TYPE}) {
+ pidl "NDR_CHECK(ndr_push_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, r->out.result));";
+ }
+
+ deindent;
+ pidl "}";
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+sub AllocateArrayLevel($$$$$)
+{
+ my ($e,$l,$ndr,$env,$size) = @_;
+
+ my $var = ParseExpr($e->{NAME}, $env);
+
+ check_null_pointer($size);
+ my $pl = GetPrevLevel($e, $l);
+ if (defined($pl) and
+ $pl->{TYPE} eq "POINTER" and
+ $pl->{POINTER_TYPE} eq "ref"
+ and not $l->{IS_ZERO_TERMINATED}) {
+ pidl "if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {";
+ pidl "\tNDR_PULL_ALLOC_N($ndr, $var, $size);";
+ pidl "}";
+ } else {
+ pidl "NDR_PULL_ALLOC_N($ndr, $var, $size);";
+ }
+
+ if (grep(/in/,@{$e->{DIRECTION}}) and
+ grep(/out/,@{$e->{DIRECTION}}) and
+ $pl->{POINTER_TYPE} eq "ref") {
+ pidl "memcpy(r->out.$e->{NAME},r->in.$e->{NAME},$size * sizeof(*r->in.$e->{NAME}));";
+ }
+}
+
+#####################################################################
+# parse a function
+sub ParseFunctionPull($)
+{
+ my($fn) = shift;
+
+ return if has_property($fn, "nopull");
+
+ # pull function args
+ pidl fn_prefix($fn) . "NTSTATUS ndr_pull_$fn->{NAME}(struct ndr_pull *ndr, int flags, struct $fn->{NAME} *r)";
+ pidl "{";
+ indent;
+
+ # declare any internal pointers we need
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ DeclarePtrVariables($e);
+ DeclareArrayVariables($e);
+ }
+
+ my %double_cases = ();
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ next if ($e->{TYPE} eq "EMPTY");
+ next if ($double_cases{"$e->{NAME}"});
+ DeclareMemCtxVariables($e);
+ $double_cases{"$e->{NAME}"} = 1;
+ }
+
+ pidl "if (flags & NDR_IN) {";
+ indent;
+
+ # auto-init the out section of a structure. I originally argued that
+ # this was a bad idea as it hides bugs, but coping correctly
+ # with initialisation and not wiping ref vars is turning
+ # out to be too tricky (tridge)
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ next unless grep(/out/, @{$e->{DIRECTION}});
+ pidl "ZERO_STRUCT(r->out);";
+ pidl "";
+ last;
+ }
+
+ my $env = GenerateFunctionInEnv($fn);
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ next unless (grep(/in/, @{$e->{DIRECTION}}));
+ ParseElementPull($e, "ndr", "r->in.", $env, 1, 1);
+ }
+
+ # allocate the "simple" out ref variables. FIXME: Shouldn't this have it's
+ # own flag rather then be in NDR_IN ?
+
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ next unless (grep(/out/, @{$e->{DIRECTION}}));
+ next unless ($e->{LEVELS}[0]->{TYPE} eq "POINTER" and
+ $e->{LEVELS}[0]->{POINTER_TYPE} eq "ref");
+ next if (($e->{LEVELS}[1]->{TYPE} eq "DATA") and
+ ($e->{LEVELS}[1]->{DATA_TYPE} eq "string"));
+ next if (($e->{LEVELS}[1]->{TYPE} eq "ARRAY")
+ and $e->{LEVELS}[1]->{IS_ZERO_TERMINATED});
+
+ if ($e->{LEVELS}[1]->{TYPE} eq "ARRAY") {
+ my $size = ParseExpr($e->{LEVELS}[1]->{SIZE_IS}, $env);
+ check_null_pointer($size);
+
+ pidl "NDR_PULL_ALLOC_N(ndr, r->out.$e->{NAME}, $size);";
+
+ if (grep(/in/, @{$e->{DIRECTION}})) {
+ pidl "memcpy(r->out.$e->{NAME}, r->in.$e->{NAME}, $size * sizeof(*r->in.$e->{NAME}));";
+ } else {
+ pidl "memset(r->out.$e->{NAME}, 0, $size * sizeof(*r->out.$e->{NAME}));";
+ }
+ } else {
+ pidl "NDR_PULL_ALLOC(ndr, r->out.$e->{NAME});";
+
+ if (grep(/in/, @{$e->{DIRECTION}})) {
+ pidl "*r->out.$e->{NAME} = *r->in.$e->{NAME};";
+ } else {
+ pidl "ZERO_STRUCTP(r->out.$e->{NAME});";
+ }
+ }
+ }
+
+ add_deferred();
+ deindent;
+ pidl "}";
+
+ pidl "if (flags & NDR_OUT) {";
+ indent;
+
+ $env = GenerateFunctionOutEnv($fn);
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ next unless grep(/out/, @{$e->{DIRECTION}});
+ ParseElementPull($e, "ndr", "r->out.", $env, 1, 1);
+ }
+
+ if ($fn->{RETURN_TYPE}) {
+ pidl "NDR_CHECK(ndr_pull_$fn->{RETURN_TYPE}(ndr, NDR_SCALARS, &r->out.result));";
+ }
+
+ add_deferred();
+ deindent;
+ pidl "}";
+
+ pidl "return NT_STATUS_OK;";
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# produce a function call table
+sub FunctionTable($)
+{
+ my($interface) = shift;
+ my $count = 0;
+ my $uname = uc $interface->{NAME};
+
+ $count = $#{$interface->{FUNCTIONS}}+1;
+
+ return if ($count == 0);
+
+ pidl "static const struct dcerpc_interface_call $interface->{NAME}\_calls[] = {";
+ $count = 0;
+ foreach my $d (@{$interface->{FUNCTIONS}}) {
+ next if not defined($d->{OPNUM});
+ pidl "\t{";
+ pidl "\t\t\"$d->{NAME}\",";
+ pidl "\t\tsizeof(struct $d->{NAME}),";
+ pidl "\t\t(ndr_push_flags_fn_t) ndr_push_$d->{NAME},";
+ pidl "\t\t(ndr_pull_flags_fn_t) ndr_pull_$d->{NAME},";
+ pidl "\t\t(ndr_print_function_t) ndr_print_$d->{NAME}";
+ pidl "\t},";
+ $count++;
+ }
+ pidl "\t{ NULL, 0, NULL, NULL, NULL }";
+ pidl "};";
+ pidl "";
+
+ pidl "static const char * const $interface->{NAME}\_endpoint_strings[] = {";
+ foreach my $ep (@{$interface->{ENDPOINTS}}) {
+ pidl "\t$ep, ";
+ }
+ my $endpoint_count = $#{$interface->{ENDPOINTS}}+1;
+
+ pidl "};";
+ pidl "";
+
+ pidl "static const struct dcerpc_endpoint_list $interface->{NAME}\_endpoints = {";
+ pidl "\t.count\t= $endpoint_count,";
+ pidl "\t.names\t= $interface->{NAME}\_endpoint_strings";
+ pidl "};";
+ pidl "";
+
+ if (! defined $interface->{PROPERTIES}->{authservice}) {
+ $interface->{PROPERTIES}->{authservice} = "\"host\"";
+ }
+
+ my @a = split / /, $interface->{PROPERTIES}->{authservice};
+ my $authservice_count = $#a + 1;
+
+ pidl "static const char * const $interface->{NAME}\_authservice_strings[] = {";
+ foreach my $ap (@a) {
+ pidl "\t$ap, ";
+ }
+ pidl "};";
+ pidl "";
+
+ pidl "static const struct dcerpc_authservice_list $interface->{NAME}\_authservices = {";
+ pidl "\t.count\t= $endpoint_count,";
+ pidl "\t.names\t= $interface->{NAME}\_authservice_strings";
+ pidl "};";
+ pidl "";
+
+ pidl "\nconst struct dcerpc_interface_table dcerpc_table_$interface->{NAME} = {";
+ pidl "\t.name\t\t= \"$interface->{NAME}\",";
+ pidl "\t.uuid\t\t= DCERPC_$uname\_UUID,";
+ pidl "\t.if_version\t= DCERPC_$uname\_VERSION,";
+ pidl "\t.helpstring\t= DCERPC_$uname\_HELPSTRING,";
+ pidl "\t.num_calls\t= $count,";
+ pidl "\t.calls\t\t= $interface->{NAME}\_calls,";
+ pidl "\t.endpoints\t= &$interface->{NAME}\_endpoints,";
+ pidl "\t.authservices\t= &$interface->{NAME}\_authservices";
+ pidl "};";
+ pidl "";
+
+ pidl "static NTSTATUS dcerpc_ndr_$interface->{NAME}_init(void)";
+ pidl "{";
+ pidl "\treturn librpc_register_interface(&dcerpc_table_$interface->{NAME});";
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# parse the interface definitions
+sub ParseInterface($$)
+{
+ my($interface,$needed) = @_;
+
+ # Typedefs
+ foreach my $d (@{$interface->{TYPEDEFS}}) {
+ ($needed->{"push_$d->{NAME}"}) && ParseTypedefPush($d);
+ ($needed->{"pull_$d->{NAME}"}) && ParseTypedefPull($d);
+ ($needed->{"print_$d->{NAME}"}) && ParseTypedefPrint($d);
+
+ # Make sure we don't generate a function twice...
+ $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} =
+ $needed->{"print_$d->{NAME}"} = 0;
+
+ ($needed->{"ndr_size_$d->{NAME}"}) && ParseTypedefNdrSize($d);
+ }
+
+ # Functions
+ foreach my $d (@{$interface->{FUNCTIONS}}) {
+ ($needed->{"push_$d->{NAME}"}) && ParseFunctionPush($d);
+ ($needed->{"pull_$d->{NAME}"}) && ParseFunctionPull($d);
+ ($needed->{"print_$d->{NAME}"}) && ParseFunctionPrint($d);
+
+ # Make sure we don't generate a function twice...
+ $needed->{"push_$d->{NAME}"} = $needed->{"pull_$d->{NAME}"} =
+ $needed->{"print_$d->{NAME}"} = 0;
+ }
+
+ FunctionTable($interface);
+}
+
+sub RegistrationFunction($$)
+{
+ my ($idl,$filename) = @_;
+
+ $filename =~ /.*\/ndr_(.*).c/;
+ my $basename = $1;
+ pidl "NTSTATUS dcerpc_$basename\_init(void)";
+ pidl "{";
+ indent;
+ pidl "NTSTATUS status = NT_STATUS_OK;";
+ foreach my $interface (@{$idl}) {
+ next if $interface->{TYPE} ne "INTERFACE";
+
+ my $count = ($#{$interface->{FUNCTIONS}}+1);
+
+ next if ($count == 0);
+
+ pidl "status = dcerpc_ndr_$interface->{NAME}_init();";
+ pidl "if (NT_STATUS_IS_ERR(status)) {";
+ pidl "\treturn status;";
+ pidl "}";
+ pidl "";
+ }
+ pidl "return status;";
+ deindent;
+ pidl "}";
+ pidl "";
+}
+
+#####################################################################
+# parse a parsed IDL structure back into an IDL file
+sub Parse($$)
+{
+ my($ndr,$filename) = @_;
+
+ $tabs = "";
+ my $h_filename = $filename;
+ $res = "";
+
+ if ($h_filename =~ /(.*)\.c/) {
+ $h_filename = "$1.h";
+ }
+
+ pidl "/* parser auto-generated by pidl */";
+ pidl "";
+ pidl "#include \"includes.h\"";
+ pidl "#include \"librpc/gen_ndr/ndr_misc.h\"";
+ pidl "#include \"librpc/gen_ndr/ndr_dcerpc.h\"";
+ pidl "#include \"$h_filename\"";
+ pidl "";
+
+ my %needed = ();
+
+ foreach my $x (@{$ndr}) {
+ ($x->{TYPE} eq "INTERFACE") && NeededInterface($x, \%needed);
+ }
+
+ foreach my $x (@{$ndr}) {
+ ($x->{TYPE} eq "INTERFACE") && ParseInterface($x, \%needed);
+ }
+
+ RegistrationFunction($ndr, $filename);
+
+ return $res;
+}
+
+sub NeededFunction($$)
+{
+ my ($fn,$needed) = @_;
+ $needed->{"pull_$fn->{NAME}"} = 1;
+ $needed->{"push_$fn->{NAME}"} = 1;
+ $needed->{"print_$fn->{NAME}"} = 1;
+ foreach my $e (@{$fn->{ELEMENTS}}) {
+ $e->{PARENT} = $fn;
+ unless(defined($needed->{"pull_$e->{TYPE}"})) {
+ $needed->{"pull_$e->{TYPE}"} = 1;
+ }
+ unless(defined($needed->{"push_$e->{TYPE}"})) {
+ $needed->{"push_$e->{TYPE}"} = 1;
+ }
+ unless(defined($needed->{"print_$e->{TYPE}"})) {
+ $needed->{"print_$e->{TYPE}"} = 1;
+ }
+ }
+}
+
+sub NeededTypedef($$)
+{
+ my ($t,$needed) = @_;
+ if (has_property($t, "public")) {
+ $needed->{"pull_$t->{NAME}"} = not has_property($t, "nopull");
+ $needed->{"push_$t->{NAME}"} = not has_property($t, "nopush");
+ $needed->{"print_$t->{NAME}"} = not has_property($t, "noprint");
+ }
+
+ if ($t->{DATA}->{TYPE} eq "STRUCT" or $t->{DATA}->{TYPE} eq "UNION") {
+ if (has_property($t, "gensize")) {
+ $needed->{"ndr_size_$t->{NAME}"} = 1;
+ }
+
+ for my $e (@{$t->{DATA}->{ELEMENTS}}) {
+ $e->{PARENT} = $t->{DATA};
+ if ($needed->{"pull_$t->{NAME}"} and
+ not defined($needed->{"pull_$e->{TYPE}"})) {
+ $needed->{"pull_$e->{TYPE}"} = 1;
+ }
+ if ($needed->{"push_$t->{NAME}"} and
+ not defined($needed->{"push_$e->{TYPE}"})) {
+ $needed->{"push_$e->{TYPE}"} = 1;
+ }
+ if ($needed->{"print_$t->{NAME}"} and
+ not defined($needed->{"print_$e->{TYPE}"})) {
+ $needed->{"print_$e->{TYPE}"} = 1;
+ }
+ }
+ }
+}
+
+#####################################################################
+# work out what parse functions are needed
+sub NeededInterface($$)
+{
+ my ($interface,$needed) = @_;
+ foreach my $d (@{$interface->{FUNCTIONS}}) {
+ NeededFunction($d, $needed);
+ }
+ foreach my $d (reverse @{$interface->{TYPEDEFS}}) {
+ NeededTypedef($d, $needed);
+ }
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/NDR/Server.pm b/source4/pidl/Parse/Pidl/Samba/NDR/Server.pm
new file mode 100644
index 0000000000..a8c159572b
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/NDR/Server.pm
@@ -0,0 +1,322 @@
+###################################################
+# server boilerplate generator
+# Copyright tridge@samba.org 2003
+# Copyright metze@samba.org 2004
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::NDR::Server;
+
+use strict;
+
+my($res);
+
+sub pidl($)
+{
+ $res .= shift;
+}
+
+
+#####################################################
+# generate the switch statement for function dispatch
+sub gen_dispatch_switch($)
+{
+ my $interface = shift;
+
+ foreach my $fn (@{$interface->{FUNCTIONS}}) {
+ next if not defined($fn->{OPNUM});
+
+ pidl "\tcase $fn->{OPNUM}: {\n";
+ pidl "\t\tstruct $fn->{NAME} *r2 = r;\n";
+ pidl "\t\tif (DEBUGLEVEL >= 10) {\n";
+ pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_IN, r2);\n";
+ pidl "\t\t}\n";
+ if ($fn->{RETURN_TYPE} && $fn->{RETURN_TYPE} ne "void") {
+ pidl "\t\tr2->out.result = $fn->{NAME}(dce_call, mem_ctx, r2);\n";
+ } else {
+ pidl "\t\t$fn->{NAME}(dce_call, mem_ctx, r2);\n";
+ }
+ pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+ pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} will reply async\\n\"));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tbreak;\n\t}\n";
+ }
+}
+
+#####################################################
+# generate the switch statement for function reply
+sub gen_reply_switch($)
+{
+ my $interface = shift;
+
+ foreach my $fn (@{$interface->{FUNCTIONS}}) {
+ next if not defined($fn->{OPNUM});
+
+ pidl "\tcase $fn->{OPNUM}: {\n";
+ pidl "\t\tstruct $fn->{NAME} *r2 = r;\n";
+ pidl "\t\tif (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {\n";
+ pidl "\t\t\tDEBUG(5,(\"function $fn->{NAME} replied async\\n\"));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tif (DEBUGLEVEL >= 10 && dce_call->fault_code == 0) {\n";
+ pidl "\t\t\tNDR_PRINT_FUNCTION_DEBUG($fn->{NAME}, NDR_OUT | NDR_SET_VALUES, r2);\n";
+ pidl "\t\t}\n";
+ pidl "\t\tif (dce_call->fault_code != 0) {\n";
+ pidl "\t\t\tDEBUG(2,(\"dcerpc_fault %s in $fn->{NAME}\\n\", dcerpc_errstr(mem_ctx, dce_call->fault_code)));\n";
+ pidl "\t\t}\n";
+ pidl "\t\tbreak;\n\t}\n";
+ }
+}
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Boilerplate_Iface($)
+{
+ my($interface) = shift;
+ my $name = $interface->{NAME};
+ my $uname = uc $name;
+ my $uuid = Parse::Pidl::Util::make_str($interface->{PROPERTIES}->{uuid});
+ my $if_version = $interface->{PROPERTIES}->{version};
+
+ pidl "
+static NTSTATUS $name\__op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_BIND
+ return DCESRV_INTERFACE_$uname\_BIND(dce_call,iface);
+#else
+ return NT_STATUS_OK;
+#endif
+}
+
+static void $name\__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
+{
+#ifdef DCESRV_INTERFACE_$uname\_UNBIND
+ DCESRV_INTERFACE_$uname\_UNBIND(context, iface);
+#else
+ return;
+#endif
+}
+
+static NTSTATUS $name\__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
+{
+ NTSTATUS status;
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ dce_call->fault_code = 0;
+
+ if (opnum >= dcerpc_table_$name.num_calls) {
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ *r = talloc_size(mem_ctx, dcerpc_table_$name.calls[opnum].struct_size);
+ NT_STATUS_HAVE_NO_MEMORY(*r);
+
+ /* unravel the NDR for the packet */
+ status = dcerpc_table_$name.calls[opnum].ndr_pull(pull, NDR_IN, *r);
+ if (!NT_STATUS_IS_OK(status)) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ dce_call->fault_code = DCERPC_FAULT_NDR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ switch (opnum) {
+";
+ gen_dispatch_switch($interface);
+
+pidl "
+ default:
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ break;
+ }
+
+ if (dce_call->fault_code != 0) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
+{
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ switch (opnum) {
+";
+ gen_reply_switch($interface);
+
+pidl "
+ default:
+ dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+ break;
+ }
+
+ if (dce_call->fault_code != 0) {
+ dcerpc_log_packet(&dcerpc_table_$name, opnum, NDR_IN,
+ &dce_call->pkt.u.request.stub_and_verifier);
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS $name\__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
+{
+ NTSTATUS status;
+ uint16_t opnum = dce_call->pkt.u.request.opnum;
+
+ status = dcerpc_table_$name.calls[opnum].ndr_push(push, NDR_OUT, r);
+ if (!NT_STATUS_IS_OK(status)) {
+ dce_call->fault_code = DCERPC_FAULT_NDR;
+ return NT_STATUS_NET_WRITE_FAULT;
+ }
+
+ return NT_STATUS_OK;
+}
+
+static const struct dcesrv_interface $name\_interface = {
+ .name = \"$name\",
+ .uuid = $uuid,
+ .if_version = $if_version,
+ .bind = $name\__op_bind,
+ .unbind = $name\__op_unbind,
+ .ndr_pull = $name\__op_ndr_pull,
+ .dispatch = $name\__op_dispatch,
+ .reply = $name\__op_reply,
+ .ndr_push = $name\__op_ndr_push
+};
+
+";
+}
+
+#####################################################################
+# produce boilerplate code for an endpoint server
+sub Boilerplate_Ep_Server($)
+{
+ my($interface) = shift;
+ my $name = $interface->{NAME};
+ my $uname = uc $name;
+
+ pidl "
+static NTSTATUS $name\__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
+{
+ int i;
+
+ for (i=0;i<dcerpc_table_$name.endpoints->count;i++) {
+ NTSTATUS ret;
+ const char *name = dcerpc_table_$name.endpoints->names[i];
+
+ ret = dcesrv_interface_register(dce_ctx, name, &$name\_interface, NULL);
+ if (!NT_STATUS_IS_OK(ret)) {
+ DEBUG(1,(\"$name\_op_init_server: failed to register endpoint \'%s\'\\n\",name));
+ return ret;
+ }
+ }
+
+ return NT_STATUS_OK;
+}
+
+static BOOL $name\__op_interface_by_uuid(struct dcesrv_interface *iface, const char *uuid, uint32_t if_version)
+{
+ if ($name\_interface.if_version == if_version &&
+ strcmp($name\_interface.uuid, uuid)==0) {
+ memcpy(iface,&$name\_interface, sizeof(*iface));
+ return True;
+ }
+
+ return False;
+}
+
+static BOOL $name\__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
+{
+ if (strcmp($name\_interface.name, name)==0) {
+ memcpy(iface,&$name\_interface, sizeof(*iface));
+ return True;
+ }
+
+ return False;
+}
+
+NTSTATUS dcerpc_server_$name\_init(void)
+{
+ NTSTATUS ret;
+ struct dcesrv_endpoint_server ep_server;
+
+ /* fill in our name */
+ ep_server.name = \"$name\";
+
+ /* fill in all the operations */
+ ep_server.init_server = $name\__op_init_server;
+
+ ep_server.interface_by_uuid = $name\__op_interface_by_uuid;
+ ep_server.interface_by_name = $name\__op_interface_by_name;
+
+ /* register ourselves with the DCERPC subsystem. */
+ ret = dcerpc_register_ep_server(&ep_server);
+
+ if (!NT_STATUS_IS_OK(ret)) {
+ DEBUG(0,(\"Failed to register \'$name\' endpoint server!\\n\"));
+ return ret;
+ }
+
+ return ret;
+}
+
+";
+}
+
+#####################################################################
+# dcerpc server boilerplate from a parsed IDL structure
+sub ParseInterface($)
+{
+ my($interface) = shift;
+ my $count = 0;
+
+ if (!defined $interface->{PROPERTIES}->{uuid}) {
+ return $res;
+ }
+
+ if (!defined $interface->{PROPERTIES}->{version}) {
+ $interface->{PROPERTIES}->{version} = "0.0";
+ }
+
+ foreach my $fn (@{$interface->{FUNCTIONS}}) {
+ if (defined($fn->{OPNUM})) { $count++; }
+ }
+
+ if ($count == 0) {
+ return $res;
+ }
+
+ $res .= "/* $interface->{NAME} - dcerpc server boilerplate generated by pidl */\n\n";
+ Boilerplate_Iface($interface);
+ Boilerplate_Ep_Server($interface);
+
+ return $res;
+}
+
+sub Parse($$)
+{
+ my($ndr) = shift;
+ my($filename) = shift;
+
+ $res = "";
+ $res .= "/* server functions auto-generated by pidl */\n";
+ $res .= "\n";
+
+ foreach my $x (@{$ndr}) {
+ ParseInterface($x) if ($x->{TYPE} eq "INTERFACE" and not defined($x->{PROPERTIES}{object}));
+ }
+
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/SWIG.pm b/source4/pidl/Parse/Pidl/Samba/SWIG.pm
new file mode 100644
index 0000000000..409095804f
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/SWIG.pm
@@ -0,0 +1,76 @@
+###################################################
+# Samba4 parser generator for swig wrappers
+# Copyright tpot@samba.org 2004,2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::SWIG;
+
+use strict;
+
+sub pidl($)
+{
+ print OUT shift;
+}
+
+#####################################################################
+# rewrite autogenerated header file
+sub RewriteHeader($$$)
+{
+ my($idl) = shift;
+ my($input) = shift;
+ my($output) = shift;
+
+ open(IN, "<$input") || die "can't open $input for reading";
+ open(OUT, ">$output") || die "can't open $output for writing";
+
+ pidl "%{\n";
+ pidl "#define data_in in\n";
+ pidl "#define data_out out\n";
+ pidl "%}\n\n";
+
+ while(<IN>) {
+
+ # Rename dom_sid2 to dom_sid as we don't care about the difference
+ # for the swig wrappers.
+
+ s/dom_sid2/dom_sid/g;
+
+ # Copy structure and union definitions
+
+ if (/^(struct|union) .*? {$/ .. /^\};$/) {
+ s/\} (in|out);/\} data_$1;/; # "in" is a Python keyword
+ pidl $_;
+ next;
+ }
+
+ # Copy dcerpc functions
+
+ pidl $_ if /^NTSTATUS dcerpc_.*?\(struct dcerpc_pipe/;
+
+ # Copy interface definitions
+
+ pidl $_
+ if /^\#define DCERPC_.*?_UUID/ or /^\#define DCERPC_.*?_VERSION/;
+ }
+
+ close(OUT);
+}
+
+#####################################################################
+# rewrite autogenerated header file
+sub RewriteC($$$)
+{
+ my($idl) = shift;
+ my($input) = shift;
+ my($output) = shift;
+
+ open(IN, "<$input") || die "can't open $input for reading";
+ open(OUT, ">>$output") || die "can't open $output for writing";
+
+ while(<IN>) {
+ }
+
+ close(OUT);
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/TDR.pm b/source4/pidl/Parse/Pidl/Samba/TDR.pm
new file mode 100644
index 0000000000..b9bfd83e41
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/TDR.pm
@@ -0,0 +1,266 @@
+###################################################
+# Trivial Parser Generator
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::TDR;
+use Parse::Pidl::Util qw(has_property ParseExpr is_constant);
+use Data::Dumper;
+
+use strict;
+
+my $ret = "";
+my $tabs = "";
+
+sub indent() { $tabs.="\t"; }
+sub deindent() { $tabs = substr($tabs, 1); }
+sub pidl($) { $ret .= $tabs.(shift)."\n"; }
+sub fatal($$) { my ($e,$s) = @_; die("$e->{FILE}:$e->{LINE}: $s\n"); }
+sub static($) { my $p = shift; return("static ") unless ($p); return ""; }
+sub printarg($) {
+ my $t = shift;
+ return(", const char *name") if ($t eq "print");
+ return("");
+}
+
+sub ContainsArray($)
+{
+ my $e = shift;
+ foreach (@{$e->{ELEMENTS}}) {
+ next if (has_property($_, "charset") and
+ scalar(@{$_->{ARRAY_LEN}}) == 1);
+ return 1 if (defined($_->{ARRAY_LEN}) and
+ scalar(@{$_->{ARRAY_LEN}}) > 0);
+ }
+ return 0;
+}
+
+sub ParserElement($$$)
+{
+ my ($e,$t,$env) = @_;
+ my $switch = "";
+ my $array = "";
+ my $name = "";
+
+ fatal($e,"Pointers not supported in TDR") if ($e->{POINTERS} > 0);
+ fatal($e,"size_is() not supported in TDR") if (has_property($e, "size_is"));
+ fatal($e,"length_is() not supported in TDR") if (has_property($e, "length_is"));
+
+ if ($t eq "print") {
+ $name = ", \"$e->{NAME}\"$array";
+ }
+
+ if (has_property($e, "flag")) {
+ pidl "{";
+ indent;
+ pidl "uint32_t saved_flags = tdr->flags;";
+ pidl "tdr->flags |= $e->{PROPERTIES}->{flag};";
+ }
+
+ if (has_property($e, "charset")) {
+ fatal($e,"charset() on non-array element") unless (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0);
+
+ my $len = @{$e->{ARRAY_LEN}}[0];
+ if ($len eq "*") { $len = "-1"; }
+ pidl "TDR_CHECK(tdr_$t\_charset(tdr$name, &v->$e->{NAME}, $len, sizeof($e->{TYPE}_t), CH_$e->{PROPERTIES}->{charset}));";
+ return;
+ }
+
+
+ if (has_property($e, "switch_is")) {
+ $switch = ", " . ParseExpr($e->{PROPERTIES}->{switch_is}, $env);
+ }
+
+ if (defined($e->{ARRAY_LEN}) and scalar(@{$e->{ARRAY_LEN}}) > 0) {
+ my $len = ParseExpr($e->{ARRAY_LEN}[0], $env);
+
+ if ($t eq "pull" and not is_constant($len)) {
+ pidl "TDR_ALLOC(tdr, v->$e->{NAME}, $len);"
+ }
+
+ pidl "for (i = 0; i < $len; i++) {";
+ indent;
+ $array = "[i]";
+ }
+
+ if (has_property($e, "value") && $t eq "push") {
+ pidl "v->$e->{NAME} = ".ParseExpr($e->{PROPERTIES}->{value}, $env).";";
+ }
+
+ pidl "TDR_CHECK(tdr_$t\_$e->{TYPE}(tdr$name$switch, &v->$e->{NAME}$array));";
+
+ if ($array) { deindent; pidl "}"; }
+
+ if (has_property($e, "flag")) {
+ pidl "tdr->flags = saved_flags;";
+ deindent;
+ pidl "}";
+ }
+}
+
+sub ParserStruct($$$$)
+{
+ my ($e,$n,$t,$p) = @_;
+
+ pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", struct $n *v)";
+ pidl "{"; indent;
+ pidl "int i;" if (ContainsArray($e));
+
+ if ($t eq "print") {
+ pidl "tdr->print(tdr, \"\%-25s: struct $n\", name);";
+ pidl "tdr->level++;";
+ }
+
+ my %env = map { $_->{NAME} => "v->$_->{NAME}" } @{$e->{ELEMENTS}};
+ ParserElement($_, $t, \%env) foreach (@{$e->{ELEMENTS}});
+
+ if ($t eq "print") {
+ pidl "tdr->level--;";
+ }
+
+ pidl "return NT_STATUS_OK;";
+
+ deindent; pidl "}";
+}
+
+sub ParserUnion($$$$)
+{
+ my ($e,$n,$t,$p) = @_;
+
+ pidl static($p)."NTSTATUS tdr_$t\_$n(struct tdr_$t *tdr".printarg($t).", int level, union $n *v)";
+ pidl "{"; indent;
+ pidl "int i;" if (ContainsArray($e));
+
+ if ($t eq "print") {
+ pidl "tdr->print(tdr, \"\%-25s: union $n\", name);";
+ pidl "tdr->level++;";
+ }
+
+ pidl "switch (level) {"; indent;
+ foreach (@{$e->{ELEMENTS}}) {
+ if (has_property($_, "case")) {
+ pidl "case " . $_->{PROPERTIES}->{case} . ":";
+ } elsif (has_property($_, "default")) {
+ pidl "default:";
+ }
+ indent; ParserElement($_, $t, {}); deindent;
+ pidl "break;";
+ }
+ deindent; pidl "}";
+
+ if ($t eq "print") {
+ pidl "tdr->level--;";
+ }
+
+ pidl "return NT_STATUS_OK;\n";
+ deindent; pidl "}";
+}
+
+sub ParserBitmap($$$$)
+{
+ my ($e,$n,$t,$p) = @_;
+ return if ($p);
+ pidl "#define tdr_$t\_$n tdr_$t\_" . Parse::Pidl::Typelist::bitmap_type_fn($e);
+}
+
+sub ParserEnum($$$$)
+{
+ my ($e,$n,$t,$p) = @_;
+ my $bt = Parse::Pidl::Typelist::enum_type_fn($e);
+
+ pidl static($p)."NTSTATUS tdr_$t\_$n (struct tdr_$t *tdr".printarg($t).", enum $n *v)";
+ pidl "{";
+ if ($t eq "pull") {
+ pidl "\t$bt\_t r;";
+ pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, \&r));";
+ pidl "\t*v = r;";
+ } elsif ($t eq "push") {
+ pidl "\tTDR_CHECK(tdr_$t\_$bt(tdr, ($bt\_t *)v));";
+ } elsif ($t eq "print") {
+ pidl "\t/* FIXME */";
+ }
+ pidl "\treturn NT_STATUS_OK;";
+ pidl "}";
+}
+
+sub ParserTypedef($$)
+{
+ my ($e,$t) = @_;
+
+ return if (has_property($e, "no$t"));
+
+ { STRUCT => \&ParserStruct, UNION => \&ParserUnion,
+ ENUM => \&ParserEnum, BITMAP => \&ParserBitmap
+ }->{$e->{DATA}->{TYPE}}($e->{DATA}, $e->{NAME}, $t, has_property($e, "public"));
+
+ pidl "";
+}
+
+sub ParserInterface($)
+{
+ my $x = shift;
+
+ foreach (@{$x->{DATA}}) {
+ next if ($_->{TYPE} ne "TYPEDEF");
+ ParserTypedef($_, "pull");
+ ParserTypedef($_, "push");
+ ParserTypedef($_, "print");
+ }
+}
+
+sub Parser($$)
+{
+ my ($idl,$hdrname) = @_;
+ $ret = "";
+ pidl "/* autogenerated by pidl */";
+ pidl "#include \"includes.h\"";
+ pidl "#include \"$hdrname\"";
+ foreach (@$idl) { ParserInterface($_) if ($_->{TYPE} eq "INTERFACE"); }
+ return $ret;
+}
+
+sub HeaderInterface($$)
+{
+ my ($x,$outputdir) = @_;
+
+ pidl "#ifndef __TDR_$x->{NAME}_HEADER__";
+ pidl "#define __TDR_$x->{NAME}_HEADER__";
+
+ pidl "#include \"$outputdir/$x->{NAME}.h\"";
+
+ foreach my $e (@{$x->{DATA}}) {
+ next unless ($e->{TYPE} eq "TYPEDEF");
+ next unless has_property($e, "public");
+
+ my $switch = "";
+
+ $switch = ", int level" if ($e->{DATA}->{TYPE} eq "UNION");
+
+ if ($e->{DATA}->{TYPE} eq "BITMAP") {
+ # FIXME
+ } else {
+ my ($n, $d) = ($e->{NAME}, lc($e->{DATA}->{TYPE}));
+ pidl "NTSTATUS tdr_pull\_$n(struct tdr_pull *tdr$switch, $d $n *v);";
+ pidl "NTSTATUS tdr_print\_$n(struct tdr_print *tdr, const char *name$switch, $d $n *v);";
+ pidl "NTSTATUS tdr_push\_$n(struct tdr_push *tdr$switch, $d $n *v);";
+ }
+
+ pidl "";
+ }
+
+ pidl "#endif /* __TDR_$x->{NAME}_HEADER__ */";
+}
+
+sub Header($$)
+{
+ my ($idl,$outputdir) = @_;
+ $ret = "";
+ pidl "/* Generated by pidl */";
+
+ foreach (@$idl) {
+ HeaderInterface($_, $outputdir) if ($_->{TYPE} eq "INTERFACE");
+ }
+ return $ret;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Samba/Template.pm b/source4/pidl/Parse/Pidl/Samba/Template.pm
new file mode 100644
index 0000000000..eb71b6d707
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Samba/Template.pm
@@ -0,0 +1,88 @@
+###################################################
+# server template function generator
+# Copyright tridge@samba.org 2003
+# released under the GNU GPL
+
+package Parse::Pidl::Samba::Template;
+
+use strict;
+
+my($res);
+
+#####################################################################
+# produce boilerplate code for a interface
+sub Template($)
+{
+ my($interface) = shift;
+ my($data) = $interface->{DATA};
+ my $name = $interface->{NAME};
+
+ $res .=
+"/*
+ Unix SMB/CIFS implementation.
+
+ endpoint server for the $name pipe
+
+ Copyright (C) YOUR NAME HERE YEAR
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include \"includes.h\"
+#include \"rpc_server/dcerpc_server.h\"
+#include \"librpc/gen_ndr/ndr_$name.h\"
+
+";
+
+ foreach my $d (@{$data}) {
+ if ($d->{TYPE} eq "FUNCTION") {
+ my $fname = $d->{NAME};
+ $res .=
+"
+/*
+ $fname
+*/
+static $d->{RETURN_TYPE} $fname(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+ struct $fname *r)
+{
+ DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+
+";
+ }
+ }
+
+ $res .=
+"
+/* include the generated boilerplate */
+#include \"librpc/gen_ndr/ndr_$name\_s.c\"
+"
+}
+
+
+#####################################################################
+# parse a parsed IDL structure back into an IDL file
+sub Parse($)
+{
+ my($idl) = shift;
+ $res = "";
+ foreach my $x (@{$idl}) {
+ ($x->{TYPE} eq "INTERFACE") &&
+ Template($x);
+ }
+ return $res;
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Test.pm b/source4/pidl/Parse/Pidl/Test.pm
new file mode 100644
index 0000000000..34ea80c95c
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Test.pm
@@ -0,0 +1,169 @@
+# Simple system for running tests against pidl
+# (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+# Published under the GNU General Public License
+
+package Parse::Pidl::Test;
+
+use strict;
+use Parse::Pidl::Util;
+use Getopt::Long;
+
+my $cc = $ENV{CC};
+my @cflags = split / /, $ENV{CFLAGS};
+my @ldflags = split / /, $ENV{LDFLAGS};
+
+$cc = "cc" if ($cc eq "");
+
+sub generate_cfile($$$)
+{
+ my ($filename, $fragment, $incfiles) = @_;
+
+ unless (open (OUT, ">$filename")) {
+ print STDERR "Unable to open $filename\n";
+ return -1;
+ }
+ print OUT '
+/* This file was autogenerated. All changes made will be lost! */
+#include "include/includes.h"
+';
+
+ foreach (@$incfiles) {
+ print OUT "#include \"$_\"\n";
+ }
+
+ print OUT '
+int main(int argc, char **argv)
+{
+ TALLOC_CTX *mem_ctx = talloc_init(NULL);
+ ';
+ print OUT $fragment;
+ print OUT "\treturn 0;\n}\n";
+ close OUT;
+
+ return 0;
+}
+
+sub generate_idlfile($$)
+{
+ my ($filename,$fragment) = @_;
+
+ unless (open(OUT, ">$filename")) {
+ print STDERR "Unable to open $filename\n";
+ return -1;
+ }
+
+ print OUT '
+[uuid("1-2-3-4-5")] interface test_if
+{
+';
+ print OUT $fragment;
+ print OUT "\n}\n";
+ close OUT;
+
+ return 0;
+}
+
+sub compile_idl($$$)
+{
+ my ($filename,$idl_path, $idlargs) = @_;
+
+ my @args = @$idlargs;
+ push (@args, $filename);
+
+ unless (system($idl_path, @args) == 0) {
+ print STDERR "Error compiling IDL file $filename: $!\n";
+ return -1;
+ }
+}
+
+sub compile_cfile($)
+{
+ my ($filename) = @_;
+
+ return system($cc, @cflags, '-I.', '-Iinclude', '-c', $filename);
+}
+
+sub link_files($$)
+{
+ my ($exe_name,$objs) = @_;
+
+ return system($cc, @ldflags, '-Lbin', '-lrpc', '-o', $exe_name, @$objs);
+}
+
+sub test_idl($$$$)
+{
+ my ($name,$settings,$idl,$c) = @_;
+
+ $| = 1;
+
+ print "Running $name... ";
+
+ my $outputdir = $settings->{OutputDir};
+
+ my $c_filename = $outputdir."/".$name."_test.c";
+ my $idl_filename = $outputdir."/".$name."_idl.idl";
+ my $exe_filename = $outputdir."/".$name."_exe";
+
+ return -1 if (generate_cfile($c_filename, $c, $settings->{IncludeFiles}) == -1);
+
+ return -1 if (generate_idlfile($idl_filename, $idl) == -1);
+
+ return -1 if (compile_idl($idl_filename, $settings->{'IDL-Compiler'}, $settings->{'IDL-Arguments'}) == -1);
+
+ my @srcs = ($c_filename);
+ push (@srcs, @{$settings->{'ExtraFiles'}});
+
+ foreach (@srcs) {
+ next unless /\.c$/;
+ return -1 if (compile_cfile($_) == -1);
+ }
+
+ my @objs;
+ foreach (@srcs) {
+ if (/\.c$/) { s/\.c$/\.o/g; }
+ push(@objs, $_);
+ }
+
+ return -1 if (link_files($exe_filename, \@objs) == -1);
+
+ my $ret = system("./$exe_filename");
+ if ($ret != 0) {
+ $ret = $? >> 8;
+ print "failed with return value $ret\n";
+ return $ret;
+ }
+
+ unless ($settings->{Keep}) {
+ unlink(@srcs, @objs, $exe_filename, $idl_filename);
+ }
+
+ print "Ok\n";
+
+ return $ret;
+}
+
+sub GetSettings($)
+{
+ my $settings = {
+ OutputDir => ".",
+ 'IDL-Compiler' => "./pidl"
+ };
+
+ my %opts = ();
+ GetOptions('idl-compiler=s' => \$settings->{'IDL-Compiler'},
+ 'outputdir=s' => \$settings->{OutputDir},
+ 'keep' => \$settings->{Keep},
+ 'help' => sub { ShowHelp(); exit 1; } );
+
+ return %$settings;
+}
+
+sub ShowHelp()
+{
+ print " --idl-compiler=PATH-TO-PIDL Override path to IDL compiler\n";
+ print " --outputdir=OUTPUTDIR Write temporary files to OUTPUTDIR rather then .\n";
+ print " --keep Keep intermediate files after running test";
+ print " --help Show this help message\n";
+}
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Typelist.pm b/source4/pidl/Parse/Pidl/Typelist.pm
new file mode 100644
index 0000000000..10a4baf7e7
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Typelist.pm
@@ -0,0 +1,336 @@
+###################################################
+# Samba4 parser generator for IDL structures
+# Copyright jelmer@samba.org 2005
+# released under the GNU GPL
+
+package Parse::Pidl::Typelist;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(hasType getType mapType);
+
+use Parse::Pidl::Util qw(has_property);
+use strict;
+
+my %typedefs = ();
+
+# a list of known scalar types
+my $scalars = {
+ # 0 byte types
+ "void" => {
+ C_TYPE => "void",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 0
+ },
+
+ # 1 byte types
+ "char" => {
+ C_TYPE => "char",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 1
+ },
+ "int8" => {
+ C_TYPE => "int8_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 1
+ },
+ "uint8" => {
+ C_TYPE => "uint8_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 1
+ },
+
+ # 2 byte types
+ "int16" => {
+ C_TYPE => "int16_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 2
+ },
+ "uint16" => { C_TYPE => "uint16_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 2
+ },
+
+ # 4 byte types
+ "int32" => {
+ C_TYPE => "int32_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "uint32" => { C_TYPE => "uint32_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+
+ # 8 byte types
+ "hyper" => {
+ C_TYPE => "uint64_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 8
+ },
+ "dlong" => {
+ C_TYPE => "int64_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "udlong" => {
+ C_TYPE => "uint64_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "udlongr" => {
+ C_TYPE => "uint64_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+
+ # DATA_BLOB types
+ "DATA_BLOB" => {
+ C_TYPE => "DATA_BLOB",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+
+ # string types
+ "string" => {
+ C_TYPE => "const char *",
+ IS_REFERENCE => 1,
+ NDR_ALIGN => 4 #???
+ },
+ "string_array" => {
+ C_TYPE => "const char **",
+ IS_REFERENCE => 1,
+ NDR_ALIGN => 4 #???
+ },
+
+ # time types
+ "time_t" => {
+ C_TYPE => "time_t",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "NTTIME" => {
+ C_TYPE => "NTTIME",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "NTTIME_1sec" => {
+ C_TYPE => "NTTIME",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "NTTIME_hyper" => {
+ C_TYPE => "NTTIME",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 8
+ },
+
+
+ # error code types
+ "WERROR" => {
+ C_TYPE => "WERROR",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "NTSTATUS" => {
+ C_TYPE => "NTSTATUS",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+ "COMRESULT" => {
+ "C_TYPE" => "COMRESULT",
+ IS_REFERENCE => 0,
+ NDR_ALIGN => 4
+ },
+
+ # special types
+ "nbt_string" => {
+ C_TYPE => "const char *",
+ IS_REFERENCE => 1,
+ NDR_ALIGN => 4 #???
+ },
+ "ipv4address" => {
+ C_TYPE => "const char *",
+ IS_REFERENCE => 1,
+ NDR_ALIGN => 4
+ }
+};
+
+# map from a IDL type to a C header type
+sub mapScalarType($)
+{
+ my $name = shift;
+
+ # it's a bug when a type is not in the list
+ # of known scalars or has no mapping
+ return $typedefs{$name}->{DATA}->{C_TYPE} if defined($typedefs{$name}) and defined($typedefs{$name}->{DATA}->{C_TYPE});
+
+ die("Unknown scalar type $name");
+}
+
+sub getScalarAlignment($)
+{
+ my $name = shift;
+
+ # it's a bug when a type is not in the list
+ # of known scalars or has no mapping
+ return $scalars->{$name}{NDR_ALIGN} if defined($scalars->{$name}) and defined($scalars->{$name}{NDR_ALIGN});
+
+ die("Unknown scalar type $name");
+}
+
+sub addType($)
+{
+ my $t = shift;
+ $typedefs{$t->{NAME}} = $t;
+}
+
+sub getType($)
+{
+ my $t = shift;
+ return undef if not hasType($t);
+ return $typedefs{$t};
+}
+
+sub typeIs($$)
+{
+ my $t = shift;
+ my $tt = shift;
+
+ return 1 if (hasType($t) and getType($t)->{DATA}->{TYPE} eq $tt);
+ return 0;
+}
+
+sub hasType($)
+{
+ my $t = shift;
+ return 1 if defined($typedefs{$t});
+ return 0;
+}
+
+sub is_scalar($)
+{
+ my $type = shift;
+
+ return 0 unless(hasType($type));
+
+ if (my $dt = getType($type)->{DATA}->{TYPE}) {
+ return 1 if ($dt eq "SCALAR" or $dt eq "ENUM" or $dt eq "BITMAP");
+ }
+
+ return 0;
+}
+
+sub scalar_is_reference($)
+{
+ my $name = shift;
+
+ return $scalars->{$name}{IS_REFERENCE} if defined($scalars->{$name}) and defined($scalars->{$name}{IS_REFERENCE});
+ return 0;
+}
+
+sub RegisterScalars()
+{
+ foreach my $k (keys %{$scalars}) {
+ $typedefs{$k} = {
+ NAME => $k,
+ TYPE => "TYPEDEF",
+ DATA => $scalars->{$k}
+ };
+ $typedefs{$k}->{DATA}->{TYPE} = "SCALAR";
+ $typedefs{$k}->{DATA}->{NAME} = $k;
+ }
+}
+
+my $aliases = {
+ "DWORD" => "uint32",
+ "int" => "int32",
+ "WORD" => "uint16",
+ "char" => "uint8",
+ "long" => "int32",
+ "short" => "int16",
+ "HYPER_T" => "hyper",
+ "HRESULT" => "COMRESULT",
+};
+
+sub RegisterAliases()
+{
+ foreach my $k (keys %{$aliases}) {
+ $typedefs{$k} = $typedefs{$aliases->{$k}};
+ }
+}
+
+sub enum_type_fn($)
+{
+ my $enum = shift;
+ if (has_property($enum->{PARENT}, "enum8bit")) {
+ return "uint8";
+ } elsif (has_property($enum->{PARENT}, "v1_enum")) {
+ return "uint32";
+ }
+ return "uint16";
+}
+
+sub bitmap_type_fn($)
+{
+ my $bitmap = shift;
+
+ if (has_property($bitmap, "bitmap8bit")) {
+ return "uint8";
+ } elsif (has_property($bitmap, "bitmap16bit")) {
+ return "uint16";
+ } elsif (has_property($bitmap, "bitmap64bit")) {
+ return "hyper";
+ }
+ return "uint32";
+}
+
+sub mapType($)
+{
+ my $t = shift;
+ die("Undef passed to mapType") unless defined($t);
+ my $dt;
+
+ unless ($dt or ($dt = getType($t))) {
+ # Best guess
+ return "struct $t";
+ }
+ return mapScalarType($t) if ($dt->{DATA}->{TYPE} eq "SCALAR");
+ return "enum $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "ENUM");
+ return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "STRUCT");
+ return "struct $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "INTERFACE");
+ return "union $dt->{NAME}" if ($dt->{DATA}->{TYPE} eq "UNION");
+
+ if ($dt->{DATA}->{TYPE} eq "BITMAP") {
+ return mapScalarType(bitmap_type_fn($dt->{DATA}));
+ }
+
+ die("Unknown type $dt->{DATA}->{TYPE}");
+}
+
+sub LoadIdl($)
+{
+ my $idl = shift;
+
+ foreach my $x (@{$idl}) {
+ next if $x->{TYPE} ne "INTERFACE";
+
+ # DCOM interfaces can be types as well
+ addType({
+ NAME => $x->{NAME},
+ TYPE => "TYPEDEF",
+ DATA => $x
+ }) if (has_property($x, "object"));
+
+ foreach my $y (@{$x->{DATA}}) {
+ addType($y) if (
+ $y->{TYPE} eq "TYPEDEF"
+ or $y->{TYPE} eq "DECLARE");
+ }
+ }
+}
+
+RegisterScalars();
+RegisterAliases();
+
+1;
diff --git a/source4/pidl/Parse/Pidl/Util.pm b/source4/pidl/Parse/Pidl/Util.pm
new file mode 100644
index 0000000000..8854be9d74
--- /dev/null
+++ b/source4/pidl/Parse/Pidl/Util.pm
@@ -0,0 +1,149 @@
+###################################################
+# utility functions to support pidl
+# Copyright tridge@samba.org 2000
+# released under the GNU GPL
+package Parse::Pidl::Util;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = qw(has_property property_matches ParseExpr is_constant);
+
+use strict;
+
+#####################################################################
+# flatten an array of arrays into a single array
+sub FlattenArray2($)
+{
+ my $a = shift;
+ my @b;
+ for my $d (@{$a}) {
+ for my $d1 (@{$d}) {
+ push(@b, $d1);
+ }
+ }
+ return \@b;
+}
+
+#####################################################################
+# flatten an array of arrays into a single array
+sub FlattenArray($)
+{
+ my $a = shift;
+ my @b;
+ for my $d (@{$a}) {
+ for my $d1 (@{$d}) {
+ push(@b, $d1);
+ }
+ }
+ return \@b;
+}
+
+#####################################################################
+# flatten an array of hashes into a single hash
+sub FlattenHash($)
+{
+ my $a = shift;
+ my %b;
+ for my $d (@{$a}) {
+ for my $k (keys %{$d}) {
+ $b{$k} = $d->{$k};
+ }
+ }
+ return \%b;
+}
+
+#####################################################################
+# a dumper wrapper to prevent dependence on the Data::Dumper module
+# unless we actually need it
+sub MyDumper($)
+{
+ require Data::Dumper;
+ my $s = shift;
+ return Data::Dumper::Dumper($s);
+}
+
+#####################################################################
+# see if a pidl property list contains a given property
+sub has_property($$)
+{
+ my($e) = shift;
+ my($p) = shift;
+
+ if (!defined $e->{PROPERTIES}) {
+ return undef;
+ }
+
+ return $e->{PROPERTIES}->{$p};
+}
+
+#####################################################################
+# see if a pidl property matches a value
+sub property_matches($$$)
+{
+ my($e) = shift;
+ my($p) = shift;
+ my($v) = shift;
+
+ if (!defined has_property($e, $p)) {
+ return undef;
+ }
+
+ if ($e->{PROPERTIES}->{$p} =~ /$v/) {
+ return 1;
+ }
+
+ return undef;
+}
+
+# return 1 if the string is a C constant
+sub is_constant($)
+{
+ my $s = shift;
+ if (defined $s && $s =~ /^\d/) {
+ return 1;
+ }
+ return 0;
+}
+
+# return a "" quoted string, unless already quoted
+sub make_str($)
+{
+ my $str = shift;
+ if (substr($str, 0, 1) eq "\"") {
+ return $str;
+ }
+ return "\"" . $str . "\"";
+}
+
+# a hack to build on platforms that don't like negative enum values
+my $useUintEnums = 0;
+sub setUseUintEnums($)
+{
+ $useUintEnums = shift;
+}
+sub useUintEnums()
+{
+ return $useUintEnums;
+}
+
+sub ParseExpr($$)
+{
+ my($expr,$varlist) = @_;
+
+ die("Undefined value in ParseExpr") if not defined($expr);
+
+ my @tokens = split /((?:[A-Za-z_])(?:(?:(?:[A-Za-z0-9_.])|(?:->))+))/, $expr;
+ my $ret = "";
+
+ foreach my $t (@tokens) {
+ if (defined($varlist->{$t})) {
+ $ret .= $varlist->{$t};
+ } else {
+ $ret .= $t;
+ }
+ }
+
+ return $ret;
+}
+
+1;