← Back to branch summary

~ubuntu-branches/ubuntu/maverick/samba/maverick-security

« back to all changes in this revision

Viewing changes to source/pidl/tests/wireshark-ndr.pl

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2009-03-03 22:02:23 UTC
  • mfrom: (0.28.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090303220223-3bdlm2d9fwx1p1ye
Tags: 2:3.3.1-1ubuntu1
https://launchpad.net/bugs/337094
* Merge from Debian unstable (LP: #337094), remaining changes:
  + debian/patches/VERSION.patch:
    - setup SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksambapasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd.
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against ctdb.
  + debian/rules:
    - enable "native" PIE hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
* Dropped changes, merged in Debian:
  + debian/libpam-smbpass.pam-config, debian/libpam-smbpass.postinst,
    debian/libpam-smbpass.prerm, debian/libpam-smbpass.files,
    debian/rules:
    - Make libpam-smbpasswd depend on libpam-runtime to allow 
      libpam-smbpasswd for auto-configuration.
  + debian/control:
    - Provide a config block for the new PAM framework to auto-configure
      itself
  + debian/samba.postinst:
    - When populating the new sambashare group, it is not an error
      if the user simply does not exist; test for this case and let
      the install continue instead of aborting.
  + debian/winbind.files:
    - include additional files

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/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"]);