chiark / gitweb /
debugging for thing that crashed
[innduct.git] / frontends / scanspool.in
1 #! /usr/bin/perl
2 # fixscript will replace this line with require innshellvars.pl
3
4 # @(#)scanspool.pl      1.20 4/6/92 00:47:35
5 #
6 # Written by:  Landon Curt Noll         (chongo was here  /\../\)
7 #
8 # This code is placed in the public domain.
9 #
10 # scanspool - perform a big scan over all articles in /usr/spool/news
11 #
12 # usage:
13 #    scanspool [-a active_file] [-s spool_dir] [-v] [-c] [-n]
14 #
15 #    -a active_file     active file to use (default /usr/lib/news/active)
16 #    -s spool_dir       spool tree (default /usr/spool/news)
17 #    -v                 verbose mode
18 #                       verbose messages begin with a tab
19 #                       show articles found in non-active directories
20 #    -c                 check article filenames, don't scan the articles
21 #    -n                 don't throttle innd
22 #
23 # NOTE: This take a while, -v is a good thing if you want to know
24 #       how far this program has progressed.
25 #
26 # This program will scan first the active file, noting problems such as:
27 #
28 #       malformed line
29 #       group aliased to a non-existent group
30 #       group aliased to a group tat is also aliased
31 #
32 # Then it will examine all articles under your news spool directory,
33 # looking for articles that:
34 #
35 #       basename that starts with a leading 0
36 #       basename that is out of range with the active file
37 #       does not contain a Newsgroups: line
38 #       article that is all header and no text
39 #       is in a directory for which there is no active group
40 #       article that is in a group to which it does not belong
41 #
42 # Scanspool understands aliased groups.  Thus, if an article is posted
43 # to foo.old.name that is aliases to foo.bar, it will be expected to
44 # be found under foo.bar and not foo.old.name.
45 #
46 # Any group that is of type 'j' or 'x' (4th field of the active file)
47 # will be allowed to show up under the junk group.
48 #
49 # Scanspool assumes that the path of a valid newsgroup's directory
50 # from the top of the spool tree will not contain any "." character.
51 # Thus, directories such as out.going, tmp.dir, in.coming and
52 # news.archive will not be searched.  This program also assumes that
53 # article basenames contain only decimal digits.  Last, files under
54 # the top level directory "lost+found" are not scanned.
55 #
56 # The output of scanspool will start with one of 4 forms:
57 #
58 #    FATAL:         fatal or internal error                     (to stderr)
59 #
60 #    WARN:          active or article format problem,           (to stderr)
61 #                   group alias problem, find error,
62 #                   article open error
63 #
64 #    path/123:      basename starts with 0,                     (to stdout)
65 #                   article number out of range,
66 #                   article in the wrong directory,
67 #                   article in directory not related to
68 #                       an active non-aliases newsgroup
69 #
70 #    \t ...         verbose message starting with a tab         (to stdout)
71
72
73 # Data structures
74 #
75 # $gname2type{$name}
76 #    $name      - newsgroup name in foo.dot.form
77 #    produces  => 4th active field  (y, n, x, ...)
78 #                 alias type is "=", not "=foo.bar"
79 #
80 # $realgname{$name}
81 #    $name      - newsgroup name in foo.dot.form
82 #    produces  => newsgroup name in foo.dot.form
83 #                 if type is =, this will be a.b, not $name
84 #
85 # $lowart{$name}
86 #    $name      - newsgroup name in foo.dot.form
87 #    produces  => lowest article allowed in the group
88 #                 if type is =, this is not valid
89 #
90 # $highart{$name}
91 #    $name      - newsgroup name in foo.dot.form
92 #    produces  => highest article allowed in the group
93 #                 if type is =, this is not valid
94 #                 If $highart{$name} < $lowart{$name},
95 #                 then the group should be empty
96
97 # perl requirements
98 #
99 require "getopts.pl";
100
101 # setup non-buffered stdout and stderr
102 #
103 select(STDERR);
104 $|=1;
105 select(STDOUT);
106 $|=1;
107
108 # global constants
109 #
110 $prog = $0;                             # our name
111 $spool = "$inn::patharticles";
112 $active = "$inn::pathdb/active";
113 $ctlinnd = "$inn::pathbin/ctlinnd";
114 $reason = "running scanspool";          # throttle reason
115
116 # parse args
117 #
118 &Getopts("a:s:vcn");
119 $active = $opt_a if (defined($opt_a));
120 $spool = $opt_s if (defined($opt_s));
121
122 # throttle innd unless -n
123 #
124 if (! defined($opt_n)) {
125     system("$ctlinnd throttle '$reason' >/dev/null 2>&1");
126 }
127
128 # process the active file
129 #
130 &parse_active($active);
131
132 # check the spool directory
133 #
134 &check_spool($spool);
135
136 # unthrottle innd unless -n
137 #
138 if (! defined($opt_n)) {
139     system("$ctlinnd go '$reason' >/dev/null 2>&1");
140 }
141
142 # all done
143 exit(0);
144
145
146 # parse_active - parse the active file
147 #
148 # From the active file, fill out the @gname2type (type of newsgroup)
149 # and @realgname (real/non-aliased name of group), @lowart & @highart
150 # (low and high article numbers).  This routine will also check for
151 # aliases to missing groups or groups that are also aliases.
152 #
153 sub parse_active
154 {
155     local ($active) = $_[0];    # the name of the active file to use
156     local (*ACTIVE);            # active file handle
157     local ($line);              # active file line
158     local ($name);              # name of newsgroup
159     local ($low);               # low article number
160     local ($high);              # high article number
161     local ($type);              # type of newsgroup (4th active field)
162     local ($field5);            # 5th active field (should not exist)
163     local ($dir);               # directory path of group from $spool
164     local ($alias);             # realname of an aliased group
165     local ($linenum);           # active file line number
166
167     # if verbose (-v), say what we are doing
168     print "\tscanning $active\n" if defined($opt_v);
169
170     # open the active file
171     open (ACTIVE, $active) || &fatal(1, "cannot open $active");
172
173     # parse each line
174     $linenum = 0;
175     while ($line = <ACTIVE>) {
176
177         # count the line
178         ++$linenum;
179
180         # verify that we have a correct number of tokens
181         if ($line !~ /^\S+ 0*(\d+) 0*(\d+) \S+$/o) {
182             &problem("WARNING: active line is mal-formed at line $linenum");
183             next;
184         }
185         ($name, $high, $low, $type) = $line =~ /^(\S+) 0*(\d+) 0*(\d+) (\S+)$/o;
186
187         # watch for duplicate entries
188         if (defined($realgname{$name})) {
189             &problem("WARNING: ignoring dup group: $name, at line $linenum");
190             next;
191         }
192
193         # record which type it is
194         $gname2type{$name} = $type;
195
196         # record the low and high article numbers
197         $lowart{$name} = $low;
198         $highart{$name} = $high;
199
200         # determine the directory and real group name
201         if ($type eq "j" || $type eq "x") {
202             $dir = "junk";
203             $alias = $name;
204         } elsif ($type =~ /^=(.+)/o) {
205             $alias = $1;
206             ($dir = $alias) =~ s#\.#/#go;
207             $gname2type{$name} = "=";   # rename type to be just =
208         } else {
209             $dir = $name;
210             $dir =~ s#\.#/#go;
211             $alias = $name;
212         }
213         $realgname{$name} = $alias;
214     }
215
216     # close the active file
217     close (ACTIVE);
218
219     # be sure that any alias type is aliased to a real group
220     foreach $name (keys %realgname) {
221
222         # skip if not an alias type
223         next if $gname2type{$name} ne "=";
224
225         # be sure that the alias exists
226         $alias = $realgname{$name};
227         if (! defined($realgname{$alias})) {
228             &problem("WARNING: alias for $name: $alias, is not a group");
229             next;
230         }
231
232         # be sure that the alias is not an alias of something else
233         if ($gname2type{$alias} eq "=") {
234             &problem("WARNING: alias for $name: $alias, is also an alias");
235             next;
236         }
237     }
238 }
239
240
241 # problem - report a problem to stdout
242 #
243 # Print a message to stdout.  Parameters are space separated.
244 # A final newline is appended to it.
245 #
246 # usage:
247 #       &problem(arg, arg2, ...)
248 #
249 sub problem
250 {
251     local ($line);              # the line to write
252
253     # print the line with the header and newline
254     $line = join(" ", @_);
255     print STDERR $line, "\n";
256 }
257
258
259 # fatal - report a fatal error to stderr and exit
260 #
261 # Print a message to stderr.  The message has the program name prepended
262 # to it.  Parameters are space separated.  A final newline is appended
263 # to it.  This function exists with the code of exitval.
264 #
265 # usage:
266 #       &fatal(exitval, arg, arg2, ...)
267 #
268 sub fatal
269 {
270     local ($exitval) = $_[0];   # what to exit with
271
272     # firewall
273     if ($#_ < 1) {
274         print STDERR "FATAL: fatal called with only ", $#_-1, " arguments\n";
275         if ($#_ < 0) {
276             $exitval = -1;
277         }
278     }
279
280     # print the error message
281     shift(@_);
282     $line = join(" ", @_);
283     print STDERR "$prog: ", $line, "\n";
284
285     # unthrottle innd unless -n
286     #
287     if (! defined($opt_n)) {
288         system("$ctlinnd go '$reason' >/dev/null 2>&1");
289     }
290
291     # exit
292     exit($exitval);
293 }
294
295
296 # check_spool - check the articles found in the spool directory
297 #
298 # This subroutine will check all articles found under the $spool directory.
299 # It will examine only file path that do not contain any "." or whitespace
300 # character, and whose basename is completely numeric.  Files under
301 # lost+found will also be ignored.
302 #
303 # given:
304 #       $spooldir  - top of /usr/spool/news article tree
305 #
306 sub check_spool
307 {
308     local ($spooldir) = $_[0];  # top of article tree
309     local (*FILEFILE);          # pipe from the find files process
310     local ($filename);          # article pathname under $spool
311     local ($artgrp);            # group of an article
312     local ($artnum);            # article number in a group
313     local ($prevgrp);           # previous different value of $artgrp
314     local ($preverrgrp);        # previous non-active $artgrp
315     local (*ARTICLE);           # article handle
316     local ($aline);             # header line from an article
317     local (@group);             # array of groups from the Newsgroup header
318     local ($j);
319
320     # if verbose, say what we are doing
321     print "\tfinding articles under $spooldir\n" if defined($opt_v);
322
323     # move to the $spool directory
324     chdir $spooldir || &fatal(2, "cannot chdir to $spool");
325
326     # start finding files
327     #
328     if (!open (FINDFILE,
329           "find . \\( -type f -o -type l \\) -name '[0-9]*' -print 2>&1 |")) {
330         &fatal(3, "cannot start find in $spool");
331     }
332
333     # process each history line
334     #
335     while ($filename = <FINDFILE>) {
336
337         # if the line contains find:, assume it is a find error and print it
338         chop($filename);
339         if ($filename =~ /find:\s/o) {
340             &problem("WARNING:", $filename);
341             next;
342         }
343
344         # remove the \n and ./ that find put in our path
345         $filename =~ s#^\./##o;
346
347         # skip is this path has a . in it (beyond a leading ./)
348         next if ($filename =~ /\./o);
349
350         # skip if lost+found
351         next if ($filename =~ m:^lost+found/:o);
352
353         # skip if not a numeric basename
354         next if ($filename !~ m:/\d+$:o);
355
356         # get the article's newsgroup name (based on its path from $spool)
357         $artgrp = $filename;
358         $artgrp =~ s#/\d+$##o;
359         $artgrp =~ s#/#.#go;
360
361         # if verbose (-v), then note if our group changed
362         if (defined($opt_v) && $artgrp ne $prevgrp) {
363             print "\t$artgrp\n";
364             $prevgrp = $artgrp;
365         }
366
367         # note if the article is not in a directory that is used by
368         # a real (non-aliased) group in the active file
369         #
370         # If we complained about this dgroup before, don't complain again.
371         # If verbose, note files that could be removed.
372         #
373         if (!defined($gname2type{$artgrp}) || $gname2type{$artgrp} =~ /[=jx]/o){
374             if ($preverrgrp ne $artgrp) {
375                 &problem("$artgrp: not an active group directory");
376                 $preverrgrp = $artgrp;
377             }
378             if (defined($opt_v)) {
379                 &problem("$filename: article found in non-active directory");
380             }
381             next;
382         }
383
384         # check on the article number
385         $artnum = $filename;
386         $artnum =~ s#^.+/##o;
387         if ($artnum =~ m/^0/o) {
388             &problem("$filename: article basename starts with a 0");
389         }
390         if (defined($gname2type{$artgrp})) {
391             if ($lowart{$artgrp} > $highart{$artgrp}) {
392                 &problem("$filename: active indicates group should be empty");
393             } elsif ($artnum < $lowart{$artgrp}) {
394                 &problem("$filename: article number is too low");
395             } elsif ($artnum > $highart{$artgrp}) {
396                 &problem("$filename: article number is too high");
397             }
398         }
399
400         # if check filenames only (-c), then do nothing else with the file
401         next if (defined($opt_c));
402
403         # don't open a control or junk, they can be from anywhere
404         next if ($artgrp eq "control" || $artgrp eq "junk");
405
406         # try open the file
407         if (!open(ARTICLE, $filename)) {
408
409             # the find is now gone (expired?), give up on it
410             &problem("WARNING: cannot open $filename");
411             next;
412         }
413
414         # read until the Newsgroup header line is found
415         AREADLINE:
416         while ($aline = <ARTICLE>) {
417
418             # catch the newsgroup: header
419             if ($aline =~ /^Newsgroups:\w*\W/io) {
420
421                 # convert $aline into a comma separated list of groups
422                 $aline =~ s/^Newsgroups://io;
423                 $aline =~ tr/ \t\n//d;
424
425                 # form an array of news groups
426                 @group = split(",", $aline);
427
428                 # see if any groups in the Newsgroup list are our group
429                 for ($j=0; $j <= $#group; ++$j) {
430
431                     # look at the group
432                     if ($realgname{$group[$j]} eq $artgrp) {
433                         # this article was posted to this group
434                         last AREADLINE;
435                     }
436                 }
437
438                 # no group or group alias was found
439                 &problem("$filename: does not belong in $artgrp");
440                 last;
441
442             # else watch for the end of the header
443             } elsif ($aline =~ /^\s*$/o) {
444
445                 # no Newsgroup: header found
446                 &problem("WARNING: $filename: no Newsgroup header");
447                 last;
448             }
449             if (eof(ARTICLE)) {
450                 &problem("WARNING: $filename: EOF found while reading header");
451             }
452         }
453
454         # close the article
455         close(ARTICLE);
456     }
457
458     # all done with the find
459     close(FINDFILE);
460 }