nexmon – Blame information for rev 1
?pathlinks?
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1 | office | 1 | #!/usr/bin/env perl |
| 2 | # |
||
| 3 | # Copyright 2013 Michael Mann (see AUTHORS file) |
||
| 4 | # |
||
| 5 | # A program to help convert proto_tree_add_text calls into filterable "items" that |
||
| 6 | # use proto_tree_add_item. The program requires 2 passes. "Pass 1" (generate) collects |
||
| 7 | # the eligible proto_tree_add_text calls and outputs the necessary data into a delimited |
||
| 8 | # file. "Pass 2" (fix-all) takes the data from the delimited file and replaces the |
||
| 9 | # proto_tree_add_text calls with proto_tree_add_item or "expert info" calls as well as |
||
| 10 | # generating separate files for the hf and/or ei variable declarations and hf and/or ei array data. |
||
| 11 | # The hf "files" can be copy/pasted into the dissector where appropriate (until such time as |
||
| 12 | # its done automatically) |
||
| 13 | # |
||
| 14 | # Note that the output from "Pass 1" won't always be a perfect conversion for "Pass 2", so |
||
| 15 | # "human interaction" is needed as an intermediary to verify and update the delimited file |
||
| 16 | # before "Pass 2" is done. |
||
| 17 | # It is also recommended to run checkhf.pl and checkAPIs.pl after "Pass 2" is completed. |
||
| 18 | # |
||
| 19 | # Delimited file field format: |
||
| 20 | # <convert proto_tree_add_text_call[0|1|10-13]><add hf or ei variable[0|1|2]><proto_tree var><hf var><tvb var><offset><length><encoding|[EXPERT_GROUPS]> |
||
| 21 | # <[FIELDNAME]><[FIELDTYPE]|[EXPERT_SEVERITY]><[FIELDABBREV]><[FIELDDISPLAY]><[FIELDCONVERT]><[BITMASK]> |
||
| 22 | # |
||
| 23 | # convert proto_tree_add_text_call enumerations: |
||
| 24 | # 0 - no conversions |
||
| 25 | # 1 - proto_tree_add_item |
||
| 26 | # 10 - expert_add_info |
||
| 27 | # 11 - expert_add_info_format |
||
| 28 | # 12 - proto_tree_add_expert |
||
| 29 | # 13 - proto_tree_add_expert_format |
||
| 30 | # |
||
| 31 | # Usage: convert_proto_tree_add_text.pl action=<generate|fix-all> <file or files> |
||
| 32 | # |
||
| 33 | # Lots of code shamelessly borrowed from fix-encoding-args.pl (Thanks Bill!) |
||
| 34 | # |
||
| 35 | # Wireshark - Network traffic analyzer |
||
| 36 | # By Gerald Combs <gerald@wireshark.org> |
||
| 37 | # Copyright 1998 Gerald Combs |
||
| 38 | # |
||
| 39 | # This program is free software; you can redistribute it and/or |
||
| 40 | # modify it under the terms of the GNU General Public License |
||
| 41 | # as published by the Free Software Foundation; either version 2 |
||
| 42 | # of the License, or (at your option) any later version. |
||
| 43 | # |
||
| 44 | # This program is distributed in the hope that it will be useful, |
||
| 45 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
| 46 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
| 47 | # GNU General Public License for more details. |
||
| 48 | # |
||
| 49 | # You should have received a copy of the GNU General Public License |
||
| 50 | # along with this program; if not, write to the Free Software |
||
| 51 | # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
||
| 52 | # |
||
| 53 | |||
| 54 | use strict; |
||
| 55 | use warnings; |
||
| 56 | |||
| 57 | use Getopt::Long; |
||
| 58 | |||
| 59 | my %DISPLAY_BASE = ('BASE_NONE' => "BASE_NONE", |
||
| 60 | 'BASE_DEC' => "BASE_DEC", |
||
| 61 | 'BASE_HEX' => "BASE_HEX", |
||
| 62 | 'BASE_OCT' => "BASE_OCT", |
||
| 63 | 'BASE_DEC_HEX' => "BASE_DEC_HEX", |
||
| 64 | 'BASE_HEX_DEC' => "BASE_HEX_DEC", |
||
| 65 | 'BASE_EXT_STRING' => "BASE_EXT_STRING", |
||
| 66 | 'BASE_RANGE_STRING' => "BASE_RANGE_STRING", |
||
| 67 | 'ABSOLUTE_TIME_LOCAL' => "ABSOLUTE_TIME_LOCAL", |
||
| 68 | 'ABSOLUTE_TIME_UTC' => "ABSOLUTE_TIME_UTC", |
||
| 69 | 'ABSOLUTE_TIME_DOY_UTC' => "ABSOLUTE_TIME_DOY_UTC", |
||
| 70 | 'BASE_CUSTOM' => "BASE_CUSTOM"); |
||
| 71 | |||
| 72 | my %ENCODINGS = ('ENC_BIG_ENDIAN' => "ENC_BIG_ENDIAN", |
||
| 73 | 'ENC_LITTLE_ENDIAN' => "ENC_LITTLE_ENDIAN", |
||
| 74 | 'ENC_TIME_TIMESPEC' => "ENC_TIME_TIMESPEC", |
||
| 75 | 'ENC_TIME_NTP' => "ENC_TIME_NTP", |
||
| 76 | 'ENC_ASCII' => "ENC_ASCII", |
||
| 77 | 'ENC_UTF_8' => "ENC_UTF_8", |
||
| 78 | 'ENC_UTF_16' => "ENC_UTF_16", |
||
| 79 | 'ENC_UCS_2' => "ENC_UCS_2", |
||
| 80 | 'ENC_EBCDIC' => "ENC_EBCDIC", |
||
| 81 | 'ENC_NA' => "ENC_NA"); |
||
| 82 | |||
| 83 | my %FIELD_TYPE = ('FT_NONE' => "FT_NONE", 'FT_PROTOCOL' => "FT_PROTOCOL", 'FT_BOOLEAN' => "FT_BOOLEAN", |
||
| 84 | 'FT_UINT8' => "FT_UINT8", 'FT_UINT16' => "FT_UINT16", 'FT_UINT24' => "FT_UINT24", 'FT_UINT32' => "FT_UINT32", 'FT_UINT64' => "FT_UINT64", |
||
| 85 | 'FT_INT8' => "FT_INT8", 'FT_INT16' => "FT_INT16", 'FT_INT24' => "FT_INT24", 'FT_INT32' => "FT_INT32", 'FT_INT64' => "FT_INT64", |
||
| 86 | 'FT_FLOAT' => "FT_FLOAT", 'FT_DOUBLE' => "FT_DOUBLE", |
||
| 87 | 'FT_ABSOLUTE_TIME' => "FT_ABSOLUTE_TIME", 'FT_RELATIVE_TIME' => "FT_RELATIVE_TIME", |
||
| 88 | 'FT_STRING' => "FT_STRING", 'FT_STRINGZ' => "FT_STRINGZ", 'FT_UINT_STRING' => "FT_UINT_STRING", |
||
| 89 | 'FT_ETHER' => "FT_ETHER", 'FT_BYTES' => "FT_BYTES", 'FT_UINT_BYTES' => "FT_UINT_BYTES", |
||
| 90 | 'FT_IPv4' => "FT_IPv4", 'FT_IPv6' => "FT_IPv6", 'FT_IPXNET' => "FT_IPXNET", 'FT_AX25' => "FT_AX25", 'FT_VINES' => "FT_VINES", |
||
| 91 | 'FT_FRAMENUM' => "FT_FRAMENUM", 'FT_PCRE' => "FT_PCRE", 'FT_GUID' => "FT_GUID", 'FT_OID' => "FT_OID", 'FT_REL_OID' => "FT_REL_OID", 'FT_EUI64' => "FT_EUI64"); |
||
| 92 | |||
| 93 | my %EXPERT_SEVERITY = ('PI_COMMENT' => "PI_COMMENT", |
||
| 94 | 'PI_CHAT' => "PI_CHAT", |
||
| 95 | 'PI_NOTE' => "PI_NOTE", |
||
| 96 | 'PI_WARN' => "PI_WARN", |
||
| 97 | 'PI_ERROR' => "PI_ERROR"); |
||
| 98 | |||
| 99 | my %EXPERT_GROUPS = ('PI_CHECKSUM' => "PI_CHECKSUM", |
||
| 100 | 'PI_SEQUENCE' => "PI_SEQUENCE", |
||
| 101 | 'PI_RESPONSE_CODE' => "PI_RESPONSE_CODE", |
||
| 102 | 'PI_REQUEST_CODE' => "PI_REQUEST_CODE", |
||
| 103 | 'PI_UNDECODED' => "PI_UNDECODED", |
||
| 104 | 'PI_REASSEMBLE' => "PI_REASSEMBLE", |
||
| 105 | 'PI_MALFORMED' => "PI_MALFORMED", |
||
| 106 | 'PI_DEBUG' => "PI_DEBUG", |
||
| 107 | 'PI_PROTOCOL' => "PI_PROTOCOL", |
||
| 108 | 'PI_SECURITY' => "PI_SECURITY", |
||
| 109 | 'PI_COMMENTS_GROUP' => "PI_COMMENTS_GROUP"); |
||
| 110 | |||
| 111 | my @proto_tree_list; |
||
| 112 | my @expert_list; |
||
| 113 | my $protabbrev = ""; |
||
| 114 | |||
| 115 | # Perl trim function to remove whitespace from the start and end of the string |
||
| 116 | sub trim($) |
||
| 117 | { |
||
| 118 | my $string = shift; |
||
| 119 | $string =~ s/^\s+//; |
||
| 120 | $string =~ s/\s+$//; |
||
| 121 | return $string; |
||
| 122 | } |
||
| 123 | |||
| 124 | # --------------------------------------------------------------------- |
||
| 125 | # |
||
| 126 | # MAIN |
||
| 127 | # |
||
| 128 | my $helpFlag = ''; |
||
| 129 | my $action = 'generate'; |
||
| 130 | my $encoding = ''; |
||
| 131 | my $expert = ''; |
||
| 132 | |||
| 133 | my $result = GetOptions( |
||
| 134 | 'action=s' => \$action, |
||
| 135 | 'encoding=s' => \$encoding, |
||
| 136 | 'expert' => \$expert, |
||
| 137 | 'help|?' => \$helpFlag |
||
| 138 | ); |
||
| 139 | |||
| 140 | if (!$result || $helpFlag || !$ARGV[0]) { |
||
| 141 | usage(); |
||
| 142 | } |
||
| 143 | |||
| 144 | sub usage { |
||
| 145 | print "\nUsage: $0 [--action=generate|fix-all|find-all] [--encoding=ENC_BIG_ENDIAN|ENC_LITTLE_ENDIAN] FILENAME [...]\n\n"; |
||
| 146 | print " --action = generate (default)\n"; |
||
| 147 | print " generate - create a delimited file (FILENAME.proto_tree_input) with\n"; |
||
| 148 | print " proto_tree_add_text fields in FILENAME(s)\n"; |
||
| 149 | print " fix-all - Use delimited file (FILENAME.proto_tree_input) to convert\n"; |
||
| 150 | print " proto_tree_add_text to proto_tree_add_item\n"; |
||
| 151 | print " Also generates FILENAME.hf and FILENAME.hf_array to be\n"; |
||
| 152 | print " copy/pasted into the dissector where appropriate\n"; |
||
| 153 | print " find-all - Output the number of eligible proto_tree_add_text calls\n"; |
||
| 154 | print " for conversion\n\n"; |
||
| 155 | print " --expert (Optional) Includes proto_tree_add_text calls with no printf arguments in\n"; |
||
| 156 | print " the .proto_tree_input file as they could be converted to expert info\n"; |
||
| 157 | print " (otherwise they are ignored)\n"; |
||
| 158 | print " Must be called for 'fix-all' if called on 'generate'\n"; |
||
| 159 | print " --encoding (Optional) Default encoding if one can't be determined\n"; |
||
| 160 | print " (effective only for generate)\n"; |
||
| 161 | print " If not specified, an encoding will not be auto-populated\n"; |
||
| 162 | print " if undetermined\n\n"; |
||
| 163 | |||
| 164 | exit(1); |
||
| 165 | } |
||
| 166 | |||
| 167 | # |
||
| 168 | # XXX Outline general algorithm here |
||
| 169 | # |
||
| 170 | my $found_total = 0; |
||
| 171 | my $protabbrev_index; |
||
| 172 | my $line_number = 0; |
||
| 173 | |||
| 174 | while (my $fileName = $ARGV[0]) { |
||
| 175 | shift; |
||
| 176 | my $fileContents = ''; |
||
| 177 | |||
| 178 | die "No such file: \"$fileName\"\n" if (! -e $fileName); |
||
| 179 | |||
| 180 | # delete leading './' |
||
| 181 | $fileName =~ s{ ^ \. / } {}xo; |
||
| 182 | |||
| 183 | #determine PROTABBREV for dissector based on file name format of (dirs)/packet-PROTABBREV.c |
||
| 184 | $protabbrev_index = rindex($fileName, "packet-"); |
||
| 185 | if ($protabbrev_index == -1) { |
||
| 186 | print "$fileName doesn't fit format of packet-PROTABBREV.c\n"; |
||
| 187 | next; |
||
| 188 | } |
||
| 189 | |||
| 190 | $protabbrev = substr($fileName, $protabbrev_index+length("packet-")); |
||
| 191 | $protabbrev_index = rindex($protabbrev, "."); |
||
| 192 | if ($protabbrev_index == -1) { |
||
| 193 | print "$fileName doesn't fit format of packet-PROTABBREV.c\n"; |
||
| 194 | next; |
||
| 195 | } |
||
| 196 | $protabbrev = lc(substr($protabbrev, 0, $protabbrev_index)); |
||
| 197 | |||
| 198 | # Read in the file (ouch, but it's easier that way) |
||
| 199 | open(FCI, "<", $fileName) || die("Couldn't open $fileName"); |
||
| 200 | while (<FCI>) { |
||
| 201 | $fileContents .= $_; |
||
| 202 | } |
||
| 203 | close(FCI); |
||
| 204 | |||
| 205 | if ($action eq "generate") { |
||
| 206 | generate_hfs(\$fileContents, $fileName); |
||
| 207 | } |
||
| 208 | |||
| 209 | if ($action eq "fix-all") { |
||
| 210 | # Read in the hf "input" file |
||
| 211 | $line_number = 0; |
||
| 212 | my $errors = 0; |
||
| 213 | open(FCI, "<", $fileName . ".proto_tree_input") || die("Couldn't open $fileName.proto_tree_input"); |
||
| 214 | while(my $line=<FCI>){ |
||
| 215 | my @proto_tree_item = split(/;|\n/, $line); |
||
| 216 | |||
| 217 | $line_number++; |
||
| 218 | $errors += verify_line(@proto_tree_item); |
||
| 219 | |||
| 220 | push(@proto_tree_list, \@proto_tree_item); |
||
| 221 | if ($proto_tree_item[1] eq "2") { |
||
| 222 | push(@expert_list, \@proto_tree_item); |
||
| 223 | } |
||
| 224 | } |
||
| 225 | close(FCI); |
||
| 226 | |||
| 227 | if ($errors > 0) { |
||
| 228 | print "Aborting conversion.\n"; |
||
| 229 | exit(-1); |
||
| 230 | } |
||
| 231 | |||
| 232 | fix_proto_tree_add_text(\$fileContents, $fileName); |
||
| 233 | |||
| 234 | # Write out the hf data |
||
| 235 | output_hf_array($fileName); |
||
| 236 | output_hf($fileName); |
||
| 237 | |||
| 238 | # Write out the changed version to a file |
||
| 239 | open(FCO, ">", $fileName . ".proto_tree_add_text"); |
||
| 240 | print FCO "$fileContents"; |
||
| 241 | close(FCO); |
||
| 242 | } |
||
| 243 | |||
| 244 | if ($action eq "find-all") { |
||
| 245 | # Find all proto_tree_add_text() statements eligible for conversion |
||
| 246 | $found_total += find_all(\$fileContents, $fileName); |
||
| 247 | } |
||
| 248 | |||
| 249 | } # while |
||
| 250 | |||
| 251 | exit $found_total; |
||
| 252 | |||
| 253 | # --------------------------------------------------------------------- |
||
| 254 | # Sanity check the data in the .proto_tree_input file |
||
| 255 | sub verify_line { |
||
| 256 | my( @proto_tree_item) = @_; |
||
| 257 | my $errors = 0; |
||
| 258 | |||
| 259 | #do some basic error checking of the file |
||
| 260 | if ($proto_tree_item[0] eq "1") { |
||
| 261 | if (!($proto_tree_item[3] =~ /^hf_/)) { |
||
| 262 | print "$line_number: Poorly formed hf_ variable ($proto_tree_item[3])!\n"; |
||
| 263 | $errors++; |
||
| 264 | } |
||
| 265 | |||
| 266 | foreach (split(/\|/, $proto_tree_item[7])) { |
||
| 267 | if (!exists($ENCODINGS{$_})) { |
||
| 268 | print "$line_number: Encoding value '$_' unknown!\n"; |
||
| 269 | $errors++; |
||
| 270 | } |
||
| 271 | } |
||
| 272 | } elsif (($proto_tree_item[0] eq "10") || |
||
| 273 | ($proto_tree_item[0] eq "11") || |
||
| 274 | ($proto_tree_item[0] eq "12") || |
||
| 275 | ($proto_tree_item[0] eq "13")) { |
||
| 276 | #expert info conversions |
||
| 277 | if (!($proto_tree_item[3] =~ /^ei_/)) { |
||
| 278 | print "$line_number: Poorly formed ei_ variable ($proto_tree_item[3])!\n"; |
||
| 279 | $errors++; |
||
| 280 | } |
||
| 281 | } elsif ($proto_tree_item[0] ne "0") { |
||
| 282 | print "Bad conversion value! Aborting conversion.\n"; |
||
| 283 | $errors++; |
||
| 284 | } |
||
| 285 | |||
| 286 | if ($proto_tree_item[1] eq "1") { |
||
| 287 | if (!($proto_tree_item[3] =~ /^hf_/)) { |
||
| 288 | print "$line_number: Poorly formed hf_ variable ($proto_tree_item[3])!\n"; |
||
| 289 | $errors++; |
||
| 290 | } |
||
| 291 | if (!exists($FIELD_TYPE{$proto_tree_item[9]})) { |
||
| 292 | print "$line_number: Field type '$proto_tree_item[9]' unknown!\n"; |
||
| 293 | $errors++; |
||
| 294 | } |
||
| 295 | foreach (split(/\|/, $proto_tree_item[11])) { |
||
| 296 | if ((!exists($DISPLAY_BASE{$_})) && |
||
| 297 | (!($proto_tree_item[11] =~ /\d+/))) { |
||
| 298 | print "$line_number: Display base '$proto_tree_item[11]' unknown!\n"; |
||
| 299 | $errors++; |
||
| 300 | } |
||
| 301 | } |
||
| 302 | if (($proto_tree_item[9] eq "FT_UINT8") || |
||
| 303 | ($proto_tree_item[9] eq "FT_UINT16") || |
||
| 304 | ($proto_tree_item[9] eq "FT_UINT24") || |
||
| 305 | ($proto_tree_item[9] eq "FT_UINT32") || |
||
| 306 | ($proto_tree_item[9] eq "FT_UINT64") || |
||
| 307 | ($proto_tree_item[9] eq "FT_INT8") || |
||
| 308 | ($proto_tree_item[9] eq "FT_INT16") || |
||
| 309 | ($proto_tree_item[9] eq "FT_INT24") || |
||
| 310 | ($proto_tree_item[9] eq "FT_INT32") || |
||
| 311 | ($proto_tree_item[9] eq "FT_INT64")) { |
||
| 312 | if ($proto_tree_item[11] eq "BASE_NONE") { |
||
| 313 | print "$line_number: Interger type should not be BASE_NONE!\n"; |
||
| 314 | $errors++; |
||
| 315 | } |
||
| 316 | } |
||
| 317 | |||
| 318 | } elsif ($proto_tree_item[1] eq "2") { |
||
| 319 | if (!($proto_tree_item[3] =~ /^ei_/)) { |
||
| 320 | print "$line_number: Poorly formed ei_ variable ($proto_tree_item[3])!\n"; |
||
| 321 | $errors++; |
||
| 322 | } |
||
| 323 | if (!exists($EXPERT_SEVERITY{$proto_tree_item[9]})) { |
||
| 324 | print "$line_number: Expert severity value '$proto_tree_item[9]' unknown!\n"; |
||
| 325 | $errors++; |
||
| 326 | } |
||
| 327 | if (!exists($EXPERT_GROUPS{$proto_tree_item[7]})) { |
||
| 328 | print "$line_number: Expert group value '$proto_tree_item[7]' unknown!\n"; |
||
| 329 | $errors++; |
||
| 330 | } |
||
| 331 | |||
| 332 | } elsif ($proto_tree_item[1] ne "0") { |
||
| 333 | print "$line_number: Bad hf/ei variable generation value!\n"; |
||
| 334 | $errors++; |
||
| 335 | } |
||
| 336 | |||
| 337 | return $errors; |
||
| 338 | } |
||
| 339 | |||
| 340 | sub generate_hfs { |
||
| 341 | my( $fileContentsRef, $fileName) = @_; |
||
| 342 | my @args; |
||
| 343 | my $num_items = 0; |
||
| 344 | my @temp; |
||
| 345 | my $str_temp; |
||
| 346 | my $pat; |
||
| 347 | |||
| 348 | if ($expert ne "") { |
||
| 349 | $pat = qr / |
||
| 350 | ( |
||
| 351 | (?:proto_tree_add_text)\s* \( |
||
| 352 | (([^[\,;])*\,){4,} |
||
| 353 | [^;]* |
||
| 354 | \s* \) \s* ; |
||
| 355 | ) |
||
| 356 | /xs; |
||
| 357 | } else { |
||
| 358 | $pat = qr / |
||
| 359 | ( |
||
| 360 | (?:proto_tree_add_text)\s* \( |
||
| 361 | (([^[\,;])*\,){5,} |
||
| 362 | [^;]* |
||
| 363 | \s* \) \s* ; |
||
| 364 | ) |
||
| 365 | /xs; |
||
| 366 | } |
||
| 367 | |||
| 368 | while ($$fileContentsRef =~ / $pat /xgso) { |
||
| 369 | my @proto_tree_item = (1, 1, "tree", "hf_name", "tvb", "offset", "length", "encoding", |
||
| 370 | "fieldfullname", "fieldtype", "fieldabbrevname", "BASE_NONE", "NULL", "0x0"); |
||
| 371 | my $str = "${1}\n"; |
||
| 372 | $str =~ tr/\t\n\r/ /d; |
||
| 373 | $str =~ s/ \s+ / /xg; |
||
| 374 | #print "$fileName: $str\n"; |
||
| 375 | |||
| 376 | @args = split(/,/, $str); |
||
| 377 | #printf "ARGS(%d): %s\n", scalar @args, join("# ", @args); |
||
| 378 | $args[0] =~ s/proto_tree_add_text\s*\(\s*//; |
||
| 379 | $proto_tree_item[2] = $args[0]; #tree |
||
| 380 | $proto_tree_item[4] = trim($args[1]); #tvb |
||
| 381 | $proto_tree_item[5] = trim($args[2]); #offset |
||
| 382 | $proto_tree_item[6] = trim($args[3]); #length |
||
| 383 | if (scalar @args == 5) { |
||
| 384 | #remove the "); at the end |
||
| 385 | $args[4] =~ s/\"\s*\)\s*;$//; |
||
| 386 | } |
||
| 387 | |||
| 388 | #encoding |
||
| 389 | if (scalar @args > 5) { |
||
| 390 | if (($proto_tree_item[6] eq "1") || |
||
| 391 | ($args[5] =~ /tvb_get_guint8/) || |
||
| 392 | ($args[5] =~ /tvb_bytes_to_str/) || |
||
| 393 | ($args[5] =~ /tvb_ether_to_str/)) { |
||
| 394 | $proto_tree_item[7] = "ENC_NA"; |
||
| 395 | } elsif ($args[5] =~ /tvb_get_ntoh/) { |
||
| 396 | $proto_tree_item[7] = "ENC_BIG_ENDIAN"; |
||
| 397 | } elsif ($args[5] =~ /tvb_get_letoh/) { |
||
| 398 | $proto_tree_item[7] = "ENC_LITTLE_ENDIAN"; |
||
| 399 | } elsif (($args[5] =~ /tvb_get_ephemeral_string/) || |
||
| 400 | ($args[5] =~ /tvb_format_text/)){ |
||
| 401 | $proto_tree_item[7] = "ENC_NA|ENC_ASCII"; |
||
| 402 | } elsif ($encoding ne "") { |
||
| 403 | $proto_tree_item[7] = $encoding; |
||
| 404 | } |
||
| 405 | } |
||
| 406 | |||
| 407 | #field full name |
||
| 408 | if (($expert ne "") || (scalar @args > 5)) { |
||
| 409 | my @arg_temp = split(/=|:/, $args[4]); |
||
| 410 | $proto_tree_item[8] = $arg_temp[0]; |
||
| 411 | } else { |
||
| 412 | $proto_tree_item[8] = $args[4]; |
||
| 413 | } |
||
| 414 | $proto_tree_item[8] =~ s/\"//; |
||
| 415 | $proto_tree_item[8] = trim($proto_tree_item[8]); |
||
| 416 | |||
| 417 | if ($proto_tree_item[8] eq "%s\"") { |
||
| 418 | #assume proto_tree_add_text will not be converted |
||
| 419 | $proto_tree_item[0] = 0; |
||
| 420 | $proto_tree_item[1] = 0; |
||
| 421 | $proto_tree_item[3] = sprintf("hf_%s_", $protabbrev); |
||
| 422 | $proto_tree_item[10] = sprintf("%s.", $protabbrev); |
||
| 423 | } else { |
||
| 424 | #hf variable name |
||
| 425 | $proto_tree_item[3] = sprintf("hf_%s_%s", $protabbrev, lc($proto_tree_item[8])); |
||
| 426 | $proto_tree_item[3] =~ s/\s+|-|:/_/g; |
||
| 427 | |||
| 428 | #field abbreviated name |
||
| 429 | $proto_tree_item[10] = sprintf("%s.%s", $protabbrev, lc($proto_tree_item[8])); |
||
| 430 | $proto_tree_item[10] =~ s/\s+|-|:/_/g; |
||
| 431 | } |
||
| 432 | |||
| 433 | #VALS |
||
| 434 | if ($str =~ /val_to_str(_const)?\(\s*tvb_get_[^\(]*\([^\,]*,[^\)]*\)\s*\,\s*([^\,]*)\s*\,\s*([^\)]*)\)/) { |
||
| 435 | $proto_tree_item[12] = sprintf("VALS(%s)", trim($2)); |
||
| 436 | } elsif ($str =~ /val_to_str(_const)?\([^\,]*\,([^\,]*)\,/) { |
||
| 437 | $proto_tree_item[12] = sprintf("VALS(%s)", trim($2)); |
||
| 438 | } elsif ($str =~ /val_to_str_ext(_const)?\(\s*tvb_get_[^\(]*\([^\,]*,[^\)]*\)\s*\,\s*([^\,]*)\s*\,\s*([^\)]*)\)/) { |
||
| 439 | $proto_tree_item[12] = trim($2); |
||
| 440 | } elsif ($str =~ /val_to_str_ext(_const)?\([^\,]*\,([^\,]*)\,/) { |
||
| 441 | $proto_tree_item[12] = trim($2); |
||
| 442 | } |
||
| 443 | |||
| 444 | #field type |
||
| 445 | if (scalar @args > 5) { |
||
| 446 | if ($args[5] =~ /tvb_get_guint8/) { |
||
| 447 | if ($args[4] =~ /%[0-9]*[i]/) { |
||
| 448 | $proto_tree_item[9] = "FT_INT8"; |
||
| 449 | } else { |
||
| 450 | $proto_tree_item[9] = "FT_UINT8"; |
||
| 451 | } |
||
| 452 | } elsif ($args[5] =~ /tvb_get_(n|"le")tohs/) { |
||
| 453 | if ($args[4] =~ /%[0-9]*[i]/) { |
||
| 454 | $proto_tree_item[9] = "FT_INT16"; |
||
| 455 | } else { |
||
| 456 | $proto_tree_item[9] = "FT_UINT16"; |
||
| 457 | } |
||
| 458 | } elsif ($args[5] =~ /tvb_get_(n|"le")toh24/) { |
||
| 459 | if ($args[4] =~ /%[0-9]*[i]/) { |
||
| 460 | $proto_tree_item[9] = "FT_INT24"; |
||
| 461 | } else { |
||
| 462 | $proto_tree_item[9] = "FT_UINT24"; |
||
| 463 | } |
||
| 464 | } elsif ($args[5] =~ /tvb_get_(n|"le")tohl/) { |
||
| 465 | if ($args[4] =~ /%[0-9]*[i]/) { |
||
| 466 | $proto_tree_item[9] = "FT_INT32"; |
||
| 467 | } else { |
||
| 468 | $proto_tree_item[9] = "FT_UINT32"; |
||
| 469 | } |
||
| 470 | } elsif ($args[5] =~ /tvb_get_(n|"le")toh("40"|"48"|"56"|"64")/) { |
||
| 471 | if ($args[4] =~ /%[0-9]*[i]/) { |
||
| 472 | $proto_tree_item[9] = "FT_INT64"; |
||
| 473 | } else { |
||
| 474 | $proto_tree_item[9] = "FT_UINT64"; |
||
| 475 | } |
||
| 476 | } elsif (($args[5] =~ /tvb_get_(n|"le")tohieee_float/) || |
||
| 477 | ($args[4] =~ /%[0-9\.]*[fFeEgG]/)) { |
||
| 478 | $proto_tree_item[9] = "FT_FLOAT"; |
||
| 479 | } elsif ($args[5] =~ /tvb_get_(n|"le")tohieee_double/) { |
||
| 480 | $proto_tree_item[9] = "FT_DOUBLE"; |
||
| 481 | } elsif (($args[5] =~ /tvb_get_ipv4/) || |
||
| 482 | ($args[5] =~ /tvb_ip_to_str/)) { |
||
| 483 | $proto_tree_item[9] = "FT_IPv4"; |
||
| 484 | } elsif (($args[5] =~ /tvb_get_ipv6/) || |
||
| 485 | ($args[5] =~ /tvb_ip6_to_str/)) { |
||
| 486 | $proto_tree_item[9] = "FT_IPv6"; |
||
| 487 | } elsif ($args[5] =~ /tvb_get_(n|"le")tohguid/) { |
||
| 488 | $proto_tree_item[9] = "FT_GUID"; |
||
| 489 | } elsif ($args[5] =~ /tvb_get_ephemeral_stringz/) { |
||
| 490 | $proto_tree_item[9] = "FT_STRINGZ"; |
||
| 491 | } elsif (($args[5] =~ /tvb_get_ephemeral_string/) || |
||
| 492 | ($args[5] =~ /tvb_format_text/)){ |
||
| 493 | $proto_tree_item[9] = "FT_STRING"; |
||
| 494 | } elsif (($args[5] =~ /tvb_bytes_to_str/)) { |
||
| 495 | $proto_tree_item[9] = "FT_BYTES"; |
||
| 496 | } elsif ($args[5] =~ /tvb_ether_to_str/) { |
||
| 497 | $proto_tree_item[9] = "FT_ETHER"; |
||
| 498 | } |
||
| 499 | |||
| 500 | #if we still can't determine type, assume a constant length |
||
| 501 | #value means we have an unsigned value |
||
| 502 | if ($proto_tree_item[9] eq "fieldtype") { |
||
| 503 | my $len_str = trim($args[3]); |
||
| 504 | if ($len_str eq "1") { |
||
| 505 | $proto_tree_item[9] = "FT_UINT8"; |
||
| 506 | } elsif ($len_str eq "2") { |
||
| 507 | $proto_tree_item[9] = "FT_UINT16"; |
||
| 508 | } elsif ($len_str eq "3") { |
||
| 509 | $proto_tree_item[9] = "FT_UINT24"; |
||
| 510 | } elsif ($len_str eq "4") { |
||
| 511 | $proto_tree_item[9] = "FT_UINT32"; |
||
| 512 | } elsif ($len_str eq "8") { |
||
| 513 | $proto_tree_item[9] = "FT_UINT64"; |
||
| 514 | } |
||
| 515 | } |
||
| 516 | } |
||
| 517 | |||
| 518 | #display base |
||
| 519 | if ($args[4] =~ /%[0-9]*[xX]/) { |
||
| 520 | $proto_tree_item[11] = "BASE_HEX"; |
||
| 521 | } elsif ($args[4] =~ /%[0-9]*[uld]/) { |
||
| 522 | $proto_tree_item[11] = "BASE_DEC"; |
||
| 523 | } elsif ($args[4] =~ /%[0-9]*o/) { |
||
| 524 | $proto_tree_item[11] = "BASE_OCT"; |
||
| 525 | } |
||
| 526 | if ($str =~ /val_to_str_ext(_const)?\([^\,]*\,([^\,]*)\,/) { |
||
| 527 | $proto_tree_item[11] .= "|BASE_EXT_STRING"; |
||
| 528 | } |
||
| 529 | |||
| 530 | if (($proto_tree_item[7] eq "encoding") && ($proto_tree_item[9] eq "FT_BYTES")) { |
||
| 531 | $proto_tree_item[7] = "ENC_NA"; |
||
| 532 | } |
||
| 533 | |||
| 534 | push(@proto_tree_list, \@proto_tree_item); |
||
| 535 | |||
| 536 | $num_items += 1; |
||
| 537 | } |
||
| 538 | |||
| 539 | if ($num_items > 0) { |
||
| 540 | open(FCO, ">", $fileName . ".proto_tree_input"); |
||
| 541 | for my $item (@proto_tree_list) { |
||
| 542 | print FCO join(";", @{$item}), "\n"; |
||
| 543 | } |
||
| 544 | close(FCO); |
||
| 545 | } |
||
| 546 | } |
||
| 547 | |||
| 548 | # --------------------------------------------------------------------- |
||
| 549 | # Find all proto_tree_add_text calls and replace them with the data |
||
| 550 | # found in proto_tree_list |
||
| 551 | sub fix_proto_tree_add_text { |
||
| 552 | my( $fileContentsRef, $fileName) = @_; |
||
| 553 | my $found = 0; |
||
| 554 | my $pat; |
||
| 555 | |||
| 556 | if ($expert ne "") { |
||
| 557 | $pat = qr / |
||
| 558 | ( |
||
| 559 | (?:proto_tree_add_text)\s* \( |
||
| 560 | (([^[\,;])*\,){4,} |
||
| 561 | [^;]* |
||
| 562 | \s* \) \s* ; |
||
| 563 | ) |
||
| 564 | /xs; |
||
| 565 | } else { |
||
| 566 | $pat = qr / |
||
| 567 | ( |
||
| 568 | (?:proto_tree_add_text)\s* \( |
||
| 569 | (([^[\,;])*\,){5,} |
||
| 570 | [^;]* |
||
| 571 | \s* \) \s* ; |
||
| 572 | ) |
||
| 573 | /xs; |
||
| 574 | } |
||
| 575 | |||
| 576 | $$fileContentsRef =~ s/ $pat /patsub($found, $1)/xges; |
||
| 577 | } |
||
| 578 | |||
| 579 | # --------------------------------------------------------------------- |
||
| 580 | # Format proto_tree_add_item or expert info functions with proto_tree_list data |
||
| 581 | sub patsub { |
||
| 582 | my $item_str; |
||
| 583 | if ($proto_tree_list[$_[0]][0] eq "1") { |
||
| 584 | $item_str = sprintf("proto_tree_add_item(%s, %s, %s, %s, %s, %s);", |
||
| 585 | $proto_tree_list[$_[0]][2], $proto_tree_list[$_[0]][3], |
||
| 586 | $proto_tree_list[$_[0]][4], $proto_tree_list[$_[0]][5], |
||
| 587 | $proto_tree_list[$_[0]][6], $proto_tree_list[$_[0]][7]); |
||
| 588 | } elsif ($proto_tree_list[$_[0]][0] eq "10") { |
||
| 589 | $item_str = sprintf("expert_add_info(pinfo, %s, &%s);", |
||
| 590 | $proto_tree_list[$_[0]][2], $proto_tree_list[$_[0]][3]); |
||
| 591 | } elsif ($proto_tree_list[$_[0]][0] eq "11") { |
||
| 592 | $item_str = sprintf("expert_add_info_format(pinfo, %s, &%s, \"%s\"", |
||
| 593 | $proto_tree_list[$_[0]][2], $proto_tree_list[$_[0]][3], |
||
| 594 | $proto_tree_list[$_[0]][8]); |
||
| 595 | if ($proto_tree_list[$_[0]][11] ne "") { |
||
| 596 | $item_str .= ", $proto_tree_list[$_[0]][11]"; |
||
| 597 | } |
||
| 598 | $item_str .= ");"; |
||
| 599 | } elsif ($proto_tree_list[$_[0]][0] eq "12") { |
||
| 600 | $item_str = sprintf("proto_tree_add_expert(%s, pinfo, &%s, %s, %s, %s);", |
||
| 601 | $proto_tree_list[$_[0]][2], $proto_tree_list[$_[0]][3], |
||
| 602 | $proto_tree_list[$_[0]][4], $proto_tree_list[$_[0]][5], |
||
| 603 | $proto_tree_list[$_[0]][6]); |
||
| 604 | } elsif ($proto_tree_list[$_[0]][0] eq "13") { |
||
| 605 | $item_str = sprintf("proto_tree_add_expert_format(%s, pinfo, &%s, %s, %s, %s, \"%s\"", |
||
| 606 | $proto_tree_list[$_[0]][2], $proto_tree_list[$_[0]][3], |
||
| 607 | $proto_tree_list[$_[0]][4], $proto_tree_list[$_[0]][5], |
||
| 608 | $proto_tree_list[$_[0]][6], $proto_tree_list[$_[0]][8]); |
||
| 609 | if ($proto_tree_list[$_[0]][11] ne "") { |
||
| 610 | $item_str .= ", $proto_tree_list[$_[0]][11]"; |
||
| 611 | } |
||
| 612 | $item_str .= ");"; |
||
| 613 | } else { |
||
| 614 | $item_str = $1; |
||
| 615 | } |
||
| 616 | |||
| 617 | $_[0] += 1; |
||
| 618 | |||
| 619 | return $item_str; |
||
| 620 | } |
||
| 621 | |||
| 622 | # --------------------------------------------------------------------- |
||
| 623 | # Output the hf variable declarations. For now, write them to a file. |
||
| 624 | # XXX - Eventually find the right place to add it to the modified dissector file |
||
| 625 | sub output_hf { |
||
| 626 | my( $fileName) = @_; |
||
| 627 | my %hfs = (); |
||
| 628 | my %eis = (); |
||
| 629 | my $index; |
||
| 630 | my $key; |
||
| 631 | |||
| 632 | open(FCO, ">", $fileName . ".hf"); |
||
| 633 | |||
| 634 | print FCO "/* Generated from convert_proto_tree_add_text.pl */\n"; |
||
| 635 | |||
| 636 | #add hfs to hash table to prevent against (accidental) duplicates |
||
| 637 | for ($index=0;$index<@proto_tree_list;$index++) { |
||
| 638 | if ($proto_tree_list[$index][1] eq "1") { |
||
| 639 | $hfs{$proto_tree_list[$index][3]} = $proto_tree_list[$index][3]; |
||
| 640 | print FCO "static int $proto_tree_list[$index][3] = -1;\n"; |
||
| 641 | } elsif ($proto_tree_list[$index][1] eq "2") { |
||
| 642 | $eis{$proto_tree_list[$index][3]} = $proto_tree_list[$index][3]; |
||
| 643 | } |
||
| 644 | } |
||
| 645 | |||
| 646 | if (scalar keys %hfs > 0) { |
||
| 647 | print FCO "\n\n"; |
||
| 648 | } |
||
| 649 | |||
| 650 | print FCO "/* Generated from convert_proto_tree_add_text.pl */\n"; |
||
| 651 | |||
| 652 | foreach $key (keys %eis) { |
||
| 653 | print FCO "static expert_field $key = EI_INIT;\n"; |
||
| 654 | } |
||
| 655 | close(FCO); |
||
| 656 | |||
| 657 | } |
||
| 658 | |||
| 659 | # --------------------------------------------------------------------- |
||
| 660 | # Output the hf array items. For now, write them to a file. |
||
| 661 | # XXX - Eventually find the right place to add it to the modified dissector file |
||
| 662 | # (bonus points if formatting of hf array in dissector file is kept) |
||
| 663 | sub output_hf_array { |
||
| 664 | my( $fileName) = @_; |
||
| 665 | my $index; |
||
| 666 | my %hfs = (); |
||
| 667 | my %eis = (); |
||
| 668 | |||
| 669 | open(FCO, ">", $fileName . ".hf_array"); |
||
| 670 | |||
| 671 | print FCO " /* Generated from convert_proto_tree_add_text.pl */\n"; |
||
| 672 | |||
| 673 | for ($index=0;$index<@proto_tree_list;$index++) { |
||
| 674 | if ($proto_tree_list[$index][1] eq "1") { |
||
| 675 | if (exists($hfs{$proto_tree_list[$index][3]})) { |
||
| 676 | print "duplicate hf entry '$proto_tree_list[$index][3]' found! Aborting conversion.\n"; |
||
| 677 | exit(-1); |
||
| 678 | } |
||
| 679 | $hfs{$proto_tree_list[$index][3]} = $proto_tree_list[$index][3]; |
||
| 680 | print FCO " { &$proto_tree_list[$index][3], { \"$proto_tree_list[$index][8]\", \"$proto_tree_list[$index][10]\", "; |
||
| 681 | print FCO "$proto_tree_list[$index][9], $proto_tree_list[$index][11], $proto_tree_list[$index][12], $proto_tree_list[$index][13], NULL, HFILL }},\r\n"; |
||
| 682 | } |
||
| 683 | } |
||
| 684 | |||
| 685 | if ($index > 0) { |
||
| 686 | print FCO "\n\n"; |
||
| 687 | } |
||
| 688 | |||
| 689 | print FCO " /* Generated from convert_proto_tree_add_text.pl */\n"; |
||
| 690 | for ($index=0;$index<@expert_list;$index++) { |
||
| 691 | if (exists($eis{$expert_list[$index][3]})) { |
||
| 692 | print "duplicate ei entry '$expert_list[$index][3]' found! Aborting conversion.\n"; |
||
| 693 | exit(-1); |
||
| 694 | } |
||
| 695 | $eis{$expert_list[$index][3]} = $expert_list[$index][3]; |
||
| 696 | |||
| 697 | print FCO " { &$expert_list[$index][3], { \"$expert_list[$index][10]\", $expert_list[$index][7], "; |
||
| 698 | print FCO "$expert_list[$index][9], \"$expert_list[$index][8]\", EXPFILL }},\r\n"; |
||
| 699 | } |
||
| 700 | |||
| 701 | close(FCO); |
||
| 702 | } |
||
| 703 | |||
| 704 | # --------------------------------------------------------------------- |
||
| 705 | # Find all proto_tree_add_text calls that have parameters passed in them |
||
| 706 | # and output number found |
||
| 707 | |||
| 708 | sub find_all { |
||
| 709 | my( $fileContentsRef, $fileName) = @_; |
||
| 710 | |||
| 711 | my $found = 0; |
||
| 712 | my $tvb_found = 0; |
||
| 713 | my $pat; |
||
| 714 | my $tvb_percent; |
||
| 715 | |||
| 716 | if ($expert ne "") { |
||
| 717 | $pat = qr / |
||
| 718 | ( |
||
| 719 | (?:proto_tree_add_text)\s* \( |
||
| 720 | (([^[\,;])*\,){4,} |
||
| 721 | [^;]* |
||
| 722 | \s* \) \s* ; |
||
| 723 | ) |
||
| 724 | /xs; |
||
| 725 | } else { |
||
| 726 | $pat = qr / |
||
| 727 | ( |
||
| 728 | (?:proto_tree_add_text)\s* \( |
||
| 729 | (([^[\,;])*\,){5,} |
||
| 730 | [^;]* |
||
| 731 | \s* \) \s* ; |
||
| 732 | ) |
||
| 733 | /xs; |
||
| 734 | } |
||
| 735 | |||
| 736 | while ($$fileContentsRef =~ / $pat /xgso) { |
||
| 737 | my $str = "${1}\n"; |
||
| 738 | my @args = split(/,/, ${1}); |
||
| 739 | |||
| 740 | #cleanup whitespace to show proto_tree_add_text in single line (easier for seeing grep results) |
||
| 741 | $str =~ tr/\t\n\r/ /d; |
||
| 742 | $str =~ s/ \s+ / /xg; |
||
| 743 | #print "$fileName: $str\n"; |
||
| 744 | |||
| 745 | #find all instances where proto_tree_add_text has a tvb_get (or similar) call, because |
||
| 746 | #convert_proto_tree_add_text.pl has an easier time determining hf_ field values with it |
||
| 747 | if (scalar @args > 5) { |
||
| 748 | my $tvb = trim($args[5]); |
||
| 749 | if ($tvb =~ /^tvb_/) { |
||
| 750 | $tvb_found += 1; |
||
| 751 | } |
||
| 752 | } |
||
| 753 | |||
| 754 | $found += 1; |
||
| 755 | } |
||
| 756 | |||
| 757 | if ($found > 0) { |
||
| 758 | if ($tvb_found > 0) { |
||
| 759 | $tvb_percent = 100*$tvb_found/$found; |
||
| 760 | |||
| 761 | printf "%s: Found %d proto_tree_add_text calls eligible for conversion, %d contain a \"tvb get\" call (%.2f%%).\n", |
||
| 762 | $fileName, $found, $tvb_found, $tvb_percent; |
||
| 763 | } else { |
||
| 764 | print "$fileName: Found $found proto_tree_add_text calls eligible for conversion, 0 \"tvb get\" calls.\n"; |
||
| 765 | } |
||
| 766 | } |
||
| 767 | return $found; |
||
| 768 | } |