pidl/tests/wireshark-ndr.pl

   1 #!/usr/bin/perl
   2 # (C) 2007 Jelmer Vernooij <jelmer@samba.org>
   3 # Published under the GNU General Public License
   4 # test parsing wireshark conformance files
   5 use strict;
   6 use warnings;
   7
   8 use Test::More tests => 40;
   9 use FindBin qw($RealBin);
  10 use lib "$RealBin";
  11 use Util;
  12 use Parse::Pidl::Util qw(MyDumper);
  13 use strict;
  14 use Parse::Pidl::Wireshark::NDR qw(field2name %res PrintIdl StripPrefixes RegisterInterfaceHandoff register_hf_field ProcessImport ProcessInclude find_type DumpEttList DumpEttDeclaration DumpHfList DumpHfDeclaration DumpFunctionTable register_type register_ett);
  15
  16 is("Access Mask", field2name("access_mask"));
  17 is("Accessmask", field2name("AccessMask"));
  18
  19 my $x = new Parse::Pidl::Wireshark::NDR();
  20 $x->PrintIdl("foo\nbar\n");
  21 is("/* IDL: foo */
  22 /* IDL: bar */
  23
  24 ", $x->{res}->{code});
  25
  26 is("bla_foo", StripPrefixes("bla_foo", []));
  27 is("foo", StripPrefixes("bla_foo", ["bla"]));
  28 is("foo_bla", StripPrefixes("foo_bla", ["bla"]));
  29
  30 $x = new Parse::Pidl::Wireshark::NDR();
  31 $x->RegisterInterfaceHandoff({});
  32 is($x->{res}->{code}, "");
  33 ok(not defined($x->{hf_used}->{hf_bla_opnum}));
  34
  35 $x = new Parse::Pidl::Wireshark::NDR();
  36 $x->{res}->{code} = "";
  37 $x->RegisterInterfaceHandoff({UUID => "uuid", NAME => "bla"});
  38 is($x->{res}->{code}, 'void proto_reg_handoff_dcerpc_bla(void)
  39 {
  40         dcerpc_init_uuid(proto_dcerpc_bla, ett_dcerpc_bla,
  41                 &uuid_dcerpc_bla, ver_dcerpc_bla,
  42                 bla_dissectors, hf_bla_opnum);
  43 }
  44 ');
  45 is($x->{hf_used}->{hf_bla_opnum}, 1);
  46
  47 $x->{conformance} = {};
  48 is("hf_bla_idx",
  49         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef));
  50 is_deeply($x->{conformance}, {
  51                 header_fields => {
  52                         "hf_bla_idx" => {
  53                                 INDEX => "hf_bla_idx",
  54                                 NAME => "bla",
  55                                 FILTER => "my.filter",
  56                                 BASE_TYPE => "BASE_HEX",
  57                                 FT_TYPE => "FT_UINT32",
  58                                 VALSSTRING => "NULL",
  59                                 BLURB => undef,
  60                                 MASK => 0xF
  61                         }
  62                 },
  63                 hf_renames => {},
  64                 fielddescription => {}
  65 });
  66
  67 $x->{conformance} = { fielddescription => { hf_bla_idx => { DESCRIPTION => "Some Description" }}};
  68 is("hf_bla_idx",
  69         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef));
  70 is_deeply($x->{conformance}, {
  71                 fielddescription => {
  72                         hf_bla_idx => {
  73                                 DESCRIPTION => "Some Description",
  74                                 USED => 1
  75                         }
  76                 },
  77                 header_fields => {
  78                         "hf_bla_idx" => {
  79                                 INDEX => "hf_bla_idx",
  80                                 NAME => "bla",
  81                                 FILTER => "my.filter",
  82                                 BASE_TYPE => "BASE_HEX",
  83                                 FT_TYPE => "FT_UINT32",
  84                                 VALSSTRING => "NULL",
  85                                 BLURB => "Some Description",
  86                                 MASK => 0xF
  87                         }
  88                 },
  89                 hf_renames => {},
  90 });
  91
  92 $x->{conformance} = { fielddescription => { hf_bla_idx => { DESCRIPTION => "Some Description" }}};
  93 is("hf_bla_idx",
  94         $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF,
  95                 "Actual Description"));
  96 is_deeply($x->{conformance}, {
  97                 fielddescription => {
  98                         hf_bla_idx => { DESCRIPTION => "Some Description" }
  99                 },
 100                 header_fields => {
 101                         "hf_bla_idx" => {
 102                                 INDEX => "hf_bla_idx",
 103                                 NAME => "bla",
 104                                 FILTER => "my.filter",
 105                                 BASE_TYPE => "BASE_HEX",
 106                                 FT_TYPE => "FT_UINT32",
 107                                 VALSSTRING => "NULL",
 108                                 BLURB => "Actual Description",
 109                                 MASK => 0xF
 110                         }
 111                 },
 112                 hf_renames => {},
 113 });
 114
 115
 116
 117 $x->{conformance} = { hf_renames => { "hf_bla_idx" => { NEWNAME => "hf_bloe_idx" } } };
 118 $x->register_hf_field("hf_bla_idx", "bla", "my.filter", "FT_UINT32", "BASE_HEX", "NULL", 0xF, undef);
 119 is_deeply($x->{conformance}, {
 120                 hf_renames => { hf_bla_idx => { USED => 1, NEWNAME => "hf_bloe_idx" } } });
 121
 122 $x->{hf_used} = { hf_bla => 1 };
 123 test_warnings("", sub {
 124                 $x->CheckUsed({ header_fields => { foo => { INDEX => "hf_bla" }}})});
 125
 126 $x->{hf_used} = { };
 127 test_warnings("hf field `hf_bla' not used\n", sub {
 128                 $x->CheckUsed({ header_fields => { foo => { INDEX => "hf_bla" }}})});
 129
 130 test_warnings("hf field `hf_id' not used\n",
 131         sub { $x->CheckUsed({
 132         hf_renames => {
 133                 hf_id => {
 134                         OLDNAME => "hf_id",
 135                         NEWNAME => "hf_newid",
 136                         USED => 0
 137                 }
 138         }
 139 }); } );
 140
 141 test_warnings("dissector param never used\n",
 142         sub { $x->CheckUsed({
 143         dissectorparams => {
 144                 dissect_foo => {
 145                         PARAM => 42,
 146                         USED => 0
 147                 }
 148         }
 149 }); } );
 150
 151 test_warnings("description never used\n",
 152         sub { $x->CheckUsed({
 153         fielddescription => {
 154                 hf_bla => {
 155                         USED => 0
 156                 }
 157         }
 158 }); } );
 159
 160 test_warnings("import never used\n",
 161         sub { $x->CheckUsed({
 162         imports => {
 163                 bla => {
 164                         USED => 0
 165                 }
 166         }
 167 }); } );
 168
 169 test_warnings("nofile:1: type never used\n",
 170         sub { $x->CheckUsed({
 171         types => {
 172                 bla => {
 173                         USED => 0,
 174                         POS => { FILE => "nofile", LINE => 1 }
 175                 }
 176         }
 177 }); } );
 178
 179 test_warnings("True/False description never used\n",
 180         sub { $x->CheckUsed({
 181         tfs => {
 182                 hf_bloe => {
 183                         USED => 0
 184                 }
 185         }
 186 }); } );
 187
 188 $x = new Parse::Pidl::Wireshark::NDR();
 189 $x->ProcessImport("security", "bla");
 190 is($x->{res}->{hdr}, "#include \"packet-dcerpc-bla.h\"\n\n");
 191
 192 $x = new Parse::Pidl::Wireshark::NDR();
 193 $x->ProcessImport("\"bla.idl\"", "\"foo.idl\"");
 194 is($x->{res}->{hdr}, "#include \"packet-dcerpc-bla.h\"\n" .
 195               "#include \"packet-dcerpc-foo.h\"\n\n");
 196
 197 $x = new Parse::Pidl::Wireshark::NDR();
 198 $x->ProcessInclude("foo.h", "bla.h", "bar.h");
 199 is($x->{res}->{hdr}, "#include \"foo.h\"\n" .
 200                   "#include \"bla.h\"\n" .
 201                           "#include \"bar.h\"\n\n");
 202
 203 $x->{conformance} = {types => { bla => "brainslug" } };
 204 is("brainslug", $x->find_type("bla"));
 205
 206 is(DumpEttList(["ett_t1", "ett_bla"]),
 207         "\tstatic gint *ett[] = {\n" .
 208         "\t\t&ett_t1,\n" .
 209         "\t\t&ett_bla,\n" .
 210         "\t};\n");
 211
 212 is(DumpEttList(), "\tstatic gint *ett[] = {\n\t};\n");
 213 is(DumpEttList(["bla"]), "\tstatic gint *ett[] = {\n\t\t&bla,\n\t};\n");
 214
 215 is(DumpEttDeclaration(["void", "zoid"]),
 216         "\n/* Ett declarations */\n" .
 217         "static gint void = -1;\n" .
 218         "static gint zoid = -1;\n" .
 219         "\n");
 220
 221 is(DumpEttDeclaration(), "\n/* Ett declarations */\n\n");
 222
 223 $x->{conformance} = {
 224         header_fields => {
 225                 hf_bla => { INDEX => "hf_bla", NAME => "Bla", FILTER => "bla.field", FT_TYPE => "FT_UINT32", BASE_TYPE => "BASE_DEC", VALSSTRING => "NULL", MASK => 0xFF, BLURB => "NULL" }
 226         }
 227 };
 228
 229 is($x->DumpHfList(), "\tstatic hf_register_info hf[] = {
 230         { &hf_bla,
 231           { \"Bla\", \"bla.field\", FT_UINT32, BASE_DEC, NULL, 255, \"NULL\", HFILL }},
 232         };
 233 ");
 234
 235 is($x->DumpHfDeclaration(), "
 236 /* Header field declarations */
 237 static gint hf_bla = -1;
 238
 239 ");
 240
 241 is(DumpFunctionTable({
 242                         NAME => "someif",
 243                         FUNCTIONS => [ { NAME => "fn1", OPNUM => 3 }, { NAME => "someif_fn2", OPNUM => 2 } ] }),
 244 'static dcerpc_sub_dissector someif_dissectors[] = {
 245         { 3, "fn1",
 246            someif_dissect_fn1_request, someif_dissect_fn1_response},
 247         { 2, "fn2",
 248            someif_dissect_fn2_request, someif_dissect_fn2_response},
 249         { 0, NULL, NULL, NULL }
 250 };
 251 ');
 252
 253 $x->{conformance} = {};
 254 $x->register_type("bla_type", "dissect_bla", "FT_UINT32", "BASE_HEX", 0xFF, "NULL", 4);
 255 is_deeply($x->{conformance}, {
 256                 types => {
 257                         bla_type => {
 258                                 NAME => "bla_type",
 259                                 DISSECTOR_NAME => "dissect_bla",
 260                                 FT_TYPE => "FT_UINT32",
 261                                 BASE_TYPE => "BASE_HEX",
 262                                 MASK => 255,
 263                                 VALSSTRING => "NULL",
 264                                 ALIGNMENT => 4
 265                         }
 266                 }
 267         }
 268 );
 269
 270 $x->{ett} = [];
 271 $x->register_ett("name");
 272 is_deeply($x->{ett}, ["name"]);
 273 $x->register_ett("leela");
 274 is_deeply($x->{ett}, ["name", "leela"]);