Contents of /bin/check-new-issues

#!/usr/bin/perl

use strict;
use File::Temp;
use Getopt::Std;
#use Smart::Comments;
use Term::ReadLine;

my %opts;
getopts('ln:fhi:t:Tca:e:uU', \%opts);

if ($opts{h}) {
    print <<'EOF';
downloads allitems.txt from cve.mitre.org and shows full decription for each
"TODO: check" item (2003 and newer). Then

- tries to guess product name and php filename and does 
  apt-cache and apt-file search
- waits for input:
  * blank line to skip to next issue
  * .fname to do "apt-file search name"
  * .cname to do "apt-cache search name"
  * .mpackage to search data/embedded-code-copies for "package"
  * v or e to launch an editor with the current item
  * q to save and quit
  * CTRL-C to quit without saving
  * everything else is inserted as product name for a NOT-FOR-US

Use "svn diff" and "svn revert" as needed ;-)

OPTIONS: [ -l [-n <n>] [-f] ]
-l        : just list issues 
-n <n>    : show max n lines of each description (default 2)
-f        : show full CVE/list entry as well
-i regexp : use regexp to select todos (default: 'CVE-20(?:0[3-9]|1[0-9])' )
-t regexp : use regexp to select todos (default: '^\s+TODO: check$' )
-T        : same as -t '^\s+TODO: check' (note the missing $)
-u        : also show unfixed issues without bug reference
-U        : only show unfixed issues without bug reference instead of TODO items
-c        : only do syntax check of embedded-code-copies
-e <file> : use <file> for embedded-code-copies, "-" for STDIN
-a <n>    : If automatic apt-cache/apt-file search gives more than n results,
            display only the count (default 10)

EOF

    exit(0);
}

# TODO/BUGS:
# - go back to previous issue / undo
# - handle entries with several TODO lines
# - handle claimed-by
# - look for ITPs?


my $basedir;
if (-e "secure-testing/data/CVE/list") {
        $basedir="secure-testing";
} elsif (-e "data/CVE/list") {
        $basedir=".";
} elsif (-e "../data/CVE/list") {
        $basedir="..";
}


my $embed_code = {};
my $embed_pkg = {};
my $embed_errors;

read_embedded_copies();

if ($opts{c}) {
        exit($embed_errors);
}


my $datafile="$basedir/data/CVE/list";
my $allitemsfile="gunzip -c $basedir/../allitems.txt.gz|";
my $allitemsurl="http://cve.mitre.org/data/downloads/allitems.txt.gz";

my $issue_regexp= $opts{i} || 'CVE-20(?:0[3-9]|1[0-9])';
my $todo_regexp= $opts{t} || ( $opts{T} ? '^\s+TODO: check' : '^\s+TODO: check$' );
my $auto_display_limit = 10;
$auto_display_limit = $opts{a} if defined $opts{a};

my $editor=$ENV{EDITOR} || $ENV{VISUAL} || "vi";

system "cd $basedir/.. ; wget -N $allitemsurl";


print "Reading data...\n";

my $entries=read_file($datafile, qr/^CVE/ );
my $CVEs=read_file($allitemsfile, qr/^=+$/ );
my $data;
my @todos;
my %afcache;
my $num_todo;
my $num_missing_bug;

foreach my $cve (@{$CVEs}) {
        $cve =~ /^Name:\s*(CVE\S+)/m or next;
        $data->{$1}->{CVE}=\$cve;
}

# packages that should be ignored by -u/-U
my @ignore_missing_bug_list = qw/linux-2.6 linux-2.6.24
        kfreebsd-source kfreebsd-5 kfreebsd-6 kfreebsd-7
        mozilla mozilla-firefox mozilla-thunderbird firefox
        php4
        gnutls11
        /;
my %ignore_missing_bug;
$ignore_missing_bug{$_} = 1 for @ignore_missing_bug_list;

foreach my $entry (@{$entries}) {
        my $name;
        if ( $entry =~ /^(CVE-....-\d\d\d\d)/ ) {
                $name=$1;
        }
        elsif ( $entry =~ /^(CVE-....-XXXX.*)\n/ ){
                $name=$1;
        }
        else {
                die "invlid entry:\n$entry";
        }
        $data->{$name}->{entry}=\$entry;
        if ($name =~ /$issue_regexp/) {
                if (!$opts{U} && $entry =~ /$todo_regexp/m ) {
                        push @todos, $name;
                        $num_todo++;
                }
                elsif ( ($opts{u} || $opts{U})
                    && $entry =~ /^\s+-\s+(\S+)\s+<unfixed>(.*)$/m
                    && ! exists $ignore_missing_bug{$1}
                    && $2 !~ /unimportant/
                    && $entry !~ /-\s+$1\s.*?bug #/m
                    ) {
                        push @todos, $name;
                        $num_missing_bug++;
                }
        }
}

print scalar(@{$CVEs}), " CVEs, ",
      scalar(@{$entries}) - scalar(@{$CVEs}),  " temp issues";
print ", $num_todo todos matching /$todo_regexp/" if $num_todo;
print ", $num_missing_bug entries with missing bug reference" if $num_missing_bug;
print "\n";

if ($opts{l}) {
        #list only
        foreach my $todo (reverse sort @todos) {
                my $desc=description($todo);
                if ($desc) {
                        my $lines=$opts{n} || 2;
                        if ($desc =~ /((?:.*\n){1,$lines})/) {
                                $desc = $1;
                                $desc =~ s/^/               /mg;
                                if ($opts{f}) {
                                        print ${$data->{$todo}->{entry}}, $desc;
                                }
                                else {
                                        print "$todo:\n$desc";
                                }
                        }
                }
                else {
                        print "${$data->{$todo}->{entry}}";
                }
        }
        exit 0;
}


my $term = new Term::ReadLine 'check-new-issues';
if ($term->ReadLine() eq 'Term::ReadLine::Stub') {
        print "Install libterm-readline-gnu-perl to get readline support!\n";
}

TODO: foreach my $todo (reverse sort @todos) {
        print ${$data->{$todo}->{CVE}} if $data->{$todo}->{CVE};
        print ${$data->{$todo}->{entry}};

        auto_search($todo);
        
    READ: while (my $r=$term->readline(">") ) {
                chomp $r;
                if ($r =~ /^\s*$/) {
                        next TODO;
                }
                elsif ($r=~ /^\.c(.*)$/ ) {
                        my $s = $1;
                        $s =~ tr{a-zA-Z0-9_@-}{ }cs;
                        print "=== apt-cache search $s :\n";
                        system("apt-cache search $s|less -FX");
                        print "===\n";
                        next READ;
                }
                elsif ($r=~ /^\.f(.*)$/ ) {
                        my $s = $1;
                        $s =~ s/^\s*(.*?)\s*$/$1/;
                        $s = quotemeta($s);
                        print "=== apt-file search $s:\n";
                        system("apt-file search $s|less -FX");
                        print "===\n";
                        next READ;
                }
                elsif ($r=~ /^\.m(.*)$/ ) {
                        my $s = $1;
                        $s =~ s/^\s+//;
                        $s =~ s/\s+$//;
                        print "references to $s in embedded-code-copies:\n";
                        search_embed($s) or print "none\n";
                        next READ;
                }
                elsif ($r=~ /^q$/i ) {
                        last TODO;
                }
                elsif ($r=~ /^[ve]$/i ) {
                        my $newentry=edit_entry(${$data->{$todo}->{entry}});
                        if ( $newentry eq ${$data->{$todo}->{entry}} ) {
                                print "Not changed.\n";
                                next READ;
                        }
                        else {
                                ${$data->{$todo}->{entry}}=$newentry;
                                print "New entry set to:\n$newentry";
                                next TODO;
                        }
                }
                else {
                        ${$data->{$todo}->{entry}} =~
                                s/^\s*TODO: check/\tNOT-FOR-US: $r/m ;
                                print "New entry set to:\n${$data->{$todo}->{entry}}";
                        next TODO;
                }
        }
}

open(my $fh, ">", $datafile);
print $fh @{$entries};
close($fh);

sub description {
        my $name=shift;

        defined $data->{$name}->{CVE} or return "";
        
        ${$data->{$name}->{CVE}} =~ /\n\n(.*)^Current Votes:/ms;
        my $desc = $1;
        $desc =~ s/\n\n+/\n/;
        
        return $desc;
}

sub read_file
{
        my $file=shift;
        my $re=shift;
        
        
        open(my $fh, $file) or die "could not open $file";
        
        my @data;
        my $cur="";
        while (my $line=<$fh>) {
                if ($line =~ $re and $cur) {
                        push @data, $cur;
                        $cur = "";
                }
                $cur.=$line;
        }
        push @data, $cur if $cur;
        
        close($fh);
        
        
        return \@data;
}


sub edit_entry {
        my $entry=shift;
        my $tmp=new File::Temp();
        my $tmpname=$tmp->filename;
        print $tmp $entry;
        close $tmp;
        system "$editor $tmpname";
        
        local $/; #slurp
        open($tmp, $tmpname);
        return <$tmp>;
        
}

sub auto_search {
        my $name=shift;
        
        my $desc=description($name);
        $desc =~ s/[\s\n]+/ /g;
        
        my $file;
        my $prog;
        if ( $desc =~ /^(\S+(?: [A-Z]\w*)*) \d/ ) {
                $prog = $1;
        }
        elsif ( $desc =~ / in (\S+\.\S+) in (?:the )?(\S+) / ) {
                $file = $1;
                $prog = $2;
        }
        elsif ( $desc =~ / in (?:the )?(\S+) / ) {
                $prog = $1;
        }
        if ($prog) {
                my $prog_esc =$prog;
                $prog_esc =~ tr{a-zA-Z0-9_@/-}{ }cs;
                print "doing apt-cache search...";
                my @ac=`apt-cache search $prog_esc`;
                if (scalar @ac > $auto_display_limit || scalar @ac == 0) {
                        print "\r", scalar @ac, " results from apt-cache search $prog_esc\n";
                }
                else {
                        print "\r=== apt-cache search $prog_esc:\n", @ac, "===\n";
                }

                foreach my $p (split /\s+/, $prog) {
                        search_embed($p);
                }
        }
        if ( $file =~ /^(?:index|default|login|search|admin)\.(?:php3?|asp|cgi|pl)$/i ) {
                return;
        }
        if ( $file =~ /(php3?|asp|cgi|pl)$/ ) {
                if (! exists $afcache{$file}) {
                        my $file_esc = quotemeta($file);
                        print "doing apt-file search...";
                        $afcache{$file}=[`apt-file -i search $file_esc`];
                        if (scalar @{$afcache{$file}} > $auto_display_limit) {
                                # replace with empty array to save mem
                                my $num = scalar @{$afcache{$file}};
                                $afcache{$file} = [];
                                $afcache{$file}->[$num-1] = undef;
                        }
                }
                if (scalar @{$afcache{$file}} > $auto_display_limit ||
                    scalar @{$afcache{$file}} == 0) {
                        print "\r", scalar @{$afcache{$file}},
                              " results from apt-file -i search $file\n";
                }
                else {
                        print "\r=== apt-file -i search $file:\n", @{$afcache{$file}}, "===\n";
                }
        }
}

sub read_embedded_copies {
        my $emb_file = $opts{e} || "$basedir/data/embedded-code-copies";
        open(my $fh, $emb_file);

        # skip comments
        while (<$fh>) {
                last if /^---BEGIN/; 
        }
        
        my ($code, $pkg);
        while (my $line = <$fh>) {
                if ($line =~ /^([-\w]+)/) {
                        $code = lc($1);
                        $pkg  = undef;
                        if (exists $embed_code->{$code}) {
                                syntax_error("Duplicate embedded code $code")
                        }
                }
                elsif ($line =~ /^\s*$/) {
                        $code = undef;
                        $pkg = undef;
                }
                elsif ($line =~ /^\s+(?:\[\w+\]\s+)?-\s+(\w[\w.-]+)/) {
                        $pkg = $1;
                        $line =~ s/^\s+//;
                        if ($embed_code->{$code}->{$pkg}) {
                                $embed_code->{$code}->{$pkg} .= $line;
                        }
                        else {
                                $embed_code->{$code}->{$pkg} = $line;
                                push @{$embed_pkg->{$pkg}}, $code;
                        }
                }
                elsif ($line =~ /^\s+(?:NOTE|TODO)/) {
                        $line =~ s/^\s+//;
                        if ($pkg) {
                                $embed_code->{$code}->{$pkg} .= $line;
                        }
                }
                else {
                        syntax_error("Cannot parse $line");
                }
        }
}

sub syntax_error {
        $embed_errors=1;
        print STDERR "embedded-code-copies:$.: @_\n";
}

sub search_embed {
        my $text = shift;
        my $found = 0;
        $text = lc($text);
        if (exists $embed_code->{$text}) {
                print "$text is embedded by: ",
                      join(" ", sort keys %{$embed_code->{$text}}),
                      "\n";
                $found = 1;
        }
        if (exists $embed_pkg->{$text}) {
                print "$text embeds: ",
                      join(" ", sort @{$embed_pkg->{$text}}),
                      "\n";
                $found = 1;
        }
        return $found;
}
1	stef-guest	4941	#!/usr/bin/perl
2
3			use strict;
4			use File::Temp;
5			use Getopt::Std;
6			#use Smart::Comments;
7	stef-guest	7808	use Term::ReadLine;
8	stef-guest	4941
9			my %opts;
10	sf	12001	getopts('ln:fhi:t:Tca:e:uU', \%opts);
11	stef-guest	4941
12			if ($opts{h}) {
13	stef-guest	7029	print <<'EOF';
14	stef-guest	4941	downloads allitems.txt from cve.mitre.org and shows full decription for each
15			"TODO: check" item (2003 and newer). Then
16
17			- tries to guess product name and php filename and does
18			apt-cache and apt-file search
19			- waits for input:
20			* blank line to skip to next issue
21			* .fname to do "apt-file search name"
22			* .cname to do "apt-cache search name"
23	stef-guest	7925	* .mpackage to search data/embedded-code-copies for "package"
24	stef-guest	4941	* v or e to launch an editor with the current item
25			* q to save and quit
26			* CTRL-C to quit without saving
27			* everything else is inserted as product name for a NOT-FOR-US
28
29			Use "svn diff" and "svn revert" as needed ;-)
30
31			OPTIONS: [ -l [-n <n>] [-f] ]
32	stef-guest	5190	-l : just list issues
33			-n <n> : show max n lines of each description (default 2)
34			-f : show full CVE/list entry as well
35	sf	12001	-i regexp : use regexp to select todos (default: 'CVE-20(?:0[3-9]\|1[0-9])' )
36	stef-guest	5190	-t regexp : use regexp to select todos (default: '^\s+TODO: check$' )
37			-T : same as -t '^\s+TODO: check' (note the missing $)
38	sf	12001	-u : also show unfixed issues without bug reference
39			-U : only show unfixed issues without bug reference instead of TODO items
40	stef-guest	7925	-c : only do syntax check of embedded-code-copies
41	sf	10840	-e <file> : use <file> for embedded-code-copies, "-" for STDIN
42	stef-guest	9877	-a <n> : If automatic apt-cache/apt-file search gives more than n results,
43			display only the count (default 10)
44	stef-guest	4941
45			EOF
46
47			exit(0);
48			}
49
50			# TODO/BUGS:
51			# - go back to previous issue / undo
52			# - handle entries with several TODO lines
53			# - handle claimed-by
54			# - look for ITPs?
55
56	stef-guest	7808
57			my $basedir;
58			if (-e "secure-testing/data/CVE/list") {
59			$basedir="secure-testing";
60			} elsif (-e "data/CVE/list") {
61			$basedir=".";
62			} elsif (-e "../data/CVE/list") {
63			$basedir="..";
64			}
65
66	stef-guest	7925
67			my $embed_code = {};
68			my $embed_pkg = {};
69			my $embed_errors;
70
71			read_embedded_copies();
72
73			if ($opts{c}) {
74			exit($embed_errors);
75			}
76
77
78	stef-guest	7808	my $datafile="$basedir/data/CVE/list";
79			my $allitemsfile="gunzip -c $basedir/../allitems.txt.gz\|";
80	stef-guest	6467	my $allitemsurl="http://cve.mitre.org/data/downloads/allitems.txt.gz";
81	stef-guest	4941
82	sf	12001	my $issue_regexp= $opts{i} \|\| 'CVE-20(?:0[3-9]\|1[0-9])';
83	stef-guest	5190	my $todo_regexp= $opts{t} \|\| ( $opts{T} ? '^\s+TODO: check' : '^\s+TODO: check$' );
84	stef-guest	9877	my $auto_display_limit = 10;
85			$auto_display_limit = $opts{a} if defined $opts{a};
86	stef-guest	5190
87	stef-guest	4941	my $editor=$ENV{EDITOR} \|\| $ENV{VISUAL} \|\| "vi";
88
89	stef-guest	7808	system "cd $basedir/.. ; wget -N $allitemsurl";
90	stef-guest	4941
91
92			print "Reading data...\n";
93
94			my $entries=read_file($datafile, qr/^CVE/ );
95			my $CVEs=read_file($allitemsfile, qr/^=+$/ );
96			my $data;
97			my @todos;
98			my %afcache;
99	sf	12001	my $num_todo;
100			my $num_missing_bug;
101	stef-guest	4941
102			foreach my $cve (@{$CVEs}) {
103			$cve =~ /^Name:\s*(CVE\S+)/m or next;
104			$data->{$1}->{CVE}=\$cve;
105			}
106
107	sf	12001	# packages that should be ignored by -u/-U
108			my @ignore_missing_bug_list = qw/linux-2.6 linux-2.6.24
109			kfreebsd-source kfreebsd-5 kfreebsd-6 kfreebsd-7
110			mozilla mozilla-firefox mozilla-thunderbird firefox
111			php4
112			gnutls11
113			/;
114			my %ignore_missing_bug;
115			$ignore_missing_bug{$_} = 1 for @ignore_missing_bug_list;
116	stef-guest	4941
117			foreach my $entry (@{$entries}) {
118			my $name;
119			if ( $entry =~ /^(CVE-....-\d\d\d\d)/ ) {
120			$name=$1;
121			}
122			elsif ( $entry =~ /^(CVE-....-XXXX.*)\n/ ){
123			$name=$1;
124			}
125			else {
126			die "invlid entry:\n$entry";
127			}
128			$data->{$name}->{entry}=\$entry;
129	sf	12001	if ($name =~ /$issue_regexp/) {
130			if (!$opts{U} && $entry =~ /$todo_regexp/m ) {
131			push @todos, $name;
132			$num_todo++;
133			}
134			elsif ( ($opts{u} \|\| $opts{U})
135			&& $entry =~ /^\s+-\s+(\S+)\s+<unfixed>(.*)$/m
136			&& ! exists $ignore_missing_bug{$1}
137			&& $2 !~ /unimportant/
138	sf	12006	&& $entry !~ /-\s+$1\s.*?bug #/m
139	sf	12001	) {
140			push @todos, $name;
141			$num_missing_bug++;
142			}
143	stef-guest	4941	}
144			}
145
146	stef-guest	7925	print scalar(@{$CVEs}), " CVEs, ",
147	sf	12001	scalar(@{$entries}) - scalar(@{$CVEs}), " temp issues";
148			print ", $num_todo todos matching /$todo_regexp/" if $num_todo;
149			print ", $num_missing_bug entries with missing bug reference" if $num_missing_bug;
150			print "\n";
151	stef-guest	4941
152			if ($opts{l}) {
153			#list only
154			foreach my $todo (reverse sort @todos) {
155			my $desc=description($todo);
156			if ($desc) {
157			my $lines=$opts{n} \|\| 2;
158			if ($desc =~ /((?:.*\n){1,$lines})/) {
159			$desc = $1;
160			$desc =~ s/^/ /mg;
161			if ($opts{f}) {
162			print ${$data->{$todo}->{entry}}, $desc;
163			}
164			else {
165			print "$todo:\n$desc";
166			}
167			}
168			}
169			else {
170			print "${$data->{$todo}->{entry}}";
171			}
172			}
173			exit 0;
174			}
175
176	stef-guest	7808
177			my $term = new Term::ReadLine 'check-new-issues';
178			if ($term->ReadLine() eq 'Term::ReadLine::Stub') {
179			print "Install libterm-readline-gnu-perl to get readline support!\n";
180			}
181
182	stef-guest	4941	TODO: foreach my $todo (reverse sort @todos) {
183			print ${$data->{$todo}->{CVE}} if $data->{$todo}->{CVE};
184			print ${$data->{$todo}->{entry}};
185
186			auto_search($todo);
187
188	stef-guest	7808	READ: while (my $r=$term->readline(">") ) {
189	stef-guest	4941	chomp $r;
190			if ($r =~ /^\s*$/) {
191			next TODO;
192			}
193			elsif ($r=~ /^\.c(.*)$/ ) {
194			my $s = $1;
195			$s =~ tr{a-zA-Z0-9_@-}{ }cs;
196			print "=== apt-cache search $s :\n";
197			system("apt-cache search $s\|less -FX");
198			print "===\n";
199			next READ;
200			}
201			elsif ($r=~ /^\.f(.*)$/ ) {
202			my $s = $1;
203			$s =~ s/^\s(.?)\s*$/$1/;
204	stef-guest	8465	$s = quotemeta($s);
205	stef-guest	9874	print "=== apt-file search $s:\n";
206	stef-guest	8465	system("apt-file search $s\|less -FX");
207	stef-guest	4941	print "===\n";
208			next READ;
209			}
210	stef-guest	7925	elsif ($r=~ /^\.m(.*)$/ ) {
211			my $s = $1;
212			$s =~ s/^\s+//;
213			$s =~ s/\s+$//;
214			print "references to $s in embedded-code-copies:\n";
215			search_embed($s) or print "none\n";
216			next READ;
217			}
218	stef-guest	4941	elsif ($r=~ /^q$/i ) {
219			last TODO;
220			}
221			elsif ($r=~ /^[ve]$/i ) {
222			my $newentry=edit_entry(${$data->{$todo}->{entry}});
223			if ( $newentry eq ${$data->{$todo}->{entry}} ) {
224			print "Not changed.\n";
225			next READ;
226			}
227			else {
228			${$data->{$todo}->{entry}}=$newentry;
229			print "New entry set to:\n$newentry";
230			next TODO;
231			}
232			}
233			else {
234			${$data->{$todo}->{entry}} =~
235			s/^\s*TODO: check/\tNOT-FOR-US: $r/m ;
236			print "New entry set to:\n${$data->{$todo}->{entry}}";
237			next TODO;
238			}
239			}
240			}
241
242			open(my $fh, ">", $datafile);
243			print $fh @{$entries};
244			close($fh);
245
246			sub description {
247			my $name=shift;
248
249			defined $data->{$name}->{CVE} or return "";
250
251			${$data->{$name}->{CVE}} =~ /\n\n(.*)^Current Votes:/ms;
252			my $desc = $1;
253			$desc =~ s/\n\n+/\n/;
254
255			return $desc;
256			}
257
258			sub read_file
259			{
260			my $file=shift;
261			my $re=shift;
262
263
264			open(my $fh, $file) or die "could not open $file";
265
266			my @data;
267			my $cur="";
268			while (my $line=<$fh>) {
269			if ($line =~ $re and $cur) {
270			push @data, $cur;
271			$cur = "";
272			}
273			$cur.=$line;
274			}
275			push @data, $cur if $cur;
276
277			close($fh);
278
279
280			return \@data;
281			}
282
283
284			sub edit_entry {
285			my $entry=shift;
286			my $tmp=new File::Temp();
287			my $tmpname=$tmp->filename;
288			print $tmp $entry;
289			close $tmp;
290			system "$editor $tmpname";
291
292			local $/; #slurp
293			open($tmp, $tmpname);
294			return <$tmp>;
295
296			}
297
298			sub auto_search {
299			my $name=shift;
300
301			my $desc=description($name);
302			$desc =~ s/[\s\n]+/ /g;
303
304			my $file;
305			my $prog;
306	stef-guest	7925	if ( $desc =~ /^(\S+(?: [A-Z]\w)) \d/ ) {
307			$prog = $1;
308			}
309			elsif ( $desc =~ / in (\S+\.\S+) in (?:the )?(\S+) / ) {
310	stef-guest	4941	$file = $1;
311			$prog = $2;
312			}
313			elsif ( $desc =~ / in (?:the )?(\S+) / ) {
314			$prog = $1;
315			}
316			if ($prog) {
317	sf	10838	my $prog_esc =$prog;
318			$prog_esc =~ tr{a-zA-Z0-9_@/-}{ }cs;
319	stef-guest	4941	print "doing apt-cache search...";
320	stef-guest	9877	my @ac=`apt-cache search $prog_esc`;
321			if (scalar @ac > $auto_display_limit \|\| scalar @ac == 0) {
322			print "\r", scalar @ac, " results from apt-cache search $prog_esc\n";
323			}
324			else {
325			print "\r=== apt-cache search $prog_esc:\n", @ac, "===\n";
326			}
327	stef-guest	7925
328			foreach my $p (split /\s+/, $prog) {
329			search_embed($p);
330			}
331	stef-guest	4941	}
332	stef-guest	7925	if ( $file =~ /^(?:index\|default\|login\|search\|admin)\.(?:php3?\|asp\|cgi\|pl)$/i ) {
333	stef-guest	4941	return;
334			}
335	stef-guest	7925	if ( $file =~ /(php3?\|asp\|cgi\|pl)$/ ) {
336	stef-guest	4941	if (! exists $afcache{$file}) {
337	stef-guest	8466	my $file_esc = quotemeta($file);
338	stef-guest	4941	print "doing apt-file search...";
339	stef-guest	9877	$afcache{$file}=[`apt-file -i search $file_esc`];
340			if (scalar @{$afcache{$file}} > $auto_display_limit) {
341			# replace with empty array to save mem
342			my $num = scalar @{$afcache{$file}};
343			$afcache{$file} = [];
344			$afcache{$file}->[$num-1] = undef;
345			}
346	stef-guest	4941	}
347	stef-guest	9877	if (scalar @{$afcache{$file}} > $auto_display_limit \|\|
348			scalar @{$afcache{$file}} == 0) {
349			print "\r", scalar @{$afcache{$file}},
350			" results from apt-file -i search $file\n";
351			}
352			else {
353			print "\r=== apt-file -i search $file:\n", @{$afcache{$file}}, "===\n";
354			}
355	stef-guest	4941	}
356			}
357	stef-guest	7925
358			sub read_embedded_copies {
359	sf	10840	my $emb_file = $opts{e} \|\| "$basedir/data/embedded-code-copies";
360			open(my $fh, $emb_file);
361	stef-guest	7925
362			# skip comments
363			while (<$fh>) {
364			last if /^---BEGIN/;
365			}
366
367			my ($code, $pkg);
368			while (my $line = <$fh>) {
369			if ($line =~ /^([-\w]+)/) {
370			$code = lc($1);
371			$pkg = undef;
372			if (exists $embed_code->{$code}) {
373			syntax_error("Duplicate embedded code $code")
374			}
375			}
376			elsif ($line =~ /^\s*$/) {
377			$code = undef;
378			$pkg = undef;
379			}
380			elsif ($line =~ /^\s+(?:\[\w+\]\s+)?-\s+(\w[\w.-]+)/) {
381			$pkg = $1;
382			$line =~ s/^\s+//;
383			if ($embed_code->{$code}->{$pkg}) {
384			$embed_code->{$code}->{$pkg} .= $line;
385			}
386			else {
387			$embed_code->{$code}->{$pkg} = $line;
388			push @{$embed_pkg->{$pkg}}, $code;
389			}
390			}
391			elsif ($line =~ /^\s+(?:NOTE\|TODO)/) {
392			$line =~ s/^\s+//;
393			if ($pkg) {
394			$embed_code->{$code}->{$pkg} .= $line;
395			}
396			}
397			else {
398			syntax_error("Cannot parse $line");
399			}
400			}
401			}
402
403			sub syntax_error {
404			$embed_errors=1;
405			print STDERR "embedded-code-copies:$.: @_\n";
406			}
407
408			sub search_embed {
409			my $text = shift;
410			my $found = 0;
411			$text = lc($text);
412			if (exists $embed_code->{$text}) {
413			print "$text is embedded by: ",
414			join(" ", sort keys %{$embed_code->{$text}}),
415			"\n";
416			$found = 1;
417			}
418			if (exists $embed_pkg->{$text}) {
419			print "$text embeds: ",
420			join(" ", sort @{$embed_pkg->{$text}}),
421			"\n";
422			$found = 1;
423			}
424			return $found;
425			}