src/src/eximstats.src

   1 #!PERL_COMMAND -w
   2 # $Cambridge: exim/src/src/eximstats.src,v 1.19 2009/10/19 12:26:34 nm4 Exp $
   3
   4 # Copyright (c) 2001 University of Cambridge.
   5 # See the file NOTICE for conditions of use and distribution.
   6
   7 # Perl script to generate statistics from one or more Exim log files.
   8
   9 # Usage: eximstats [<options>] <log file> <log file> ...
  10
  11 # 1996-05-21: Ignore lines not starting with valid date/time, just in case
  12 #               these get into a log file.
  13 # 1996-11-19: Add the -h option to control the size of the histogram,
  14 #               and optionally turn it off.
  15 #             Use some Perl 5 things; it should be everywhere by now.
  16 #             Add the Perl -w option and rewrite so no warnings are given.
  17 #             Add the -t option to control the length of the "top" listing.
  18 #             Add the -ne, -nt options to turn off errors and transport
  19 #               information.
  20 #             Add information about length of time on queue, and -q<list> to
  21 #               control the intervals and turn it off.
  22 #             Add count and percentage of delayed messages to the Received
  23 #               line.
  24 #             Show total number of errors.
  25 #             Add count and percentage of messages with errors to Received
  26 #               line.
  27 #             Add information about relaying and -nr to suppress it.
  28 # 1997-02-03  Merged in some of the things Nigel Metheringham had done:
  29 #               Re-worded headings
  30 #               Added received histogram as well as delivered
  31 #               Added local senders' league table
  32 #               Added local recipients' league table
  33 # 1997-03-10  Fixed typo "destinationss"
  34 #             Allow for intermediate address between final and original
  35 #               when testing for relaying
  36 #             Give better message when no input
  37 # 1997-04-24  Fixed bug in layout of error listing that was depending on
  38 #               text length (output line got repeated).
  39 # 1997-05-06  Bug in option decoding when only one option.
  40 #             Overflow bug when handling very large volumes.
  41 # 1997-10-28  Updated to handle revised log format that might show
  42 #               HELO name as well as host name before IP number
  43 # 1998-01-26  Bugs in the function for calculating the number of seconds
  44 #               since 1970 from a log date
  45 # 1998-02-02  Delivery to :blackhole: doesn't have a T= entry in the log
  46 #               line; cope with this, thereby avoiding undefined problems
  47 #             Very short log line gave substring error
  48 # 1998-02-03  A routed delivery to a local transport may not have <> in the
  49 #               log line; terminate the address at white space, not <
  50 # 1998-09-07  If first line of input was a => line, $thissize was undefined;
  51 #               ensure it is zero.
  52 # 1998-12-21  Adding of $thissize from => line should have been adding $size.
  53 #             Oops. Should have looked more closely when fixing the previous
  54 #               bug!
  55 # 1999-11-12  Increased the field widths for printed integers; numbers are
  56 #               bigger than originally envisaged.
  57 # 2001-03-21  Converted seconds() routine to use Time::Local, fixing a bug
  58 #               whereby seconds($timestamp) - id_seconds($id) gave an
  59 #               incorrect result.
  60 #             Added POD documentation.
  61 #             Moved usage instructions into help() subroutine.
  62 #             Added 'use strict' and declared all global variables.
  63 #             Added '-html' flag and resultant code.
  64 #             Added '-cache' flag and resultant code.
  65 #             Added add_volume() routine and converted all volume variables
  66 #               to use it, fixing the overflow problems for individual hosts
  67 #               on large sites.
  68 #             Converted all volume output to GB/MB/KB as appropriate.
  69 #             Don't store local user stats if -nfl is specified.
  70 #             Modifications done by: Steve Campbell (<steve@computurn.com>)
  71 # 2001-04-02  Added the -t_remote_users flag. Steve Campbell.
  72 # 2001-10-15  Added the -domain flag. Steve Campbell.
  73 # 2001-10-16  Accept files on STDIN or on the command line. Steve Campbell.
  74 # 2001-10-21  Removed -domain flag and added -bydomain, -byhost, and -byemail.
  75 #             We now generate our main parsing subroutine as an eval statement
  76 #             which improves performance dramatically when not all the results
  77 #             are required. We also cache the last timestamp to time convertion.
  78 #
  79 #             NOTE: 'Top 50 destinations by (message count|volume)' lines are
  80 #             now 'Top N (host|email|domain) destinations by (message count|volume)'
  81 #             where N is the topcount. Steve Campbell.
  82 #
  83 # 2001-10-30  V1.16 Joachim Wieland.
  84 #            Fixed minor bugs in add_volume() when taking over this version
  85 #               for use in Exim 4: -w gave uninitialized value warnings in
  86 #               two situations: for the first addition to a counter, and if
  87 #               there were never any gigabytes, thereby leaving the $gigs
  88 #               value unset.
  89 #             Initialized $last_timestamp to stop a -w uninitialized warning.
  90 #             Minor layout tweak for grand totals (nitpicking).
  91 #             Put the IP addresses for relaying stats in [] and separated by
  92 #               a space from the domain name.
  93 #             Removed the IPv4-specific address test when picking out addresses
  94 #               for relaying. Anything inside [] is OK.
  95 #
  96 # 2002-07-02  Philip Hazel
  97 #             Fixed "uninitialized variable" message that occurred for relay
  98 #               messages that arrived from H=[1.2.3.4] hosts (no name shown).
  99 #               This bug didn't affect the output.
 100 #
 101 # 2002-04-15  V1.17 Joachim Wieland.
 102 #             Added -charts, -chartdir. -chartrel options which use
 103 #             GD::Graph modules to create graphical charts of the statistics.
 104 #
 105 # 2002-04-15  V1.18 Steve Campbell.
 106 #             Added a check for $domain to to stop a -w uninitialized warning.
 107 #             Added -byemaildomain option.
 108 #             Only print HTML header links to included tables!
 109 #
 110 # 2002-08-02  V1.19 Steve Campbell.
 111 #             Changed the debug mode to dump the parser onto STDERR rather
 112 #             than STDOUT. Documented the -d flag into the help().
 113 #             Rejoined the divergent 2002-04-15 and 2002-07-02 releases.
 114 #
 115 # 2002-08-21  V1.20 Steve Campbell.
 116 #             Added the '-merge' option to allow merging of previous reports.
 117 #             Fixed a missing semicolon when doing -bydomain.
 118 #             Make volume charts plot the data gigs and bytes rather than just bytes.
 119 #             Only process log lines with $flag =~ /<=|=>|->|==|\*\*|Co/
 120 #             Converted Emaildomain to Edomain - the column header was too wide!
 121 #             This changes the text output slightly. You can revert to the old
 122 #             column widths by changing $COLUMN_WIDTHS to 7;
 123 #
 124 # 2002-09-04  V1.21 Andreas J Mueller
 125 #             Local deliveries domain now defaults to 'localdomain'.
 126 #             Don't match F=<From> when looking for the user.
 127 #
 128 # 2002-09-05  V1.22 Steve Campbell
 129 #             Fixed a perl 5.005 incompatibility problem ('our' variables).
 130 #
 131 # 2002-09-11  V1.23 Steve Campbell
 132 #             Stopped -charts option from throwing errors on null data.
 133 #             Don't print out 'Errors encountered' unless there are any.
 134
 135 # 2002-10-21  V1.23a Philip Hazel - patch from Tony Finch put in until
 136 #               Steve's eximstats catches up.
 137 #             Handle log files that include the timezone after the timestamp.
 138 #             Switch to assuming that log timestamps are in local time, with
 139 #               an option for UTC timestamps, as in Exim itself.
 140 #
 141 # 2003-02-05  V1.24 Steve Campbell
 142 #             Added in Sergey Sholokh's code to convert '<' and '>' characters
 143 #             in HTML output. Also added code to convert them back with -merge.
 144 #             Fixed timestamp offsets to convert to seconds rather than minutes.
 145 #             Updated -merge to work with output files using timezones.
 146 #             Added cacheing to speed up the calculation of timezone offsets.
 147 #
 148 # 2003-02-07  V1.25 Steve Campbell
 149 #             Optimised the usage of mktime() in the seconds subroutine.
 150 #             Removed the now redundant '-cache' option.
 151 #             html2txt() now explicitly matches HTML tags.
 152 #             Implemented a new sorting algorithm - the top_n_sort() routine.
 153 #             Added Danny Carroll's '-nvr' flag and code.
 154 #
 155 # 2003-03-13  V1.26 Steve Campbell
 156 #             Implemented HTML compliance changes recommended by Bernard Massot.
 157 #             Bug fix to allow top_n_sort() to handle null keys.
 158 #             Convert all domains and edomains to lowercase.
 159 #             Remove preceding dots from domains.
 160 #
 161 # 2003-03-13  V1.27 Steve Campbell
 162 #             Replaced border attributes with 'border=1', as recommended by
 163 #             Bernard Massot.
 164 #
 165 # 2003-06-03  V1.28 John Newman
 166 #             Added in the ability to skip over the parsing and evaulation of
 167 #             specific transports as passed to eximstats via the new "-nt/.../"
 168 #             command line argument.  This new switch allows the viewing of
 169 #             not more accurate statistics but more applicable statistics when
 170 #             special transports are in use (ie; SpamAssassin).  We need to be
 171 #             able to ignore transports such as this otherwise the resulting
 172 #             local deliveries are significantly skewed (doubled)...
 173 #
 174 # 2003-11-06  V1.29 Steve Campbell
 175 #             Added the '-pattern "Description" "/pattern/"' option.
 176 #
 177 # 2004-02-17  V1.30 Steve Campbell
 178 #             Added warnings if required GD::Graph modules are not available or
 179 #             insufficient -chart* options are specified.
 180 #
 181 # 2004-02-20  V1.31 Andrea Balzi
 182 #             Only show the Local Sender/Destination links if the tables exist.
 183 #
 184 # 2004-07-05  V1.32 Steve Campbell
 185 #             Fix '-merge -h0' divide by zero error.
 186 #
 187 # 2004-07-15  V1.33 Steve Campbell
 188 #             Documentation update - I've converted the subroutine
 189 #             documentation from POD to comments.
 190 #
 191 # 2004-12-10  V1.34 Steve Campbell
 192 #             Eximstats can now parse syslog lines as well as mainlog lines.
 193 #
 194 # 2004-12-20  V1.35 Wouter Verhelst
 195 #             Pie charts by volume were actually generated by count. Fixed.
 196 #
 197 # 2005-02-07  V1.36 Gregor Herrmann / Steve Campbell
 198 #             Added average sizes to HTML Top tables.
 199 #
 200 # 2005-04-26  V1.37 Frank Heydlauf
 201 #             Added -xls and the ability to specify output files.
 202 #
 203 # 2005-04-29  V1.38 Steve Campbell
 204 #             Use FileHandles for outputing results.
 205 #             Allow any combination of xls, txt, and html output.
 206 #             Fixed display of large numbers with -nvr option
 207 #             Fixed merging of reports with empty tables.
 208 #
 209 # 2005-05-27  V1.39 Steve Campbell
 210 #             Added the -include_original_destination flag
 211 #             Removed tabs and trailing whitespace.
 212 #
 213 # 2005-06-03  V1.40 Steve Campbell
 214 #             Whilst parsing the mainlog(s), store information about
 215 #             the messages in a hash of arrays rather than using
 216 #             individual hashes. This is a bit cleaner and results in
 217 #             dramatic memory savings, albeit at a slight CPU cost.
 218 #
 219 # 2005-06-15  V1.41 Steve Campbell
 220 #             Added the -show_rt<list> flag.
 221 #             Added the -show_dt<list> flag.
 222 #
 223 # 2005-06-24  V1.42 Steve Campbell
 224 #             Added Histograms for user specified patterns.
 225 #
 226 # 2005-06-30  V1.43 Steve Campbell
 227 #             Bug fix for V1.42 with -h0 specified. Spotted by Chris Lear.
 228 #
 229 # 2005-07-26  V1.44 Steve Campbell
 230 #             Use a glob alias rather than an array ref in the generated
 231 #             parser. This improves both readability and performance.
 232 #
 233 # 2005-09-30  V1.45 Marco Gaiarin / Steve Campbell
 234 #             Collect SpamAssassin and rejection statistics.
 235 #             Don't display local sender or destination tables unless
 236 #             there is data to show.
 237 #             Added average volumes into the top table text output.
 238 #
 239 # 2006-02-07  V1.46 Steve Campbell
 240 #             Collect data on the number of addresses (recipients)
 241 #             as well as the number of messages.
 242 #
 243 # 2006-05-05  V1.47 Steve Campbell
 244 #             Added 'Message too big' to the list of mail rejection
 245 #             reasons (thanks to Marco Gaiarin).
 246 #
 247 # 2006-06-05  V1.48 Steve Campbell
 248 #             Mainlog lines which have GMT offsets and are too short to
 249 #             have a flag are now skipped.
 250 #
 251 # 2006-11-10  V1.49 Alain Williams
 252 #             Added the -emptyok flag.
 253 #
 254 # 2006-11-16  V1.50 Steve Campbell
 255 #             Fixes for obtaining the IP address from reject messages.
 256 #
 257 # 2006-11-27  V1.51 Steve Campbell
 258 #             Another update for obtaining the IP address from reject messages.
 259 #
 260 # 2006-11-27  V1.52 Steve Campbell
 261 #             Tally any reject message containing SpamAssassin.
 262 #
 263 # 2007-01-31  V1.53 Philip Hazel
 264 #             Allow for [pid] after date in log lines
 265 #
 266 # 2007-02-14  V1.54 Daniel Tiefnig
 267 #             Improved the '($parent) =' pattern match.
 268 #
 269 # 2007-03-19  V1.55 Steve Campbell
 270 #             Differentiate between permanent and temporary rejects.
 271 #
 272 # 2007-03-29  V1.56 Jez Hancock
 273 #             Fixed some broken HTML links and added missing column headers.
 274 #
 275 # 2007-03-30  V1.57 Steve Campbell
 276 #             Fixed Grand Total Summary Domains, Edomains, and Email columns
 277 #             for Rejects, Temp Rejects, Ham, and Spam rows.
 278 #
 279 # 2007-04-11  V1.58 Steve Campbell
 280 #             Fix to get <> and blackhole to show in edomain tables.
 281 #
 282 # 2007-09-20  V1.59 Steve Campbell
 283 #             Added the -bylocaldomain option
 284 #
 285 # 2007-09-20  V1.60 Heiko Schlittermann
 286 #             Fix for misinterpreted log lines
 287 #
 288 #
 289 #
 290 # For documentation on the logfile format, see
 291 # http://www.exim.org/exim-html-4.50/doc/html/spec_48.html#IX2793
 292
 293 =head1 NAME
 294
 295 eximstats - generates statistics from Exim mainlog or syslog files.
 296
 297 =head1 SYNOPSIS
 298
 299  eximstats [Output] [Options] mainlog1 mainlog2 ...
 300  eximstats -merge [Options] report.1.txt report.2.txt ... > weekly_report.txt
 301
 302 =head2 Output:
 303
 304 =over 4
 305
 306 =item B<-txt>
 307
 308 Output the results in plain text to STDOUT.
 309
 310 =item B<-txt>=I<filename>
 311
 312 Output the results in plain text. Filename '-' for STDOUT is accepted.
 313
 314 =item B<-html>
 315
 316 Output the results in HTML to STDOUT.
 317
 318 =item B<-html>=I<filename>
 319
 320 Output the results in HTML. Filename '-' for STDOUT is accepted.
 321
 322 =item B<-xls>
 323
 324 Output the results in Excel compatible Format to STDOUT.
 325 Requires the Spreadsheet::WriteExcel CPAN module.
 326
 327 =item B<-xls>=I<filename>
 328
 329 Output the results in Excel compatible format. Filename '-' for STDOUT is accepted.
 330
 331
 332 =back
 333
 334 =head2 Options:
 335
 336 =over 4
 337
 338 =item B<-h>I<number>
 339
 340 histogram divisions per hour. The default is 1, and
 341 0 suppresses histograms. Valid values are:
 342
 343 0, 1, 2, 3, 5, 10, 15, 20, 30 or 60.
 344
 345 =item B<-ne>
 346
 347 Don't display error information.
 348
 349 =item B<-nr>
 350
 351 Don't display relaying information.
 352
 353 =item B<-nr>I</pattern/>
 354
 355 Don't display relaying information that matches.
 356
 357 =item B<-nt>
 358
 359 Don't display transport information.
 360
 361 =item B<-nt>I</pattern/>
 362
 363 Don't display transport information that matches
 364
 365 =item B<-q>I<list>
 366
 367 List of times for queuing information single 0 item suppresses.
 368
 369 =item B<-t>I<number>
 370
 371 Display top <number> sources/destinations
 372 default is 50, 0 suppresses top listing.
 373
 374 =item B<-tnl>
 375
 376 Omit local sources/destinations in top listing.
 377
 378 =item B<-t_remote_users>
 379
 380 Include remote users in the top source/destination listings.
 381
 382 =item B<-include_original_destination>
 383
 384 Include the original destination email addresses rather than just
 385 using the final ones.
 386 Useful for finding out which of your mailing lists are receiving mail.
 387
 388 =item B<-show_dt>I<list>
 389
 390 Show the delivery times (B<DT>)for all the messages.
 391
 392 Exim must have been configured to use the +deliver_time logging option
 393 for this option to work.
 394
 395 I<list> is an optional list of times. Eg -show_dt1,2,4,8 will show
 396 the number of messages with delivery times under 1 second, 2 seconds, 4 seconds,
 397 8 seconds, and over 8 seconds.
 398
 399 =item B<-show_rt>I<list>
 400
 401 Show the receipt times for all the messages. The receipt time is
 402 defined as the Completed hh:mm:ss - queue_time_overall - the Receipt hh:mm:ss.
 403 These figures will be skewed by pipelined messages so might not be that useful.
 404
 405 Exim must have been configured to use the +queue_time_overall logging option
 406 for this option to work.
 407
 408 I<list> is an optional list of times. Eg -show_rt1,2,4,8 will show
 409 the number of messages with receipt times under 1 second, 2 seconds, 4 seconds,
 410 8 seconds, and over 8 seconds.
 411
 412 =item B<-byhost>
 413
 414 Show results by sending host. This may be combined with
 415 B<-bydomain> and/or B<-byemail> and/or B<-byedomain>. If none of these options
 416 are specified, then B<-byhost> is assumed as a default.
 417
 418 =item B<-bydomain>
 419
 420 Show results by sending domain.
 421 May be combined with B<-byhost> and/or B<-byemail> and/or B<-byedomain>.
 422
 423 =item B<-byemail>
 424
 425 Show results by sender's email address.
 426 May be combined with B<-byhost> and/or B<-bydomain> and/or B<-byedomain>.
 427
 428 =item B<-byemaildomain> or B<-byedomain>
 429
 430 Show results by sender's email domain.
 431 May be combined with B<-byhost> and/or B<-bydomain> and/or B<-byemail>.
 432
 433 =item B<-pattern> I<Description> I</Pattern/>
 434
 435 Look for the specified pattern and count the number of lines in which it appears.
 436 This option can be specified multiple times. Eg:
 437
 438  -pattern 'Refused connections' '/refused connection/'
 439
 440
 441 =item B<-merge>
 442
 443 This option allows eximstats to merge old eximstat reports together. Eg:
 444
 445  eximstats mainlog.sun > report.sun.txt
 446  eximstats mainlog.mon > report.mon.txt
 447  eximstats mainlog.tue > report.tue.txt
 448  eximstats mainlog.wed > report.web.txt
 449  eximstats mainlog.thu > report.thu.txt
 450  eximstats mainlog.fri > report.fri.txt
 451  eximstats mainlog.sat > report.sat.txt
 452  eximstats -merge       report.*.txt > weekly_report.txt
 453  eximstats -merge -html report.*.txt > weekly_report.html
 454
 455 =over 4
 456
 457 =item *
 458
 459 You can merge text or html reports and output the results as text or html.
 460
 461 =item *
 462
 463 You can use all the normal eximstat output options, but only data
 464 included in the original reports can be shown!
 465
 466 =item *
 467
 468 When merging reports, some loss of accuracy may occur in the top I<n> lists.
 469 This will be towards the ends of the lists.
 470
 471 =item *
 472
 473 The order of items in the top I<n> lists may vary when the data volumes
 474 round to the same value.
 475
 476 =back
 477
 478 =item B<-charts>
 479
 480 Create graphical charts to be displayed in HTML output.
 481 Only valid in combination with I<-html>.
 482
 483 This requires the following modules which can be obtained
 484 from http://www.cpan.org/modules/01modules.index.html
 485
 486 =over 4
 487
 488 =item GD
 489
 490 =item GDTextUtil
 491
 492 =item GDGraph
 493
 494 =back
 495
 496 To install these, download and unpack them, then use the normal perl installation procedure:
 497
 498  perl Makefile.PL
 499  make
 500  make test
 501  make install
 502
 503 =item B<-chartdir>I <dir>
 504
 505 Create the charts in the directory <dir>
 506
 507 =item B<-chartrel>I <dir>
 508
 509 Specify the relative directory for the "img src=" tags from where to include
 510 the charts
 511
 512 =item B<-emptyok>
 513
 514 Specify that it's OK to not find any valid log lines. Without this
 515 we will output an error message if we don't find any.
 516
 517 =item B<-d>
 518
 519 Debug flag. This outputs the eval()'d parser onto STDOUT which makes it
 520 easier to trap errors in the eval section. Remember to add 1 to the line numbers to allow for the
 521 title!
 522
 523 =back
 524
 525 =head1 DESCRIPTION
 526
 527 Eximstats parses exim mainlog and syslog files to output a statistical
 528 analysis of the messages processed. By default, a text
 529 analysis is generated, but you can request other output formats
 530 using flags. See the help (B<-help>) to learn
 531 about how to create charts from the tables.
 532
 533 =head1 AUTHOR
 534
 535 There is a web site at http://www.exim.org - this contains details of the
 536 mailing list exim-users@exim.org.
 537
 538 =head1 TO DO
 539
 540 This program does not perfectly handle messages whose received
 541 and delivered log lines are in different files, which can happen
 542 when you have multiple mail servers and a message cannot be
 543 immediately delivered. Fixing this could be tricky...
 544
 545 Merging of xls files is not (yet) possible. Be free to implement :)
 546
 547 =cut
 548
 549 use integer;
 550 use strict;
 551 use IO::File;
 552
 553 # use Time::Local;  # PH/FANF
 554 use POSIX;
 555
 556 use vars qw($HAVE_GD_Graph_pie $HAVE_GD_Graph_linespoints $HAVE_Spreadsheet_WriteExcel);
 557 eval { require GD::Graph::pie; };
 558 $HAVE_GD_Graph_pie = $@ ? 0 : 1;
 559 eval { require GD::Graph::linespoints; };
 560 $HAVE_GD_Graph_linespoints = $@ ? 0 : 1;
 561 eval { require Spreadsheet::WriteExcel; };
 562 $HAVE_Spreadsheet_WriteExcel = $@ ? 0 : 1;
 563
 564
 565 ##################################################
 566 #             Static data                        #
 567 ##################################################
 568 # 'use vars' instead of 'our' as perl5.005 is still in use out there!
 569 use vars qw(@tab62 @days_per_month $gig);
 570 use vars qw($VERSION);
 571 use vars qw($COLUMN_WIDTHS);
 572 use vars qw($WEEK $DAY $HOUR $MINUTE);
 573
 574
 575 @tab62 =
 576   (0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,     # 0-9
 577    0,10,11,12,13,14,15,16,17,18,19,20,  # A-K
 578   21,22,23,24,25,26,27,28,29,30,31,32,  # L-W
 579   33,34,35, 0, 0, 0, 0, 0,              # X-Z
 580    0,36,37,38,39,40,41,42,43,44,45,46,  # a-k
 581   47,48,49,50,51,52,53,54,55,56,57,58,  # l-w
 582   59,60,61);                            # x-z
 583
 584 @days_per_month = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334);
 585 $gig     = 1024 * 1024 * 1024;
 586 $VERSION = '1.60';
 587
 588 # How much space do we allow for the Hosts/Domains/Emails/Edomains column headers?
 589 $COLUMN_WIDTHS = 8;
 590
 591 $MINUTE = 60;
 592 $HOUR   = 60 * $MINUTE;
 593 $DAY    = 24 * $HOUR;
 594 $WEEK   =  7 * $DAY;
 595
 596 # Declare global variables.
 597 use vars qw($total_received_data  $total_received_data_gigs  $total_received_count);
 598 use vars qw($total_delivered_data $total_delivered_data_gigs $total_delivered_messages $total_delivered_addresses);
 599 use vars qw(%timestamp2time);                   #Hash of timestamp => time.
 600 use vars qw($last_timestamp $last_time);        #The last time convertion done.
 601 use vars qw($last_date $date_seconds);          #The last date convertion done.
 602 use vars qw($last_offset $offset_seconds);      #The last time offset convertion done.
 603 use vars qw($localtime_offset);
 604 use vars qw($i);                                #General loop counter.
 605 use vars qw($debug);                            #Debug mode?
 606 use vars qw($ntopchart);                        #How many entries should make it into the chart?
 607 use vars qw($gddirectory);                      #Where to put files from GD::Graph
 608
 609 # SpamAssassin variables
 610 use vars qw($spam_score $spam_score_gigs);
 611 use vars qw($ham_score  $ham_score_gigs);
 612 use vars qw(%ham_count_by_ip %spam_count_by_ip);
 613 use vars qw(%rejected_count_by_ip %rejected_count_by_reason);
 614 use vars qw(%temporarily_rejected_count_by_ip %temporarily_rejected_count_by_reason);
 615
 616 #For use in Speadsheed::WriteExcel
 617 use vars qw($workbook $ws_global $ws_relayed $ws_errors);
 618 use vars qw($row $col $row_hist $col_hist);
 619 use vars qw($run_hist);
 620 use vars qw($f_default $f_header1 $f_header2 $f_header2_m $f_headertab $f_percent); #Format Header
 621
 622 # Output FileHandles
 623 use vars qw($txt_fh $htm_fh $xls_fh);
 624
 625 $ntopchart = 5;
 626
 627 # The following are parameters whose values are
 628 # set by command line switches:
 629 use vars qw($show_errors $show_relay $show_transport $transport_pattern);
 630 use vars qw($topcount $local_league_table $include_remote_users $do_local_domain);
 631 use vars qw($hist_opt $hist_interval $hist_number $volume_rounding $emptyOK);
 632 use vars qw($relay_pattern @queue_times @user_patterns @user_descriptions);
 633 use vars qw(@rcpt_times @delivery_times);
 634 use vars qw($include_original_destination);
 635 use vars qw($txt_fh $htm_fh $xls_fh);
 636
 637 use vars qw(%do_sender);                #Do sender by Host, Domain, Email, and/or Edomain tables.
 638 use vars qw($charts $chartrel $chartdir $charts_option_specified);
 639 use vars qw($merge_reports);            #Merge old reports ?
 640
 641 # The following are modified in the parse() routine, and
 642 # referred to in the print_*() routines.
 643 use vars qw($delayed_count $relayed_unshown $begin $end);
 644 use vars qw(%messages @message);
 645 use vars qw(%received_count       %received_data       %received_data_gigs);
 646 use vars qw(%delivered_messages      %delivered_data      %delivered_data_gigs %delivered_addresses);
 647 use vars qw(%received_count_user  %received_data_user  %received_data_gigs_user);
 648 use vars qw(%delivered_messages_user %delivered_addresses_user %delivered_data_user %delivered_data_gigs_user);
 649 use vars qw(%delivered_messages_local_domain %delivered_addresses_local_domain %delivered_data_local_domain %delivered_data_gigs_local_domain);
 650 use vars qw(%transported_count    %transported_data    %transported_data_gigs);
 651 use vars qw(%relayed %errors_count $message_errors);
 652 use vars qw(@qt_all_bin @qt_remote_bin);
 653 use vars qw($qt_all_overflow $qt_remote_overflow);
 654 use vars qw(@dt_all_bin @dt_remote_bin %rcpt_times_bin);
 655 use vars qw($dt_all_overflow $dt_remote_overflow %rcpt_times_overflow);
 656 use vars qw(@received_interval_count @delivered_interval_count);
 657 use vars qw(@user_pattern_totals @user_pattern_interval_count);
 658
 659 use vars qw(%report_totals);
 660
 661 # Enumerations
 662 use vars qw($SIZE $FROM_HOST $FROM_ADDRESS $ARRIVAL_TIME $REMOTE_DELIVERED $PROTOCOL);
 663 use vars qw($DELAYED $HAD_ERROR);
 664 $SIZE             = 0;
 665 $FROM_HOST        = 1;
 666 $FROM_ADDRESS     = 2;
 667 $ARRIVAL_TIME     = 3;
 668 $REMOTE_DELIVERED = 4;
 669 $DELAYED          = 5;
 670 $HAD_ERROR        = 6;
 671 $PROTOCOL         = 7;
 672
 673
 674
 675 ##################################################
 676 #                   Subroutines                  #
 677 ##################################################
 678
 679 #######################################################################
 680 # get_filehandle($file,\%output_files);
 681 # Return a filehandle writing to $file.
 682 #
 683 # If %output_files is defined, check that $output_files{$file}
 684 # doesn't exist and die if it does, or set it if it doesn't.
 685 #######################################################################
 686 sub get_filehandle {
 687   my($file,$output_files_href) = @_;
 688
 689   $file = '-' if ($file eq '');
 690
 691   if (defined $output_files_href) {
 692     die "You can only output to '$file' once! Use -h for help.\n" if exists $output_files_href->{$file};
 693     $output_files_href->{$file} = 1;
 694   }
 695
 696   if ($file eq '-') {
 697     return \*STDOUT;
 698   }
 699
 700   if (-e $file) {
 701     unlink $file or die "Failed to rm $file: $!";
 702   }
 703
 704   my $fh = new IO::File $file, O_WRONLY|O_CREAT|O_EXCL;
 705   die "new IO::File $file failed: $!" unless (defined $fh);
 706   return $fh;
 707 }
 708
 709
 710 #######################################################################
 711 # volume_rounded();
 712 #
 713 # $rounded_volume = volume_rounded($bytes,$gigabytes);
 714 #
 715 # Given a data size in bytes, round it to KB, MB, or GB
 716 # as appropriate.
 717 #
 718 # Eg 12000 => 12KB, 15000000 => 14GB, etc.
 719 #
 720 # Note: I've experimented with Math::BigInt and it results in a 33%
 721 # performance degredation as opposed to storing numbers split into
 722 # bytes and gigabytes.
 723 #######################################################################
 724 sub volume_rounded {
 725   my($x,$g) = @_;
 726   $x = 0 unless $x;
 727   $g = 0 unless $g;
 728   my($rounded);
 729
 730   while ($x > $gig) {
 731     $g++;
 732     $x -= $gig;
 733   }
 734
 735   if ($volume_rounding) {
 736     # Values < 1 GB
 737     if ($g <= 0) {
 738       if ($x < 10000) {
 739         $rounded = sprintf("%6d", $x);
 740       }
 741       elsif ($x < 10000000) {
 742         $rounded = sprintf("%4dKB", ($x + 512)/1024);
 743       }
 744       else {
 745         $rounded = sprintf("%4dMB", ($x + 512*1024)/(1024*1024));
 746       }
 747     }
 748     # Values between 1GB and 10GB are printed in MB
 749     elsif ($g < 10) {
 750       $rounded = sprintf("%4dMB", ($g * 1024) + ($x + 512*1024)/(1024*1024));
 751     }
 752     else {
 753       # Handle values over 10GB
 754       $rounded = sprintf("%4dGB", $g + ($x + $gig/2)/$gig);
 755     }
 756   }
 757   else {
 758     # We don't want any rounding to be done.
 759     # and we don't need broken formated output which on one hand avoids numbers from
 760     # being interpreted as string by Spreadsheed Calculators, on the other hand
 761     # breaks if more than 4 digits! -> flexible length instead of fixed length
 762     # Format the return value at the output routine! -fh
 763     #$rounded = sprintf("%d", ($g * $gig) + $x);
 764     no integer;
 765     $rounded = sprintf("%.0f", ($g * $gig) + $x);
 766   }
 767
 768   return $rounded;
 769 }
 770
 771
 772 #######################################################################
 773 # un_round();
 774 #
 775 #  un_round($rounded_volume,\$bytes,\$gigabytes);
 776 #
 777 # Given a volume in KB, MB or GB, as generated by volume_rounded(),
 778 # do the reverse transformation and convert it back into Bytes and Gigabytes.
 779 # These are added to the $bytes and $gigabytes parameters.
 780 #
 781 # Given a data size in bytes, round it to KB, MB, or GB
 782 # as appropriate.
 783 #
 784 # EG: 500 => (500,0), 14GB => (0,14), etc.
 785 #######################################################################
 786 sub un_round {
 787   my($rounded,$bytes_sref,$gigabytes_sref) = @_;
 788
 789   if ($rounded =~ /(\d+)GB/) {
 790     $$gigabytes_sref += $1;
 791   }
 792   elsif ($rounded =~ /(\d+)MB/) {
 793     $$gigabytes_sref +=   $1 / 1024;
 794     $$bytes_sref     += (($1 % 1024 ) * 1024 * 1024);
 795   }
 796   elsif ($rounded =~ /(\d+)KB/) {
 797     $$gigabytes_sref +=  $1 / (1024 * 1024);
 798     $$bytes_sref     += ($1 % (1024 * 1024) * 1024);
 799   }
 800   elsif ($rounded =~ /(\d+)/) {
 801     # We need to turn off integer in case we are merging an -nvr report.
 802     no integer;
 803     $$gigabytes_sref += int($1 / $gig);
 804     $$bytes_sref     += $1 % $gig;
 805   }
 806
 807   #Now reduce the bytes down to less than 1GB.
 808   add_volume($bytes_sref,$gigabytes_sref,0) if ($$bytes_sref > $gig);
 809 }
 810
 811
 812 #######################################################################
 813 # add_volume();
 814 #
 815 #   add_volume(\$bytes,\$gigs,$size);
 816 #
 817 # Add $size to $bytes/$gigs where this is a number split into
 818 # bytes ($bytes) and gigabytes ($gigs). This is significantly
 819 # faster than using Math::BigInt.
 820 #######################################################################
 821 sub add_volume {
 822   my($bytes_ref,$gigs_ref,$size) = @_;
 823   $$bytes_ref = 0 if ! defined $$bytes_ref;
 824   $$gigs_ref = 0 if ! defined $$gigs_ref;
 825   $$bytes_ref += $size;
 826   while ($$bytes_ref > $gig) {
 827     $$gigs_ref++;
 828     $$bytes_ref -= $gig;
 829   }
 830 }
 831
 832
 833 #######################################################################
 834 # format_time();
 835 #
 836 #  $formatted_time = format_time($seconds);
 837 #
 838 # Given a time in seconds, break it down into
 839 # weeks, days, hours, minutes, and seconds.
 840 #
 841 # Eg 12005 => 3h20m5s
 842 #######################################################################
 843 sub format_time {
 844 my($t) = pop @_;
 845 my($s) = $t % 60;
 846 $t /= 60;
 847 my($m) = $t % 60;
 848 $t /= 60;
 849 my($h) = $t % 24;
 850 $t /= 24;
 851 my($d) = $t % 7;
 852 my($w) = $t/7;
 853 my($p) = "";
 854 $p .= "$w"."w" if $w > 0;
 855 $p .= "$d"."d" if $d > 0;
 856 $p .= "$h"."h" if $h > 0;
 857 $p .= "$m"."m" if $m > 0;
 858 $p .= "$s"."s" if $s > 0 || $p eq "";
 859 $p;
 860 }
 861
 862
 863 #######################################################################
 864 #  unformat_time();
 865 #
 866 #  $seconds = unformat_time($formatted_time);
 867 #
 868 # Given a time in weeks, days, hours, minutes, or seconds, convert it to seconds.
 869 #
 870 # Eg 3h20m5s => 12005
 871 #######################################################################
 872 sub unformat_time {
 873   my($formated_time) = pop @_;
 874   my $time = 0;
 875
 876   while ($formated_time =~ s/^(\d+)([wdhms]?)//) {
 877     $time +=  $1 if ($2 eq '' || $2 eq 's');
 878     $time +=  $1 * 60 if ($2 eq 'm');
 879     $time +=  $1 * 60 * 60 if ($2 eq 'h');
 880     $time +=  $1 * 60 * 60 * 24 if ($2 eq 'd');
 881     $time +=  $1 * 60 * 60 * 24  * 7 if ($2 eq 'w');
 882   }
 883   $time;
 884 }
 885
 886
 887 #######################################################################
 888 # seconds();
 889 #
 890 #  $time = seconds($timestamp);
 891 #
 892 # Given a time-of-day timestamp, convert it into a time() value using
 893 # POSIX::mktime.  We expect the timestamp to be of the form
 894 # "$year-$mon-$day $hour:$min:$sec", with month going from 1 to 12,
 895 # and the year to be absolute (we do the necessary conversions). The
 896 # timestamp may be followed with an offset from UTC like "+$hh$mm"; if the
 897 # offset is not present, and we have not been told that the log is in UTC
 898 # (with the -utc option), then we adjust the time by the current local
 899 # time offset so that it can be compared with the time recorded in message
 900 # IDs, which is UTC.
 901 #
 902 # To improve performance, we only use mktime on the date ($year-$mon-$day),
 903 # and only calculate it if the date is different to the previous time we
 904 # came here. We then add on seconds for the '$hour:$min:$sec'.
 905 #
 906 # We also store the results of the last conversion done, and only
 907 # recalculate if the date is different.
 908 #
 909 # We used to have the '-cache' flag which would store the results of the
 910 # mktime() call. However, the current way of just using mktime() on the
 911 # date obsoletes this.
 912 #######################################################################
 913 sub seconds {
 914   my($timestamp) = @_;
 915
 916   # Is the timestamp the same as the last one?
 917   return $last_time if ($last_timestamp eq $timestamp);
 918
 919   return 0 unless ($timestamp =~ /^((\d{4})\-(\d\d)-(\d\d))\s(\d\d):(\d\d):(\d\d)( ([+-])(\d\d)(\d\d))?/o);
 920
 921   unless ($last_date eq $1) {
 922     $last_date = $1;
 923     my(@timestamp) = (0,0,0,$4,$3,$2);
 924     $timestamp[5] -= 1900;
 925     $timestamp[4]--;
 926     $date_seconds = mktime(@timestamp);
 927   }
 928   my $time = $date_seconds + ($5 * 3600) + ($6 * 60) + $7;
 929
 930   # SC. Use cacheing. Also note we want seconds not minutes.
 931   #my($this_offset) = ($10 * 60 + $11) * ($9 . "1") if defined $8;
 932   if (defined $8 && ($8 ne $last_offset)) {
 933     $last_offset = $8;
 934     $offset_seconds = ($10 * 60 + $11) * 60;
 935     $offset_seconds = -$offset_seconds if ($9 eq '-');
 936   }
 937
 938
 939   if (defined $7) {
 940     #$time -= $this_offset;
 941     $time -= $offset_seconds;
 942   } elsif (defined $localtime_offset) {
 943     $time -= $localtime_offset;
 944   }
 945
 946   # Store the last timestamp received.
 947   $last_timestamp = $timestamp;
 948   $last_time      = $time;
 949
 950   $time;
 951 }
 952
 953
 954 #######################################################################
 955 #  id_seconds();
 956 #
 957 #  $time = id_seconds($message_id);
 958 #
 959 # Given a message ID, convert it into a time() value.
 960 #######################################################################
 961 sub id_seconds {
 962 my($sub_id) = substr((pop @_), 0, 6);
 963 my($s) = 0;
 964 my(@c) = split(//, $sub_id);
 965 while($#c >= 0) { $s = $s * 62 + $tab62[ord(shift @c) - ord('0')] }
 966 $s;
 967 }
 968
 969 #######################################################################
 970 #  wdhms_seconds();
 971 #
 972 #  $seconds = wdhms_seconds($string);
 973 #
 974 # Convert a string in a week/day/hour/minute/second format (eg 4h10s)
 975 # into seconds.
 976 #######################################################################
 977 sub wdhms_seconds {
 978   if ($_[0] =~ /^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?/) {
 979     return((($1||0) * $WEEK) + (($2||0) * $DAY) + (($3||0) * $HOUR) + (($4||0) * $MINUTE) + ($5||0));
 980   }
 981   return undef;
 982 }
 983
 984 #######################################################################
 985 #  queue_time();
 986 #
 987 #  $queued = queue_time($completed_tod, $arrival_time, $id);
 988 #
 989 # Given the completed time of day and either the arrival time
 990 # (preferred), or the message ID, calculate how long the message has
 991 # been on the queue.
 992 #
 993 #######################################################################
 994 sub queue_time {
 995   my($completed_tod, $arrival_time, $id) = @_;
 996
 997   # Note: id_seconds() benchmarks as 42% slower than seconds()
 998   # and computing the time accounts for a significant portion of
 999   # the run time.
1000   if (defined $arrival_time) {
1001     return(seconds($completed_tod) - seconds($arrival_time));
1002   }
1003   else {
1004     return(seconds($completed_tod) - id_seconds($id));
1005   }
1006 }
1007
1008
1009 #######################################################################
1010 #  calculate_localtime_offset();
1011 #
1012 #  $localtime_offset = calculate_localtime_offset();
1013 #
1014 # Calculate the the localtime offset from gmtime in seconds.
1015 #
1016 #  $localtime = time() + $localtime_offset.
1017 #
1018 # These are the same semantics as ISO 8601 and RFC 2822 timezone offsets.
1019 # (West is negative, East is positive.)
1020 #######################################################################
1021
1022 # $localtime = gmtime() + $localtime_offset.  OLD COMMENT
1023 # This subroutine commented out as it's not currently in use.
1024
1025 #sub calculate_localtime_offset {
1026 #  # Pick an arbitrary date, convert it to localtime & gmtime, and return the difference.
1027 #  my (@sample_date) = (0,0,0,5,5,100);
1028 #  my $localtime = timelocal(@sample_date);
1029 #  my $gmtime    = timegm(@sample_date);
1030 #  my $offset = $localtime - $gmtime;
1031 #  return $offset;
1032 #}
1033
1034 sub calculate_localtime_offset {
1035   # Assume that the offset at the moment is valid across the whole
1036   # period covered by the logs that we're analysing. This may not
1037   # be true around the time the clocks change in spring or autumn.
1038   my $utc = time;
1039   # mktime works on local time and gmtime works in UTC
1040   my $local = mktime(gmtime($utc));
1041   return $local - $utc;
1042 }
1043
1044
1045
1046 #######################################################################
1047 # print_duration_table();
1048 #
1049 #  print_duration_table($title, $message_type, \@times, \@values, $overflow);
1050 #
1051 # Print a table showing how long a particular step took for
1052 # the messages. The parameters are:
1053 #   $title         Eg "Time spent on the queue"
1054 #   $message_type  Eg "Remote"
1055 #   \@times        The maximum time a message took for it to increment
1056 #                  the corresponding @values counter.
1057 #   \@values       An array of message counters.
1058 #   $overflow      The number of messages which exceeded the maximum
1059 #                  time.
1060 #######################################################################
1061 sub print_duration_table {
1062 no integer;
1063 my($title, $message_type, $times_aref, $values_aref, $overflow) = @_;
1064 my(@chartdatanames);
1065 my(@chartdatavals);
1066
1067 my $printed_one = 0;
1068 my $cumulative_percent = 0;
1069
1070 my $queue_total = $overflow;
1071 map {$queue_total += $_} @$values_aref;
1072
1073 my $temp = "$title: $message_type";
1074
1075
1076 my $txt_format = "%5s %4s   %6d %5.1f%%  %5.1f%%\n";
1077 my $htm_format = "<tr><td align=\"right\">%s %s</td><td align=\"right\">%d</td><td align=\"right\">%5.1f%%</td><td align=\"right\">%5.1f%%</td>\n";
1078
1079 # write header
1080 printf $txt_fh ("%s\n%s\n\n", $temp, "-" x length($temp)) if $txt_fh;
1081 if ($htm_fh) {
1082   print $htm_fh "<hr><a name=\"$title $message_type\"></a><h2>$temp</h2>\n";
1083   print $htm_fh "<table border=0 width=\"100%\"><tr><td><table border=1>\n";
1084   print $htm_fh "<tr><th>Time</th><th>Messages</th><th>Percentage</th><th>Cumulative Percentage</th>\n";
1085 }
1086 if ($xls_fh) {
1087   $ws_global->write($row++, $col, "$title: ".$message_type, $f_header2);
1088   my @content=("Time", "Messages", "Percentage", "Cumulative Percentage");
1089   &set_worksheet_line($ws_global, $row++, 1, \@content, $f_headertab);
1090 }
1091
1092
1093 for ($i = 0; $i <= $#$times_aref; ++$i) {
1094   if ($$values_aref[$i] > 0)
1095     {
1096     my $percent = ($values_aref->[$i] * 100)/$queue_total;
1097     $cumulative_percent += $percent;
1098
1099     my @content=($printed_one? "     " : "Under",
1100         format_time($times_aref->[$i]),
1101         $values_aref->[$i], $percent, $cumulative_percent);
1102
1103     if ($htm_fh) {
1104       printf $htm_fh ($htm_format, @content);
1105       if (!defined($values_aref->[$i])) {
1106         print $htm_fh "Not defined";
1107       }
1108     }
1109     if ($txt_fh) {
1110       printf $txt_fh ($txt_format, @content);
1111       if (!defined($times_aref->[$i])) {
1112         print $txt_fh "Not defined";
1113       }
1114     }
1115     if ($xls_fh)
1116     {
1117       no integer;
1118       &set_worksheet_line($ws_global, $row, 0, [@content[0,1,2]], $f_default);
1119       &set_worksheet_line($ws_global, $row++, 3, [$content[3]/100,$content[4]/100], $f_percent);
1120
1121       if (!defined($times_aref->[$i])) {
1122         $col=0;
1123         $ws_global->write($row++, $col, "Not defined"  );
1124       }
1125     }
1126
1127     push(@chartdatanames,
1128       ($printed_one? "" : "Under") . format_time($times_aref->[$i]));
1129     push(@chartdatavals, $$values_aref[$i]);
1130     $printed_one = 1;
1131   }
1132 }
1133
1134 if ($overflow && $overflow > 0) {
1135   my $percent = ($overflow * 100)/$queue_total;
1136   $cumulative_percent += $percent;
1137
1138     my @content = ("Over ", format_time($times_aref->[-1]),
1139         $overflow, $percent, $cumulative_percent);
1140
1141     printf $txt_fh ($txt_format, @content) if $txt_fh;
1142     printf $htm_fh ($htm_format, @content) if $htm_fh;
1143     if ($xls_fh)
1144     {
1145       &set_worksheet_line($ws_global, $row, 0, [@content[0,1,2]], $f_default);
1146       &set_worksheet_line($ws_global, $row++, 3, [$content[3]/100,$content[4]/100], $f_percent);
1147     }
1148
1149 }
1150
1151 push(@chartdatanames, "Over " . format_time($times_aref->[-1]));
1152 push(@chartdatavals, $overflow);
1153
1154 #printf("Unknown   %6d\n", $queue_unknown) if $queue_unknown > 0;
1155 if ($htm_fh) {
1156   print $htm_fh "</table></td><td>";
1157
1158   if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals > 0)) {
1159     my @data = (
1160        \@chartdatanames,
1161        \@chartdatavals
1162     );
1163     my $graph = GD::Graph::pie->new(200, 200);
1164     my $pngname = "$title-$message_type.png";
1165     $pngname =~ s/[^\w\-\.]/_/;
1166
1167     my $graph_title = "$title ($message_type)";
1168     $graph->set(title => $graph_title) if (length($graph_title) < 21);
1169
1170     my $gd = $graph->plot(\@data) or warn($graph->error);
1171     if ($gd) {
1172       open(IMG, ">$chartdir/$pngname") or die "Could not write $chartdir/$pngname: $!\n";
1173       binmode IMG;
1174       print IMG $gd->png;
1175       close IMG;
1176       print $htm_fh "<img src=\"$chartrel/$pngname\">";
1177     }
1178   }
1179   print $htm_fh "</td></tr></table>\n";
1180 }
1181
1182 if ($xls_fh)
1183 {
1184   $row++;
1185 }
1186 print $txt_fh "\n" if $txt_fh;
1187 print $htm_fh "\n" if $htm_fh;
1188
1189 }
1190
1191
1192 #######################################################################
1193 # print_histogram();
1194 #
1195 #  print_histogram('Deliveries|Messages received|$pattern', $unit, @interval_count);
1196 #
1197 # Print a histogram of the messages delivered/received per time slot
1198 # (hour by default).
1199 #######################################################################
1200 sub print_histogram {
1201 my($text, $unit, @interval_count) = @_;
1202 my(@chartdatanames);
1203 my(@chartdatavals);
1204 my($maxd) = 0;
1205
1206 # save first row of print_histogram for xls output
1207 if (!$run_hist) {
1208   $row_hist = $row;
1209 }
1210 else {
1211   $row = $row_hist;
1212 }
1213
1214 for ($i = 0; $i < $hist_number; $i++)
1215   { $maxd = $interval_count[$i] if $interval_count[$i] > $maxd; }
1216
1217 my $scale = int(($maxd + 25)/50);
1218 $scale = 1 if $scale == 0;
1219
1220 if ($scale != 1) {
1221   if ($unit !~ s/y$/ies/) {
1222     $unit .= 's';
1223   }
1224 }
1225
1226 # make and output title
1227 my $title = sprintf("$text per %s",
1228     ($hist_interval == 60)? "hour" :
1229     ($hist_interval == 1)?  "minute" : "$hist_interval minutes");
1230
1231 my $txt_htm_title = $title . " (each dot is $scale $unit)";
1232
1233 printf $txt_fh ("%s\n%s\n\n", $txt_htm_title, "-" x length($txt_htm_title)) if $txt_fh;
1234
1235 if ($htm_fh) {
1236   print $htm_fh "<hr><a name=\"$text\"></a><h2>$txt_htm_title</h2>\n";
1237   print $htm_fh "<table border=0 width=\"100%\">\n";
1238   print $htm_fh "<tr><td><pre>\n";
1239 }
1240
1241 if ($xls_fh) {
1242   $title =~ s/Messages/Msg/ ;
1243   $row += 2;
1244   $ws_global->write($row++, $col_hist+1, $title, $f_headertab);
1245 }
1246
1247
1248 my $hour = 0;
1249 my $minutes = 0;
1250 for ($i = 0; $i < $hist_number; $i++) {
1251   my $c = $interval_count[$i];
1252
1253   # If the interval is an hour (the maximum) print the starting and
1254   # ending hours as a label. Otherwise print the starting hour and
1255   # minutes, which take up the same space.
1256
1257   my $temp;
1258   if ($hist_opt == 1) {
1259     $temp = sprintf("%02d-%02d", $hour, $hour + 1);
1260
1261     print $txt_fh $temp if $txt_fh;
1262     print $htm_fh $temp if $htm_fh;
1263
1264     if ($xls_fh) {
1265       if ($run_hist==0) {
1266         # only on first run
1267         $ws_global->write($row, 0, [$temp], $f_default);
1268       }
1269     }
1270
1271     push(@chartdatanames, $temp);
1272     $hour++;
1273   }
1274   else {
1275     if ($minutes == 0)
1276       { $temp = sprintf("%02d:%02d", $hour, $minutes) }
1277     else
1278       { $temp = sprintf("  :%02d", $minutes) }
1279
1280     print $txt_fh $temp if $txt_fh;
1281     print $htm_fh $temp if $htm_fh;
1282     if (($xls_fh) and ($run_hist==0)) {
1283       # only on first run
1284       $temp = sprintf("%02d:%02d", $hour, $minutes);
1285       $ws_global->write($row, 0, [$temp], $f_default);
1286     }
1287
1288     push(@chartdatanames, $temp);
1289     $minutes += $hist_interval;
1290     if ($minutes >= 60) {
1291       $minutes = 0;
1292       $hour++;
1293     }
1294   }
1295   push(@chartdatavals, $c);
1296
1297   printf $txt_fh (" %6d %s\n", $c, "." x ($c/$scale)) if $txt_fh;
1298   printf $htm_fh (" %6d %s\n", $c, "." x ($c/$scale)) if $htm_fh;
1299   $ws_global->write($row++, $col_hist+1, [$c], $f_default) if $xls_fh;
1300
1301 } #end for
1302
1303 printf $txt_fh "\n" if $txt_fh;
1304 printf $htm_fh "\n" if $htm_fh;
1305
1306 if ($htm_fh)
1307 {
1308   print $htm_fh "</pre>\n";
1309   print $htm_fh "</td><td>\n";
1310   if ($HAVE_GD_Graph_linespoints && $charts && ($#chartdatavals > 0)) {
1311     # calculate the graph
1312     my @data = (
1313        \@chartdatanames,
1314        \@chartdatavals
1315     );
1316     my $graph = GD::Graph::linespoints->new(300, 300);
1317     $graph->set(
1318         x_label           => 'Time',
1319         y_label           => 'Amount',
1320         title             => $text,
1321         x_labels_vertical => 1
1322     );
1323     my $pngname = "histogram_$text.png";
1324     $pngname =~ s/[^\w\._]/_/g;
1325
1326     my $gd = $graph->plot(\@data) or warn($graph->error);
1327     if ($gd) {
1328       open(IMG, ">$chartdir/$pngname") or die "Could not write $chartdir/$pngname: $!\n";
1329       binmode IMG;
1330       print IMG $gd->png;
1331       close IMG;
1332       print $htm_fh "<img src=\"$chartrel/$pngname\">";
1333     }
1334   }
1335   print $htm_fh "</td></tr></table>\n";
1336 }
1337
1338 $col_hist++; # where to continue next times
1339
1340 $row+=2;     # leave some space after history block
1341 $run_hist=1; # we have done this once or more
1342 }
1343
1344
1345
1346 #######################################################################
1347 # print_league_table();
1348 #
1349 #  print_league_table($league_table_type,\%message_count,\%address_count,\%message_data,\%message_data_gigs, $spreadsheet, $row_sref);
1350 #
1351 # Given hashes of message count, address count, and message data,
1352 # which are keyed by the table type (eg by the sending host), print a
1353 # league table showing the top $topcount (defaults to 50).
1354 #######################################################################
1355 sub print_league_table {
1356   my($text,$m_count,$a_count,$m_data,$m_data_gigs,$spreadsheet, $row_sref) = @_;
1357   my($name) = ($topcount == 1)? "$text" : "$topcount ${text}s";
1358   my($title) = "Top $name by message count";
1359   my(@chartdatanames) = ();
1360   my(@chartdatavals) = ();
1361   my $chartotherval = 0;
1362   $text = ucfirst($text);
1363
1364   # Align non-local addresses to the right (so all the .com's line up).
1365   # Local addresses are aligned on the left as they are userids.
1366   my $align = ($text !~ /local/i) ? 'right' : 'left';
1367
1368
1369   ################################################
1370   # Generate the printf formats and table headers.
1371   ################################################
1372   my(@headers) = ('Messages');
1373   #push(@headers,'Addresses') if defined $a_count;
1374   push(@headers,'Addresses') if defined $a_count && %$a_count;
1375   push(@headers,'Bytes','Average') if defined $m_data;
1376
1377   my $txt_format = "%10s " x @headers . "  %s\n";
1378   my $txt_col_headers = sprintf $txt_format, @headers, $text;
1379   my $htm_format = "<tr>" . '<td align="right">%s</td>'x@headers . "<td align=\"$align\" nowrap>%s</td></tr>\n";
1380   my $htm_col_headers = sprintf $htm_format, @headers, $text;
1381   $htm_col_headers =~ s/(<\/?)td/$1th/g;      #Convert <td>'s to <th>'s for the header.
1382
1383
1384   ################################################
1385   # Write the table headers
1386   ################################################
1387   printf $txt_fh ("%s\n%s\n%s", $title, "-" x length($title),$txt_col_headers) if $txt_fh;
1388
1389   if ($htm_fh) {
1390     print $htm_fh <<EoText;
1391 <hr><a name="$text count"></a><h2>$title</h2>
1392 <table border=0 width="100%">
1393 <tr><td>
1394 <table border=1>
1395 EoText
1396   print $htm_fh $htm_col_headers
1397   }
1398
1399   if ($xls_fh) {
1400     $spreadsheet->write(${$row_sref}++, 0, $title, $f_header2);
1401     $spreadsheet->write(${$row_sref}++, 0, [@headers, $text], $f_headertab);
1402   }
1403
1404
1405   # write content
1406   foreach my $key (top_n_sort($topcount,$m_count,$m_data_gigs,$m_data)) {
1407
1408     # When displaying the average figures, we calculate the average of
1409     # the rounded data, as the user would calculate it. This reduces
1410     # the accuracy slightly, but we have to do it this way otherwise
1411     # when using -merge to convert results from text to HTML and
1412     # vice-versa discrepencies would occur.
1413     my $messages  = $$m_count{$key};
1414     my @content = ($messages);
1415     push(@content, $$a_count{$key}) if defined $a_count;
1416     if (defined $m_data) {
1417       my $rounded_volume = volume_rounded($$m_data{$key},$$m_data_gigs{$key});
1418       my($data,$gigs) = (0,0);
1419       un_round($rounded_volume,\$data,\$gigs);
1420       my $rounded_average = volume_rounded($data/$messages,$gigs/$messages);
1421       push(@content, $rounded_volume, $rounded_average);
1422     }
1423
1424     # write content
1425     printf $txt_fh ($txt_format, @content, $key) if $txt_fh;
1426
1427     if ($htm_fh) {
1428       my $htmlkey = $key;
1429       $htmlkey =~ s/>/\&gt\;/g;
1430       $htmlkey =~ s/</\&lt\;/g;
1431       printf $htm_fh ($htm_format, @content, $htmlkey);
1432     }
1433     $spreadsheet->write(${$row_sref}++, 0, [@content, $key], $f_default) if $xls_fh;
1434
1435     if (scalar @chartdatanames < $ntopchart) {
1436       push(@chartdatanames, $key);
1437       push(@chartdatavals, $$m_count{$key});
1438     }
1439     else {
1440       $chartotherval += $$m_count{$key};
1441     }
1442   }
1443
1444   push(@chartdatanames, "Other");
1445   push(@chartdatavals, $chartotherval);
1446
1447   print $txt_fh "\n" if $txt_fh;
1448   if ($htm_fh) {
1449     print $htm_fh "</table>\n";
1450     print $htm_fh "</td><td>\n";
1451     if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals > 0))
1452       {
1453       # calculate the graph
1454       my @data = (
1455          \@chartdatanames,
1456          \@chartdatavals
1457       );
1458       my $graph = GD::Graph::pie->new(300, 300);
1459       $graph->set(
1460           x_label           => 'Name',
1461           y_label           => 'Amount',
1462           title             => 'By count',
1463       );
1464       my $gd = $graph->plot(\@data) or warn($graph->error);
1465       if ($gd) {
1466         my $temp = $text;
1467         $temp =~ s/ /_/g;
1468         open(IMG, ">$chartdir/${temp}_count.png") or die "Could not write $chartdir/${temp}_count.png: $!\n";
1469         binmode IMG;
1470         print IMG $gd->png;
1471         close IMG;
1472         print $htm_fh "<img src=\"$chartrel/${temp}_count.png\">";
1473       }
1474     }
1475     print $htm_fh "</td><td>\n";
1476     print $htm_fh "</td></tr></table>\n\n";
1477   }
1478   ++${$row_sref} if $xls_fh;
1479
1480
1481   if (defined $m_data) {
1482     # write header
1483
1484     $title = "Top $name by volume";
1485
1486     printf $txt_fh ("%s\n%s\n%s", $title, "-" x length($title),$txt_col_headers) if $txt_fh;
1487
1488     if ($htm_fh) {
1489       print $htm_fh <<EoText;
1490 <hr><a name="$text volume"></a><h2>$title</h2>
1491 <table border=0 width="100%">
1492 <tr><td>
1493 <table border=1>
1494 EoText
1495     print $htm_fh $htm_col_headers;
1496     }
1497     if ($xls_fh) {
1498       $spreadsheet->write(${$row_sref}++, 0, $title, $f_header2);
1499       $spreadsheet->write(${$row_sref}++, 0, [@headers, $text], $f_headertab);
1500     }
1501
1502     @chartdatanames = ();
1503     @chartdatavals = ();
1504     $chartotherval = 0;
1505     my $use_gig = 0;
1506     foreach my $key (top_n_sort($topcount,$m_data_gigs,$m_data,$m_count)) {
1507       # The largest volume will be the first (top of the list).
1508       # If it has at least 1 gig, then just use gigabytes to avoid
1509       # risking an integer overflow when generating the pie charts.
1510       if ($$m_data_gigs{$key}) {
1511         $use_gig = 1;
1512       }
1513
1514       my $messages  = $$m_count{$key};
1515       my @content = ($messages);
1516       push(@content, $$a_count{$key}) if defined $a_count;
1517       my $rounded_volume = volume_rounded($$m_data{$key},$$m_data_gigs{$key});
1518       my($data ,$gigs) = (0,0);
1519       un_round($rounded_volume,\$data,\$gigs);
1520       my $rounded_average = volume_rounded($data/$messages,$gigs/$messages);
1521       push(@content, $rounded_volume, $rounded_average );
1522
1523       # write content
1524       printf $txt_fh ($txt_format, @content, $key) if $txt_fh;
1525       if ($htm_fh) {
1526         my $htmlkey = $key;
1527         $htmlkey =~ s/>/\&gt\;/g;
1528         $htmlkey =~ s/</\&lt\;/g;
1529         printf $htm_fh ($htm_format, @content, $htmlkey);
1530       }
1531       $spreadsheet->write(${$row_sref}++, 0, [@content, $key], $f_default) if $xls_fh;
1532
1533
1534       if (scalar @chartdatanames < $ntopchart) {
1535         if ($use_gig) {
1536           if ($$m_data_gigs{$key}) {
1537             push(@chartdatanames, $key);
1538             push(@chartdatavals, $$m_data_gigs{$key});
1539           }
1540         }
1541         else {
1542           push(@chartdatanames, $key);
1543           push(@chartdatavals, $$m_data{$key});
1544         }
1545       }
1546       else {
1547         $chartotherval += ($use_gig) ? $$m_data_gigs{$key} : $$m_data{$key};
1548       }
1549     }
1550     push(@chartdatanames, "Other");
1551     push(@chartdatavals, $chartotherval);
1552
1553     print $txt_fh "\n" if $txt_fh;
1554     if ($htm_fh) {
1555       print $htm_fh "</table>\n";
1556       print $htm_fh "</td><td>\n";
1557       if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals > 0)) {
1558         # calculate the graph
1559         my @data = (
1560            \@chartdatanames,
1561            \@chartdatavals
1562         );
1563         my $graph = GD::Graph::pie->new(300, 300);
1564         $graph->set(
1565             x_label           => 'Name',
1566             y_label           => 'Volume' ,
1567             title             => 'By Volume',
1568         );
1569         my $gd = $graph->plot(\@data) or warn($graph->error);
1570         if ($gd) {
1571           my $temp = $text;
1572           $temp =~ s/ /_/g;
1573           open(IMG, ">$chartdir/${temp}_volume.png") or die "Could not write $chartdir/${temp}_volume.png: $!\n";
1574           binmode IMG;
1575           print IMG $gd->png;
1576           close IMG;
1577           print $htm_fh "<img src=\"$chartrel/${temp}_volume.png\">";
1578         }
1579       }
1580       print $htm_fh "</td><td>\n";
1581       print $htm_fh "</td></tr></table>\n\n";
1582     }
1583
1584     ++${$row_sref} if $xls_fh;
1585   }
1586 }
1587
1588
1589 #######################################################################
1590 # top_n_sort();
1591 #
1592 #   @sorted_keys = top_n_sort($n,$href1,$href2,$href3);
1593 #
1594 # Given a hash which has numerical values, return the sorted $n keys which
1595 # point to the top values. The second and third hashes are used as
1596 # tiebreakers. They all must have the same keys.
1597 #
1598 # The idea behind this routine is that when you only want to see the
1599 # top n members of a set, rather than sorting the entire set and then
1600 # plucking off the top n, sort through the stack as you go, discarding
1601 # any member which is lower than your current n'th highest member.
1602 #
1603 # This proves to be an order of magnitude faster for large hashes.
1604 # On 200,000 lines of mainlog it benchmarked 9 times faster.
1605 # On 700,000 lines of mainlog it benchmarked 13.8 times faster.
1606 #
1607 # We assume the values are > 0.
1608 #######################################################################
1609 sub top_n_sort {
1610   my($n,$href1,$href2,$href3) = @_;
1611
1612   # PH's original sort was:
1613   #
1614   # foreach $key (sort
1615   #               {
1616   #               $$m_count{$b}     <=> $$m_count{$a} ||
1617   #               $$m_data_gigs{$b} <=> $$m_data_gigs{$a}  ||
1618   #               $$m_data{$b}      <=> $$m_data{$a}  ||
1619   #               $a cmp $b
1620   #               }
1621   #             keys %{$m_count})
1622   #
1623
1624   #We use a key of '_' to represent non-existant values, as null keys are valid.
1625   #'_' is not a valid domain, edomain, host, or email.
1626   my(@top_n_keys) = ('_') x $n;
1627   my($minimum_value1,$minimum_value2,$minimum_value3) = (0,0,0);
1628   my $top_n_key = '';
1629   my $n_minus_1 = $n - 1;
1630   my $n_minus_2 = $n - 2;
1631
1632   # Create a dummy hash incase the user has not provided us with
1633   # tiebreaker hashes.
1634   my(%dummy_hash);
1635   $href2 = \%dummy_hash unless defined $href2;
1636   $href3 = \%dummy_hash unless defined $href3;
1637
1638   # Pick out the top $n keys.
1639   my($key,$value1,$value2,$value3,$i,$comparison,$insert_position);
1640   while (($key,$value1) = each %$href1) {
1641
1642     #print STDERR "key $key ($value1,",$href2->{$key},",",$href3->{$key},") <=> ($minimum_value1,$minimum_value2,$minimum_value3)\n";
1643
1644     # Check to see that the new value is bigger than the lowest of the
1645     # top n keys that we're keeping. We test the main key first, because
1646     # for the majority of cases we can skip creating dummy hash values
1647     # should the user have not provided real tie-breaking hashes.
1648     next unless $value1 >= $minimum_value1;
1649
1650     # Create a dummy hash entry for the key if required.
1651     # Note that setting the dummy_hash value sets it for both href2 &
1652     # href3. Also note that currently we are guarenteed to have a real
1653     # value for href3 if a real value for href2 exists so don't need to
1654     # test for it as well.
1655     $dummy_hash{$key} = 0 unless exists $href2->{$key};
1656
1657     $comparison = $value1        <=> $minimum_value1 ||
1658                   $href2->{$key} <=> $minimum_value2 ||
1659                   $href3->{$key} <=> $minimum_value3 ||
1660                   $top_n_key cmp $key;
1661     next unless ($comparison == 1);
1662
1663     # As we will be using these values a few times, extract them into scalars.
1664     $value2 = $href2->{$key};
1665     $value3 = $href3->{$key};
1666
1667     # This key is bigger than the bottom n key, so the lowest position we
1668     # will insert it into is $n minus 1 (the bottom of the list).
1669     $insert_position = $n_minus_1;
1670
1671     # Now go through the list, stopping when we find a key that we're
1672     # bigger than, or we come to the penultimate position - we've
1673     # already tested bigger than the last.
1674     #
1675     # Note: we go top down as the list starts off empty.
1676     # Note: stepping through the list in this way benchmarks nearly
1677     # three times faster than doing a sort() on the reduced list.
1678     # I assume this is because the list is already in order, and
1679     # we get a performance boost from not having to do hash lookups
1680     # on the new key.
1681     for ($i = 0; $i < $n_minus_1; $i++) {
1682       $top_n_key = $top_n_keys[$i];
1683       if ( ($top_n_key eq '_') ||
1684            ( ($value1 <=> $href1->{$top_n_key} ||
1685               $value2 <=> $href2->{$top_n_key} ||
1686               $value3 <=> $href3->{$top_n_key} ||
1687               $top_n_key cmp $key) == 1
1688            )
1689          ) {
1690         $insert_position = $i;
1691         last;
1692       }
1693     }
1694
1695     # Remove the last element, then insert the new one.
1696     $#top_n_keys = $n_minus_2;
1697     splice(@top_n_keys,$insert_position,0,$key);
1698
1699     # Extract our new minimum values.
1700     $top_n_key = $top_n_keys[$n_minus_1];
1701     if ($top_n_key ne '_') {
1702       $minimum_value1 = $href1->{$top_n_key};
1703       $minimum_value2 = $href2->{$top_n_key};
1704       $minimum_value3 = $href3->{$top_n_key};
1705     }
1706   }
1707
1708   # Return the top n list, grepping out non-existant values, just in case
1709   # we didn't have that many values.
1710   return(grep(!/^_$/,@top_n_keys));
1711 }
1712
1713
1714
1715 #######################################################################
1716 # html_header();
1717 #
1718 #  $header = html_header($title);
1719 #
1720 # Print our HTML header and start the <body> block.
1721 #######################################################################
1722 sub html_header {
1723   my($title) = @_;
1724   my $text = << "EoText";
1725 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
1726 <html>
1727 <head>
1728 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-15">
1729 <title>$title</title>
1730 </head>
1731 <body bgcolor="white">
1732 <h1>$title</h1>
1733 EoText
1734   return $text;
1735 }
1736
1737
1738
1739 #######################################################################
1740 # help();
1741 #
1742 #  help();
1743 #
1744 # Display usage instructions and exit.
1745 #######################################################################
1746 sub help {
1747   print << "EoText";
1748
1749 eximstats Version $VERSION
1750
1751 Usage:
1752   eximstats [Output] [Options] mainlog1 mainlog2 ...
1753   eximstats -merge -html [Options] report.1.html ... > weekly_rep.html
1754
1755 Examples:
1756   eximstats -html=eximstats.html mainlog1 mainlog2 ...
1757   eximstats mainlog1 mainlog2 ... > report.txt
1758
1759 Parses exim mainlog or syslog files and generates a statistical analysis
1760 of the messages processed.
1761
1762 Valid output types are:
1763 -txt[=<file>]   plain text (default unless no other type is specified)
1764 -html[=<file>]  HTML
1765 -xls[=<file>]   Excel
1766 With no type and file given, defaults to -txt and STDOUT.
1767
1768 Valid options are:
1769 -h<number>      histogram divisions per hour. The default is 1, and
1770                 0 suppresses histograms. Other valid values are:
1771                 2, 3, 5, 10, 15, 20, 30 or 60.
1772 -ne             don't display error information
1773 -nr             don't display relaying information
1774 -nr/pattern/    don't display relaying information that matches
1775 -nt             don't display transport information
1776 -nt/pattern/    don't display transport information that matches
1777 -nvr            don't do volume rounding. Display in bytes, not KB/MB/GB.
1778 -t<number>      display top <number> sources/destinations
1779                 default is 50, 0 suppresses top listing
1780 -tnl            omit local sources/destinations in top listing
1781 -t_remote_users show top user sources/destinations from non-local domains
1782 -q<list>        list of times for queuing information. -q0 suppresses.
1783 -show_rt<list>  Show the receipt times for all the messages.
1784 -show_dt<list>  Show the delivery times for all the messages.
1785                 <list> is an optional list of times in seconds.
1786                 Eg -show_rt1,2,4,8.
1787
1788 -include_original_destination   show both the final and original
1789                 destinations in the results rather than just the final ones.
1790
1791 -byhost         show results by sending host (default unless bydomain or
1792                 byemail is specified)
1793 -bydomain       show results by sending domain.
1794 -byemail        show results by sender's email address
1795 -byedomain      show results by sender's email domain
1796 -bylocaldomain  show results by local domain
1797
1798 -pattern "Description" /pattern/
1799                 Count lines matching specified patterns and show them in
1800                 the results. It can be specified multiple times. Eg:
1801                 -pattern 'Refused connections' '/refused connection/'
1802
1803 -merge          merge previously generated reports into a new report
1804
1805 -charts         Create charts (this requires the GD::Graph modules).
1806                 Only valid with -html.
1807 -chartdir <dir> Create the charts' png files in the directory <dir>
1808 -chartrel <dir> Specify the relative directory for the "img src=" tags
1809                 from where to include the charts in the html file
1810                 -chartdir and -chartrel default to '.'
1811
1812 -emptyok        It is OK if there is no valid input, don't print an error.
1813
1814 -d              Debug mode - dump the eval'ed parser onto STDERR.
1815
1816 EoText
1817
1818   exit 1;
1819 }
1820
1821
1822
1823 #######################################################################
1824 # generate_parser();
1825 #
1826 #  $parser = generate_parser();
1827 #
1828 # This subroutine generates the parsing routine which will be
1829 # used to parse the mainlog. We take the base operation, and remove bits not in use.
1830 # This improves performance depending on what bits you take out or add.
1831 #
1832 # I've tested using study(), but this does not improve performance.
1833 #
1834 # We store our parsing routing in a variable, and process it looking for #IFDEF (Expression)
1835 # or #IFNDEF (Expression) statements and corresponding #ENDIF (Expression) statements. If
1836 # the expression evaluates to true, then it is included/excluded accordingly.
1837 #######################################################################
1838 sub generate_parser {
1839   my $parser = '
1840   my($ip,$host,$email,$edomain,$domain,$thissize,$size,$old,$new);
1841   my($tod,$m_hour,$m_min,$id,$flag,$extra,$length);
1842   my($seconds,$queued,$rcpt_time,$local_domain);
1843   my $rej_id = 0;
1844   while (<$fh>) {
1845
1846     # Convert syslog lines to mainlog format.
1847     if (! /^\\d{4}/) {
1848       next unless s/^.*? exim\\b.*?: //;
1849     }
1850
1851     $length = length($_);
1852     next if ($length < 38);
1853     next unless /^(\\d{4}\\-\\d\\d-\\d\\d\\s(\\d\\d):(\\d\\d):\\d\\d( [-+]\\d\\d\\d\\d)?)( \\[\\d+\\])?/o;
1854
1855     ($tod,$m_hour,$m_min) = ($1,$2,$3);
1856
1857     # PH - watch for GMT offsets in the timestamp.
1858     if (defined($4)) {
1859       $extra = 6;
1860       next if ($length < 44);
1861     }
1862     else {
1863       $extra = 0;
1864     }
1865
1866     # PH - watch for PID added after the timestamp.
1867     if (defined($5)) {
1868       $extra += length($5);
1869       next if ($length < 38 + $extra);
1870     }
1871
1872     $id   = substr($_, 20 + $extra, 16);
1873     $flag = substr($_, 37 + $extra, 2);
1874
1875     if ($flag !~ /^([<>=*-]+|SA)$/ && /rejected|refused|dropped/) {
1876       $flag = "Re";
1877       $extra -= 3;
1878     }
1879
1880     # Rejects can have no MSGID...
1881     if ($flag eq "Re" && $id !~ /^[-0-9a-zA-Z]+$/) {
1882       $id   = "reject:" . ++$rej_id;
1883       $extra -= 17;
1884     }
1885 ';
1886
1887   # Watch for user specified patterns.
1888   my $user_pattern_index = 0;
1889   foreach (@user_patterns) {
1890     $user_pattern_totals[$user_pattern_index] = 0;
1891     $parser .= "    if ($_) {\n";
1892     $parser .= "      \$user_pattern_totals[$user_pattern_index]++;\n";
1893     $parser .= "      \$user_pattern_interval_count[$user_pattern_index][(\$m_hour*60 + \$m_min)/$hist_interval]++;\n" if ($hist_opt > 0);
1894     $parser .= "    }\n";
1895     $user_pattern_index++;
1896   }
1897
1898   $parser .= '
1899     next unless ($flag =~ /<=|=>|->|==|\\*\\*|Co|SA|Re/);
1900
1901     #Strip away the timestamp, ID and flag to speed up later pattern matches.
1902     #The flags include Co (Completed), Re (Rejected), and SA (SpamAssassin).
1903     $_ = substr($_, 40 + $extra);  # PH
1904
1905     # Alias @message to the array of information about the message.
1906     # This minimises the number of calls to hash functions.
1907     $messages{$id} = [] unless exists $messages{$id};
1908     *message = $messages{$id};
1909
1910
1911     # JN - Skip over certain transports as specified via the "-nt/.../" command
1912     # line switch (where ... is a perl style regular expression).  This is
1913     # required so that transports that skew stats such as SpamAssassin can be
1914     # ignored.
1915     #IFDEF ($transport_pattern)
1916     if (/\\sT=(\\S+)/) {
1917        next if ($1 =~ /$transport_pattern/o) ;
1918     }
1919     #ENDIF ($transport_pattern)
1920
1921
1922
1923     # Do some pattern matches to get the host and IP address.
1924     # We expect lines to be of the form "H=[IpAddr]" or "H=Host [IpAddr]" or
1925     # "H=Host (UnverifiedHost) [IpAddr]" or "H=(UnverifiedHost) [IpAddr]".
1926     # We do 2 separate matches to keep the matches simple and fast.
1927     # Host is local unless otherwise specified.
1928     $ip = (/\\bH=.*?(\\[[^]]+\\])/) ? $1
1929      # 2008-03-31 06:25:22 Connection from [213.246.33.217]:39456 refused: too many connections from that IP address // .hs
1930      : (/Connection from (\[\S+\])/) ? $1
1931      # 2008-03-31 06:52:40 SMTP call from mail.cacoshrf.com (ccsd02.ccsd.local) [69.24.118.229]:4511 dropped: too many nonmail commands (last was "RSET") // .hs
1932      : (/SMTP call from .*?(\[\S+\])/) ? $1
1933      : "local";
1934     $host = (/\\bH=(\\S+)/) ? $1 : "local";
1935
1936     $domain = "localdomain";  #Domain is localdomain unless otherwise specified.
1937
1938     #IFDEF ($do_sender{Domain})
1939     if ($host =~ /^\\[/ || $host =~ /^[\\d\\.]+$/) {
1940       # Host is just an IP address.
1941       $domain = $host;
1942     }
1943     elsif ($host =~ /^(\\(?)[^\\.]+\\.([^\\.]+\\..*)/) {
1944       # Remove the host portion from the DNS name. We ensure that we end up
1945       # with at least xxx.yyy. $host can be "(x.y.z)" or  "x.y.z".
1946       $domain = lc("$1.$2");
1947       $domain =~ s/^\\.//;         #Remove preceding dot.
1948     }
1949     #ENDIF ($do_sender{Domain})
1950
1951     #IFDEF ($do_sender{Email})
1952       #IFDEF ($include_original_destination)
1953       # Catch both "a@b.com <c@d.com>" and "e@f.com"
1954       #$email = (/^(\S+) (<(\S*?)>)?/) ? $3 || $1 : "";
1955       $email = (/^(\S+ (<[^@>]+@?[^>]*>)?)/) ? $1 : "";
1956       chomp($email);
1957       #ENDIF ($include_original_destination)
1958
1959       #IFNDEF ($include_original_destination)
1960       $email = (/^(\S+)/) ? $1 : "";
1961       #ENDIF ($include_original_destination)
1962     #ENDIF ($do_sender{Email})
1963
1964     #IFDEF ($do_sender{Edomain})
1965       if (/^(<>|blackhole)/) {
1966         $edomain = $1;
1967       }
1968       #IFDEF ($include_original_destination)
1969         elsif (/^(\S+ (<\S*?\\@(\S+?)>)?)/) {
1970           $edomain = $1;
1971           chomp($edomain);
1972           $edomain =~ s/@(\S+?)>/"@" . lc($1) . ">"/e;
1973         }
1974       #ENDIF ($include_original_destination)
1975       #IFNDEF ($include_original_destination)
1976         elsif (/^\S*?\\@(\S+)/) {
1977           $edomain = lc($1);
1978         }
1979       #ENDIF ($include_original_destination)
1980       else {
1981         $edomain = "";
1982       }
1983
1984     #ENDIF ($do_sender{Edomain})
1985
1986     if ($tod lt $begin) {
1987       $begin = $tod;
1988     }
1989     elsif ($tod gt $end) {
1990       $end   = $tod;
1991     }
1992
1993
1994     if ($flag eq "<=") {
1995       $thissize = (/\\sS=(\\d+)( |$)/) ? $1 : 0;
1996       $message[$SIZE] = $thissize;
1997       $message[$PROTOCOL] = (/ P=(\S+)/) ? $1 : undef;
1998
1999       #IFDEF ($show_relay)
2000       if ($host ne "local") {
2001         # Save incoming information in case it becomes interesting
2002         # later, when delivery lines are read.
2003         my($from) = /^(\\S+)/;
2004         $message[$FROM_HOST]    = "$host$ip";
2005         $message[$FROM_ADDRESS] = $from;
2006       }
2007       #ENDIF ($show_relay)
2008
2009       #IFDEF ($local_league_table || $include_remote_users)
2010         if (/\sU=(\\S+)/) {
2011           my $user = $1;
2012
2013           #IFDEF ($local_league_table && $include_remote_users)
2014           {                         #Store both local and remote users.
2015           #ENDIF ($local_league_table && $include_remote_users)
2016
2017           #IFDEF ($local_league_table && ! $include_remote_users)
2018           if ($host eq "local") {   #Store local users only.
2019           #ENDIF ($local_league_table && ! $include_remote_users)
2020
2021           #IFDEF ($include_remote_users && ! $local_league_table)
2022           if ($host ne "local") {   #Store remote users only.
2023           #ENDIF ($include_remote_users && ! $local_league_table)
2024
2025             ++$received_count_user{$user};
2026             add_volume(\\$received_data_user{$user},\\$received_data_gigs_user{$user},$thissize);
2027           }
2028         }
2029       #ENDIF ($local_league_table || $include_remote_users)
2030
2031       #IFDEF ($do_sender{Host})
2032         ++$received_count{Host}{$host};
2033         add_volume(\\$received_data{Host}{$host},\\$received_data_gigs{Host}{$host},$thissize);
2034       #ENDIF ($do_sender{Host})
2035
2036       #IFDEF ($do_sender{Domain})
2037         if ($domain) {
2038           ++$received_count{Domain}{$domain};
2039           add_volume(\\$received_data{Domain}{$domain},\\$received_data_gigs{Domain}{$domain},$thissize);
2040         }
2041       #ENDIF ($do_sender{Domain})
2042
2043       #IFDEF ($do_sender{Email})
2044         ++$received_count{Email}{$email};
2045         add_volume(\\$received_data{Email}{$email},\\$received_data_gigs{Email}{$email},$thissize);
2046       #ENDIF ($do_sender{Email})
2047
2048       #IFDEF ($do_sender{Edomain})
2049         ++$received_count{Edomain}{$edomain};
2050         add_volume(\\$received_data{Edomain}{$edomain},\\$received_data_gigs{Edomain}{$edomain},$thissize);
2051       #ENDIF ($do_sender{Edomain})
2052
2053       ++$total_received_count;
2054       add_volume(\\$total_received_data,\\$total_received_data_gigs,$thissize);
2055
2056       #IFDEF ($#queue_times >= 0 || $#rcpt_times >= 0)
2057         $message[$ARRIVAL_TIME] = $tod;
2058       #ENDIF ($#queue_times >= 0 || $#rcpt_times >= 0)
2059
2060       #IFDEF ($hist_opt > 0)
2061         $received_interval_count[($m_hour*60 + $m_min)/$hist_interval]++;
2062       #ENDIF ($hist_opt > 0)
2063     }
2064
2065     elsif ($flag eq "=>") {
2066       $size = $message[$SIZE] || 0;
2067       if ($host ne "local") {
2068         $message[$REMOTE_DELIVERED] = 1;
2069
2070
2071         #IFDEF ($show_relay)
2072         # Determine relaying address if either only one address listed,
2073         # or two the same. If they are different, it implies a forwarding
2074         # or aliasing, which is not relaying. Note that for multi-aliased
2075         # addresses, there may be a further address between the first
2076         # and last.
2077
2078         if (defined $message[$FROM_HOST]) {
2079           if (/^(\\S+)(?:\\s+\\([^)]\\))?\\s+<([^>]+)>/) {
2080             ($old,$new) = ($1,$2);
2081           }
2082           else {
2083             $old = $new = "";
2084           }
2085
2086           if ("\\L$new" eq "\\L$old") {
2087             ($old) = /^(\\S+)/ if $old eq "";
2088             my $key = "H=\\L$message[$FROM_HOST]\\E A=\\L$message[$FROM_ADDRESS]\\E => " .
2089               "H=\\L$host\\E$ip A=\\L$old\\E";
2090             if (!defined $relay_pattern || $key !~ /$relay_pattern/o) {
2091               $relayed{$key} = 0 if !defined $relayed{$key};
2092               ++$relayed{$key};
2093             }
2094             else {
2095               ++$relayed_unshown;
2096             }
2097           }
2098         }
2099         #ENDIF ($show_relay)
2100
2101       }
2102
2103       #IFDEF ($local_league_table || $include_remote_users)
2104         #IFDEF ($local_league_table && $include_remote_users)
2105         {                         #Store both local and remote users.
2106         #ENDIF ($local_league_table && $include_remote_users)
2107
2108         #IFDEF ($local_league_table && ! $include_remote_users)
2109         if ($host eq "local") {   #Store local users only.
2110         #ENDIF ($local_league_table && ! $include_remote_users)
2111
2112         #IFDEF ($include_remote_users && ! $local_league_table)
2113         if ($host ne "local") {   #Store remote users only.
2114         #ENDIF ($include_remote_users && ! $local_league_table)
2115
2116           if (my($user) = split((/\\s</)? " <" : " ", $_)) {
2117             #IFDEF ($include_original_destination)
2118             {
2119             #ENDIF ($include_original_destination)
2120             #IFNDEF ($include_original_destination)
2121             if ($user =~ /^[\\/|]/) {
2122             #ENDIF ($include_original_destination)
2123               #my($parent) = $_ =~ /(<[^@]+@?[^>]*>)/;
2124               my($parent) = $_ =~ / (<.+?>) /;              #DT 1.54
2125               if (defined $parent) {
2126                 $user = "$user $parent";
2127                 #IFDEF ($do_local_domain)
2128                 if ($parent =~ /\\@(.+)>/) {
2129                   $local_domain = lc($1);
2130                   ++$delivered_messages_local_domain{$local_domain};
2131                   ++$delivered_addresses_local_domain{$local_domain};
2132                   add_volume(\\$delivered_data_local_domain{$local_domain},\\$delivered_data_gigs_local_domain{$local_domain},$size);
2133                 }
2134                 #ENDIF ($do_local_domain)
2135               }
2136             }
2137             ++$delivered_messages_user{$user};
2138             ++$delivered_addresses_user{$user};
2139             add_volume(\\$delivered_data_user{$user},\\$delivered_data_gigs_user{$user},$size);
2140           }
2141         }
2142       #ENDIF ($local_league_table || $include_remote_users)
2143
2144       #IFDEF ($do_sender{Host})
2145         $delivered_messages{Host}{$host}++;
2146         $delivered_addresses{Host}{$host}++;
2147         add_volume(\\$delivered_data{Host}{$host},\\$delivered_data_gigs{Host}{$host},$size);
2148       #ENDIF ($do_sender{Host})
2149       #IFDEF ($do_sender{Domain})
2150         if ($domain) {
2151           ++$delivered_messages{Domain}{$domain};
2152           ++$delivered_addresses{Domain}{$domain};
2153           add_volume(\\$delivered_data{Domain}{$domain},\\$delivered_data_gigs{Domain}{$domain},$size);
2154         }
2155       #ENDIF ($do_sender{Domain})
2156       #IFDEF ($do_sender{Email})
2157         ++$delivered_messages{Email}{$email};
2158         ++$delivered_addresses{Email}{$email};
2159         add_volume(\\$delivered_data{Email}{$email},\\$delivered_data_gigs{Email}{$email},$size);
2160       #ENDIF ($do_sender{Email})
2161       #IFDEF ($do_sender{Edomain})
2162         ++$delivered_messages{Edomain}{$edomain};
2163         ++$delivered_addresses{Edomain}{$edomain};
2164         add_volume(\\$delivered_data{Edomain}{$edomain},\\$delivered_data_gigs{Edomain}{$edomain},$size);
2165       #ENDIF ($do_sender{Edomain})
2166
2167       ++$total_delivered_messages;
2168       ++$total_delivered_addresses;
2169       add_volume(\\$total_delivered_data,\\$total_delivered_data_gigs,$size);
2170
2171       #IFDEF ($show_transport)
2172         my $transport = (/\\sT=(\\S+)/) ? $1 : ":blackhole:";
2173         ++$transported_count{$transport};
2174         add_volume(\\$transported_data{$transport},\\$transported_data_gigs{$transport},$size);
2175       #ENDIF ($show_transport)
2176
2177       #IFDEF ($hist_opt > 0)
2178         $delivered_interval_count[($m_hour*60 + $m_min)/$hist_interval]++;
2179       #ENDIF ($hist_opt > 0)
2180
2181       #IFDEF ($#delivery_times > 0)
2182         if (/ DT=(\S+)/) {
2183           $seconds = wdhms_seconds($1);
2184           for ($i = 0; $i <= $#delivery_times; $i++) {
2185             if ($seconds < $delivery_times[$i]) {
2186               ++$dt_all_bin[$i];
2187               ++$dt_remote_bin[$i] if $message[$REMOTE_DELIVERED];
2188               last;
2189             }
2190           }
2191           if ($i > $#delivery_times) {
2192             ++$dt_all_overflow;
2193             ++$dt_remote_overflow if $message[$REMOTE_DELIVERED];
2194           }
2195         }
2196       #ENDIF ($#delivery_times > 0)
2197
2198     }
2199
2200     elsif ($flag eq "->") {
2201
2202       #IFDEF ($local_league_table || $include_remote_users)
2203         #IFDEF ($local_league_table && $include_remote_users)
2204         {                         #Store both local and remote users.
2205         #ENDIF ($local_league_table && $include_remote_users)
2206
2207         #IFDEF ($local_league_table && ! $include_remote_users)
2208         if ($host eq "local") {   #Store local users only.
2209         #ENDIF ($local_league_table && ! $include_remote_users)
2210
2211         #IFDEF ($include_remote_users && ! $local_league_table)
2212         if ($host ne "local") {   #Store remote users only.
2213         #ENDIF ($include_remote_users && ! $local_league_table)
2214
2215           if (my($user) = split((/\\s</)? " <" : " ", $_)) {
2216             #IFDEF ($include_original_destination)
2217             {
2218             #ENDIF ($include_original_destination)
2219             #IFNDEF ($include_original_destination)
2220             if ($user =~ /^[\\/|]/) {
2221             #ENDIF ($include_original_destination)
2222               #my($parent) = $_ =~ /(<[^@]+@?[^>]*>)/;
2223               my($parent) = $_ =~ / (<.+?>) /;              #DT 1.54
2224               $user = "$user $parent" if defined $parent;
2225             }
2226             ++$delivered_addresses_user{$user};
2227           }
2228         }
2229       #ENDIF ($local_league_table || $include_remote_users)
2230
2231       #IFDEF ($do_sender{Host})
2232         $delivered_addresses{Host}{$host}++;
2233       #ENDIF ($do_sender{Host})
2234       #IFDEF ($do_sender{Domain})
2235         if ($domain) {
2236           ++$delivered_addresses{Domain}{$domain};
2237         }
2238       #ENDIF ($do_sender{Domain})
2239       #IFDEF ($do_sender{Email})
2240         ++$delivered_addresses{Email}{$email};
2241       #ENDIF ($do_sender{Email})
2242       #IFDEF ($do_sender{Edomain})
2243         ++$delivered_addresses{Edomain}{$edomain};
2244       #ENDIF ($do_sender{Edomain})
2245
2246       ++$total_delivered_addresses;
2247     }
2248
2249     elsif ($flag eq "==" && defined($message[$SIZE]) && !defined($message[$DELAYED])) {
2250       ++$delayed_count;
2251       $message[$DELAYED] = 1;
2252     }
2253
2254     elsif ($flag eq "**") {
2255       if (defined ($message[$SIZE])) {
2256         unless (defined $message[$HAD_ERROR]) {
2257           ++$message_errors;
2258           $message[$HAD_ERROR] = 1;
2259         }
2260       }
2261
2262       #IFDEF ($show_errors)
2263         ++$errors_count{$_};
2264       #ENDIF ($show_errors)
2265
2266     }
2267
2268     elsif ($flag eq "Co") {
2269       #Completed?
2270       #IFDEF ($#queue_times >= 0)
2271         $queued = queue_time($tod, $message[$ARRIVAL_TIME], $id);
2272
2273         for ($i = 0; $i <= $#queue_times; $i++) {
2274           if ($queued < $queue_times[$i]) {
2275             ++$qt_all_bin[$i];
2276             ++$qt_remote_bin[$i] if $message[$REMOTE_DELIVERED];
2277             last;
2278           }
2279         }
2280         if ($i > $#queue_times) {
2281           ++$qt_all_overflow;
2282           ++$qt_remote_overflow if $message[$REMOTE_DELIVERED];
2283         }
2284       #ENDIF ($#queue_times >= 0)
2285
2286       #IFDEF ($#rcpt_times >= 0)
2287         if (/ QT=(\S+)/) {
2288           $seconds = wdhms_seconds($1);
2289           #Calculate $queued if not previously calculated above.
2290           #IFNDEF ($#queue_times >= 0)
2291             $queued = queue_time($tod, $message[$ARRIVAL_TIME], $id);
2292           #ENDIF ($#queue_times >= 0)
2293           $rcpt_time = $seconds - $queued;
2294           my($protocol);
2295
2296           if (defined $message[$PROTOCOL]) {
2297             $protocol = $message[$PROTOCOL];
2298
2299             # Create the bin if its not already defined.
2300             unless (exists $rcpt_times_bin{$protocol}) {
2301               initialise_rcpt_times($protocol);
2302             }
2303           }
2304
2305
2306           for ($i = 0; $i <= $#rcpt_times; ++$i) {
2307             if ($rcpt_time < $rcpt_times[$i]) {
2308               ++$rcpt_times_bin{all}[$i];
2309               ++$rcpt_times_bin{$protocol}[$i] if defined $protocol;
2310               last;
2311             }
2312           }
2313
2314           if ($i > $#rcpt_times) {
2315             ++$rcpt_times_overflow{all};
2316             ++$rcpt_times_overflow{$protocol} if defined $protocol;
2317           }
2318         }
2319       #ENDIF ($#rcpt_times >= 0)
2320
2321       delete($messages{$id});
2322     }
2323     elsif ($flag eq "SA") {
2324       $ip = (/From.*?(\\[[^]]+\\])/ || /\\((local)\\)/) ? $1 : "";
2325       #SpamAssassin message
2326       if (/Action: ((permanently|temporarily) rejected message|flagged as Spam but accepted): score=(\d+\.\d)/) {
2327         #add_volume(\\$spam_score,\\$spam_score_gigs,$3);
2328         ++$spam_count_by_ip{$ip};
2329       } elsif (/Action: scanned but message isn\'t spam: score=(-?\d+\.\d)/) {
2330         #add_volume(\\$ham_score,\\$ham_score_gigs,$1);
2331         ++$ham_count_by_ip{$ip};
2332       } elsif (/(Not running SA because SAEximRunCond expanded to false|check skipped due to message size)/) {
2333         ++$ham_count_by_ip{$ip};
2334       }
2335     }
2336
2337     # Look for Reject messages or blackholed messages (deliveries
2338     # without a transport)
2339     if ($flag eq "Re" || ($flag eq "=>" && ! /\\sT=\\S+/)) {
2340       # Correct the IP address for rejects:
2341       # rejected EHLO from my.test.net [10.0.0.5]: syntactically invalid argument(s):
2342       # rejected EHLO from [10.0.0.6]: syntactically invalid argument(s):
2343       $ip = $1 if ($ip eq "local" && /^rejected [HE][HE]LO from .*?(\[.+?\]):/);
2344       if (/SpamAssassin/) {
2345         ++$rejected_count_by_reason{"Rejected by SpamAssassin"};
2346         ++$rejected_count_by_ip{$ip};
2347       }
2348       elsif (
2349         /(temporarily rejected [A-Z]*) .*?(: .*?)(:|\s*$)/
2350         ) {
2351         ++$temporarily_rejected_count_by_reason{"\u$1$2"};
2352         ++$temporarily_rejected_count_by_ip{$ip};
2353       }
2354       elsif (
2355         /(temporarily refused connection)/
2356         ) {
2357         ++$temporarily_rejected_count_by_reason{"\u$1"};
2358         ++$temporarily_rejected_count_by_ip{$ip};
2359       }
2360       elsif (
2361         /(listed at [^ ]+)/ ||
2362         /(Forged IP detected in HELO)/ ||
2363         /(Invalid domain or IP given in HELO\/EHLO)/ ||
2364         /(unqualified recipient rejected)/ ||
2365         /(closed connection (after|in response) .*?)\s*$/ ||
2366         /(sender rejected)/ ||
2367         # 2005-09-23 15:07:49 1EInHJ-0007Ex-Au H=(a.b.c) [10.0.0.1] F=<> rejected after DATA: This message contains a virus: (Eicar-Test-Signature) please scan your system.
2368         # 2005-10-06 10:50:07 1ENRS3-0000Nr-Kt => blackhole (DATA ACL discarded recipients): This message contains a virus: (Worm.SomeFool.P) please scan your system.
2369         / rejected after DATA: (.*)/ ||
2370         /.DATA ACL discarded recipients.: (.*)/ ||
2371         /rejected after DATA: (unqualified address not permitted)/ ||
2372         /(VRFY rejected)/ ||
2373 #        /(sender verify (defer|fail))/i ||
2374         /(too many recipients)/ ||
2375         /(refused relay.*?) to/ ||
2376         /(rejected by non-SMTP ACL: .*)/ ||
2377         /(rejected by local_scan.*)/ ||
2378         # SMTP call from %s dropped: too many syntax or protocol errors (last command was "%s"
2379         # SMTP call from %s dropped: too many nonmail commands
2380         /(dropped: too many ((nonmail|unrecognized) commands|syntax or protocol errors))/ ||
2381
2382         # local_scan() function crashed with signal %d - message temporarily rejected
2383         # local_scan() function timed out - message temporarily rejected
2384         /(local_scan.. function .* - message temporarily rejected)/ ||
2385         # SMTP protocol synchronization error (input sent without waiting for greeting): rejected connection from %s
2386         /(SMTP protocol .*?(error|violation))/ ||
2387         /(message too big)/
2388         ) {
2389         ++$rejected_count_by_reason{"\u$1"};
2390         ++$rejected_count_by_ip{$ip};
2391       }
2392       elsif (/rejected [HE][HE]LO from [^:]*: syntactically invalid argument/) {
2393         ++$rejected_count_by_reason{"Rejected HELO/EHLO: syntactically invalid argument"};
2394         ++$rejected_count_by_ip{$ip};
2395       }
2396       elsif (/response to "RCPT TO.*? was: (.*)/) {
2397         ++$rejected_count_by_reason{"Response to RCPT TO was: $1"};
2398         ++$rejected_count_by_ip{$ip};
2399       }
2400       elsif (
2401         /(lookup of host )\S+ (failed)/ ||
2402
2403         # rejected from <%s>%s%s%s%s: message too big:
2404         /(rejected [A-Z]*) .*?(: .*?)(:|\s*$)/ ||
2405         # refused connection from %s (host_reject_connection)
2406         # refused connection from %s (tcp wrappers)
2407         /(refused connection )from.*? (\(.*)/ ||
2408
2409         # error from remote mailer after RCPT TO:<a@b.c>: host a.b.c [10.0.0.1]: 450 <a@b.c>: Recipient address rejected: Greylisted for 60 seconds
2410         # error from remote mailer after MAIL FROM:<> SIZE=3468: host a.b.c [10.0.0.1]: 421 a.b.c has refused your connection because your server did not have a PTR record.
2411         /(error from remote mailer after .*?:).*(: .*?)(:|\s*$)/ ||
2412
2413         # a.b.c F=<a@b.c> rejected after DATA: "@" or "." expected after "Undisclosed-Recipient": failing address in "To" header is: <Undisclosed-Recipient:;>
2414         /rejected after DATA: ("." or "." expected).*?(: failing address in .*? header)/ ||
2415
2416         # connection from %s refused load average = %.2f
2417         /(Connection )from.*? (refused: load average)/ ||
2418         # connection from %s refused (IP options)
2419         # Connection from %s refused: too many connections
2420         # connection from %s refused
2421         /([Cc]onnection )from.*? (refused.*)/ ||
2422         # [10.0.0.1]: connection refused
2423         /: (Connection refused)()/
2424         ) {
2425         ++$rejected_count_by_reason{"\u$1$2"};
2426         ++$rejected_count_by_ip{$ip};
2427       }
2428       elsif (
2429         # 2008-03-31 06:25:22 H=mail.densitron.com [216.70.140.224]:45386 temporarily rejected connection in "connect" ACL: too fast reconnects // .hs
2430         # 2008-03-31 06:25:22 H=mail.densitron.com [216.70.140.224]:45386 temporarily rejected connection in "connect" ACL // .hs
2431         /(temporarily rejected connection in .*?ACL:?.*)/
2432         ) {
2433         ++$temporarily_rejected_count_by_ip{$ip};
2434         ++$temporarily_rejected_count_by_reason{"\u$1"};
2435       }
2436       else {
2437         ++$rejected_count_by_reason{Unknown};
2438         ++$rejected_count_by_ip{$ip};
2439         print STDERR "Unknown rejection: $_" if $debug;
2440       }
2441     }
2442   }';
2443
2444   # We now do a 'C preprocessor style operation on our parser
2445   # to remove bits not in use.
2446   my(%defines_in_operation,$removing_lines,$processed_parser);
2447   foreach (split (/\n/,$parser)) {
2448     if ((/^\s*#\s*IFDEF\s*\((.*?)\)/i  && ! eval $1) ||
2449         (/^\s*#\s*IFNDEF\s*\((.*?)\)/i &&   eval $1)    ) {
2450       $defines_in_operation{$1} = 1;
2451       $removing_lines = 1;
2452     }
2453
2454     # Convert constants.
2455     while (/(\$[A-Z][A-Z_]*)\b/) {
2456       my $constant = eval $1;
2457       s/(\$[A-Z][A-Z_]*)\b/$constant/;
2458     }
2459
2460     $processed_parser .= $_."\n" unless $removing_lines;
2461
2462     if (/^\s*#\s*ENDIF\s*\((.*?)\)/i) {
2463       delete $defines_in_operation{$1};
2464       unless (keys %defines_in_operation) {
2465         $removing_lines = 0;
2466       }
2467     }
2468   }
2469   print STDERR "# START OF PARSER:$processed_parser\n# END OF PARSER\n\n" if $debug;
2470
2471   return $processed_parser;
2472 }
2473
2474
2475
2476 #######################################################################
2477 # parse();
2478 #
2479 #  parse($parser,\*FILEHANDLE);
2480 #
2481 # This subroutine accepts a parser and a filehandle from main and parses each
2482 # line. We store the results into global variables.
2483 #######################################################################
2484 sub parse {
2485   my($parser,$fh) = @_;
2486
2487   if ($merge_reports) {
2488     parse_old_eximstat_reports($fh);
2489   }
2490   else {
2491     eval $parser;
2492     die ($@) if $@;
2493   }
2494
2495 }
2496
2497
2498
2499 #######################################################################
2500 # print_header();
2501 #
2502 #  print_header();
2503 #
2504 # Print our headers and contents.
2505 #######################################################################
2506 sub print_header {
2507
2508
2509   my $title = "Exim statistics from $begin to $end";
2510
2511   print $txt_fh "\n$title\n" if $txt_fh;
2512   if ($htm_fh) {
2513     print $htm_fh html_header($title);
2514     print $htm_fh "<ul>\n";
2515     print $htm_fh "<li><a href=\"#Grandtotal\">Grand total summary</a>\n";
2516     print $htm_fh "<li><a href=\"#Patterns\">User Specified Patterns</a>\n" if @user_patterns;
2517     print $htm_fh "<li><a href=\"#Transport\">Deliveries by Transport</a>\n" if $show_transport;
2518     if ($hist_opt) {
2519       print $htm_fh "<li><a href=\"#Messages received\">Messages received per hour</a>\n";
2520       print $htm_fh "<li><a href=\"#Deliveries\">Deliveries per hour</a>\n";
2521     }
2522
2523     if ($#queue_times >= 0) {
2524       print $htm_fh "<li><a href=\"#Time spent on the queue all messages\">Time spent on the queue: all messages</a>\n";
2525       print $htm_fh "<li><a href=\"#Time spent on the queue messages with at least one remote delivery\">Time spent on the queue: messages with at least one remote delivery</a>\n";
2526     }
2527
2528     if ($#delivery_times >= 0) {
2529       print $htm_fh "<li><a href=\"#Delivery times all messages\">Delivery times: all messages</a>\n";
2530       print $htm_fh "<li><a href=\"#Delivery times messages with at least one remote delivery\">Delivery times: messages with at least one remote delivery</a>\n";
2531     }
2532
2533     if ($#rcpt_times >= 0) {
2534       print $htm_fh "<li><a href=\"#Receipt times all messages\">Receipt times</a>\n";
2535     }
2536
2537     print $htm_fh "<li><a href=\"#Relayed messages\">Relayed messages</a>\n" if $show_relay;
2538     if ($topcount) {
2539       print $htm_fh "<li><a href=\"#Mail rejection reason count\">Top $topcount mail rejection reasons by message count</a>\n" if %rejected_count_by_reason;
2540       foreach ('Host','Domain','Email','Edomain') {
2541         next unless $do_sender{$_};
2542         print $htm_fh "<li><a href=\"#Sending \l$_ count\">Top $topcount sending \l${_}s by message count</a>\n";
2543         print $htm_fh "<li><a href=\"#Sending \l$_ volume\">Top $topcount sending \l${_}s by volume</a>\n";
2544       }
2545       if (($local_league_table || $include_remote_users) && %received_count_user) {
2546         print $htm_fh "<li><a href=\"#Local sender count\">Top $topcount local senders by message count</a>\n";
2547         print $htm_fh "<li><a href=\"#Local sender volume\">Top $topcount local senders by volume</a>\n";
2548       }
2549       foreach ('Host','Domain','Email','Edomain') {
2550         next unless $do_sender{$_};
2551         print $htm_fh "<li><a href=\"#$_ destination count\">Top $topcount \l$_ destinations by message count</a>\n";
2552         print $htm_fh "<li><a href=\"#$_ destination volume\">Top $topcount \l$_ destinations by volume</a>\n";
2553       }
2554       if (($local_league_table || $include_remote_users) && %delivered_messages_user) {
2555         print $htm_fh "<li><a href=\"#Local destination count\">Top $topcount local destinations by message count</a>\n";
2556         print $htm_fh "<li><a href=\"#Local destination volume\">Top $topcount local destinations by volume</a>\n";
2557       }
2558       if (($local_league_table || $include_remote_users) && %delivered_messages_local_domain) {
2559         print $htm_fh "<li><a href=\"#Local domain destination count\">Top $topcount local domain destinations by message count</a>\n";
2560         print $htm_fh "<li><a href=\"#Local domain destination volume\">Top $topcount local domain destinations by volume</a>\n";
2561       }
2562
2563       print $htm_fh "<li><a href=\"#Rejected ip count\">Top $topcount rejected ips by message count</a>\n" if %rejected_count_by_ip;
2564       print $htm_fh "<li><a href=\"#Temporarily rejected ip count\">Top $topcount temporarily rejected ips by message count</a>\n" if %temporarily_rejected_count_by_ip;
2565       print $htm_fh "<li><a href=\"#Non-rejected spamming ip count\">Top $topcount non-rejected spamming ips by message count</a>\n" if %spam_count_by_ip;
2566
2567     }
2568     print $htm_fh "<li><a href=\"#errors\">List of errors</a>\n" if %errors_count;
2569     print $htm_fh "</ul>\n<hr>\n";
2570   }
2571   if ($xls_fh)
2572   {
2573     $ws_global->write($row++, $col+0, "Exim Statistics",  $f_header1);
2574     &set_worksheet_line($ws_global, $row, $col, ["from:",  $begin,  "to:", $end], $f_default);
2575     $row+=2;
2576   }
2577 }
2578
2579
2580 #######################################################################
2581 # print_grandtotals();
2582 #
2583 #  print_grandtotals();
2584 #
2585 # Print the grand totals.
2586 #######################################################################
2587 sub print_grandtotals {
2588
2589   # Get the sender by headings and results. This is complicated as we can have
2590   # different numbers of columns.
2591   my($sender_txt_header,$sender_txt_format,$sender_html_format);
2592   my(@received_totals,@delivered_totals);
2593   my($row_tablehead, $row_max);
2594   my(@col_headers) = ('TOTAL', 'Volume', 'Messages', 'Addresses');
2595
2596   foreach ('Host','Domain','Email','Edomain') {
2597     next unless $do_sender{$_};
2598     if ($merge_reports) {
2599       push(@received_totals, get_report_total($report_totals{Received},"${_}s"));
2600       push(@delivered_totals,get_report_total($report_totals{Delivered},"${_}s"));
2601     }
2602     else {
2603       push(@received_totals,scalar(keys %{$received_data{$_}}));
2604       push(@delivered_totals,scalar(keys %{$delivered_data{$_}}));
2605     }
2606     $sender_txt_header  .= " " x ($COLUMN_WIDTHS - length($_)) . $_ . 's';
2607     $sender_html_format .= "<td align=\"right\">%s</td>";
2608     $sender_txt_format  .= " " x ($COLUMN_WIDTHS - 5) . "%6s";
2609     push(@col_headers,"${_}s");
2610   }
2611
2612   my $txt_format1 = "  %-16s %9s     %6d    %6s $sender_txt_format";
2613   my $txt_format2 = "  %6d %4.1f%% %6d %4.1f%%",
2614   my $htm_format1 = "<tr><td>%s</td><td align=\"right\">%s</td><td align=\"right\">%s</td><td align=\"right\">%s</td>$sender_html_format";
2615   my $htm_format2 = "<td align=\"right\">%d</td><td align=\"right\">%4.1f%%</td><td align=\"right\">%d</td><td align=\"right\">%4.1f%%</td>";
2616
2617   if ($txt_fh) {
2618     my $sender_spaces = " " x length($sender_txt_header);
2619     print $txt_fh "\n";
2620     print $txt_fh "Grand total summary\n";
2621     print $txt_fh "-------------------\n";
2622     print $txt_fh "                                              $sender_spaces           At least one address\n";
2623     print $txt_fh "  TOTAL               Volume   Messages Addresses $sender_txt_header      Delayed       Failed\n";
2624   }
2625   if ($htm_fh) {
2626     print $htm_fh "<a name=\"Grandtotal\"></a>\n";
2627     print $htm_fh "<h2>Grand total summary</h2>\n";
2628     print $htm_fh "<table border=1>\n";
2629     print $htm_fh "<tr><th>" . join('</th><th>',@col_headers) . "</th><th colspan=2>At least one addr<br>Delayed</th><th colspan=2>At least one addr<br>Failed</th>\n";
2630   }
2631   if ($xls_fh) {
2632     $ws_global->write($row++, 0, "Grand total summary", $f_header2);
2633     $ws_global->write($row, 0, \@col_headers, $f_header2);
2634     $ws_global->merge_range($row, scalar(@col_headers), $row, scalar(@col_headers)+1, "At least one addr Delayed", $f_header2_m);
2635     $ws_global->merge_range($row, scalar(@col_headers)+2, $row, scalar(@col_headers)+3, "At least one addr Failed", $f_header2_m);
2636     #$ws_global->write(++$row, scalar(@col_headers), ['Total','Percent','Total','Percent'], $f_header2);
2637   }
2638
2639
2640   my($volume,$failed_count);
2641   if ($merge_reports) {
2642     $volume = volume_rounded($report_totals{Received}{Volume}, $report_totals{Received}{'Volume-gigs'});
2643     $total_received_count = get_report_total($report_totals{Received},'Messages');
2644     $failed_count  = get_report_total($report_totals{Received},'Failed');
2645     $delayed_count = get_report_total($report_totals{Received},'Delayed');
2646   }
2647   else {
2648     $volume = volume_rounded($total_received_data, $total_received_data_gigs);
2649     $failed_count = $message_errors;
2650   }
2651
2652   {
2653     no integer;
2654
2655     my @content=(
2656         $volume,$total_received_count,'',
2657         @received_totals,
2658         $delayed_count,
2659         ($total_received_count) ? ($delayed_count*100/$total_received_count) : 0,
2660         $failed_count,
2661         ($total_received_count) ? ($failed_count*100/$total_received_count) : 0
2662     );
2663
2664     printf $txt_fh ("$txt_format1$txt_format2\n", 'Received', @content) if $txt_fh;
2665     printf $htm_fh ("$htm_format1$htm_format2\n", 'Received', @content) if $htm_fh;
2666     if ($xls_fh) {
2667       $ws_global->write(++$row, 0, 'Received', $f_default);
2668       for (my $i=0; $i < scalar(@content); $i++) {
2669         if ($i == 4 || $i == 6) {
2670           $ws_global->write($row, $i+1, $content[$i]/100, $f_percent);
2671         }
2672         else {
2673           $ws_global->write($row, $i+1, $content[$i], $f_default);
2674         }
2675       }
2676     }
2677   }
2678
2679   if ($merge_reports) {
2680     $volume = volume_rounded($report_totals{Delivered}{Volume}, $report_totals{Delivered}{'Volume-gigs'});
2681     $total_delivered_messages = get_report_total($report_totals{Delivered},'Messages');
2682     $total_delivered_addresses = get_report_total($report_totals{Delivered},'Addresses');
2683   }
2684   else {
2685     $volume = volume_rounded($total_delivered_data, $total_delivered_data_gigs);
2686   }
2687
2688   my @content=($volume, $total_delivered_messages, $total_delivered_addresses, @delivered_totals);
2689   printf $txt_fh ("$txt_format1\n", 'Delivered', @content) if $txt_fh;
2690   printf $htm_fh ("$htm_format1\n", 'Delivered', @content) if $htm_fh;
2691
2692   if ($xls_fh) {
2693     $ws_global->write(++$row, 0, 'Delivered', $f_default);
2694     for (my $i=0; $i < scalar(@content); $i++) {
2695       $ws_global->write($row, $i+1, $content[$i], $f_default);
2696     }
2697   }
2698
2699   if ($merge_reports) {
2700     foreach ('Rejects', 'Temp Rejects', 'Ham', 'Spam') {
2701       my $messages = get_report_total($report_totals{$_},'Messages');
2702       my $addresses = get_report_total($report_totals{$_},'Addresses');
2703       if ($messages) {
2704         @content = ($_, '', $messages, '');
2705         push(@content,get_report_total($report_totals{$_},'Hosts')) if $do_sender{Host};
2706         #These rows do not have entries for the following columns (if specified)
2707         foreach ('Domain','Email','Edomain') {
2708           push(@content,'') if $do_sender{$_};
2709         }
2710
2711         printf $txt_fh ("$txt_format1\n", @content) if $txt_fh;
2712         printf $htm_fh ("$htm_format1\n", @content) if $htm_fh;
2713         $ws_global->write(++$row, 0, \@content) if $xls_fh;
2714       }
2715     }
2716   }
2717   else {
2718     foreach my $total_aref (['Rejects',\%rejected_count_by_ip],
2719                             ['Temp Rejects',\%temporarily_rejected_count_by_ip],
2720                             ['Ham',\%ham_count_by_ip],
2721                             ['Spam',\%spam_count_by_ip]) {
2722       #Count the number of messages of this type.
2723       my $messages = 0;
2724       map {$messages += $_} values %{$total_aref->[1]};
2725
2726       if ($messages > 0) {
2727         @content = ($total_aref->[0], '', $messages, '');
2728
2729         #Count the number of distict IPs for the Hosts column.
2730         push(@content,scalar(keys %{$total_aref->[1]})) if $do_sender{Host};
2731
2732         #These rows do not have entries for the following columns (if specified)
2733         foreach ('Domain','Email','Edomain') {
2734           push(@content,'') if $do_sender{$_};
2735         }
2736
2737         printf $txt_fh ("$txt_format1\n", @content) if $txt_fh;
2738         printf $htm_fh ("$htm_format1\n", @content) if $htm_fh;
2739         $ws_global->write(++$row, 0, \@content) if $xls_fh;
2740       }
2741     }
2742   }
2743
2744   printf $txt_fh "\n"         if $txt_fh;
2745   printf $htm_fh "</table>\n" if $htm_fh;
2746   ++$row;
2747 }
2748
2749
2750 #######################################################################
2751 # print_user_patterns()
2752 #
2753 #  print_user_patterns();
2754 #
2755 # Print the counts of user specified patterns.
2756 #######################################################################
2757 sub print_user_patterns {
2758   my $txt_format1 = "  %-18s  %6d";
2759   my $htm_format1 = "<tr><td>%s</td><td align=\"right\">%d</td>";
2760
2761   if ($txt_fh) {
2762     print $txt_fh "User Specified Patterns\n";
2763     print $txt_fh "-----------------------";
2764     print $txt_fh "\n                       Total\n";
2765   }
2766   if ($htm_fh) {
2767     print $htm_fh "<hr><a name=\"Patterns\"></a><h2>User Specified Patterns</h2>\n";
2768     print $htm_fh "<table border=0 width=\"100%\">\n";
2769     print $htm_fh "<tr><td>\n";
2770     print $htm_fh "<table border=1>\n";
2771     print $htm_fh "<tr><th>&nbsp;</th><th>Total</th>\n";
2772   }
2773   if ($xls_fh) {
2774       $ws_global->write($row++, $col, "User Specified Patterns", $f_header2);
2775       &set_worksheet_line($ws_global, $row++, 1, ["Total"], $f_headertab);
2776   }
2777
2778
2779   my($key);
2780   if ($merge_reports) {
2781     # We are getting our data from previous reports.
2782     foreach $key (@user_descriptions) {
2783       my $count = get_report_total($report_totals{patterns}{$key},'Total');
2784       printf $txt_fh ("$txt_format1\n",$key,$count) if $txt_fh;
2785       printf $htm_fh ("$htm_format1\n",$key,$count) if $htm_fh;
2786       if ($xls_fh)
2787       {
2788         &set_worksheet_line($ws_global, $row++, 0, [$key,$count], $f_default);
2789       }
2790     }
2791   }
2792   else {
2793     # We are getting our data from mainlog files.
2794     my $user_pattern_index = 0;
2795     foreach $key (@user_descriptions) {
2796       printf $txt_fh ("$txt_format1\n",$key,$user_pattern_totals[$user_pattern_index]) if $txt_fh;
2797       printf $htm_fh ("$htm_format1\n",$key,$user_pattern_totals[$user_pattern_index]) if $htm_fh;
2798       $ws_global->write($row++, 0, [$key,$user_pattern_totals[$user_pattern_index]]) if $xls_fh;
2799       $user_pattern_index++;
2800     }
2801   }
2802   print $txt_fh "\n" if $txt_fh;
2803   print $htm_fh "</table>\n\n" if $htm_fh;
2804   if ($xls_fh)
2805   {
2806     ++$row;
2807   }
2808
2809   if ($hist_opt > 0) {
2810     my $user_pattern_index = 0;
2811     foreach $key (@user_descriptions) {
2812       print_histogram($key, 'occurence', @{$user_pattern_interval_count[$user_pattern_index]});
2813       $user_pattern_index++;
2814     }
2815   }
2816 }
2817
2818 #######################################################################
2819 # print_rejects()
2820 #
2821 #  print_rejects();
2822 #
2823 # Print statistics about rejected mail.
2824 #######################################################################
2825 sub print_rejects {
2826   my($format1,$reason);
2827
2828   my $txt_format1 = "  %-40s  %6d";
2829   my $htm_format1 = "<tr><td>%s</td><td align=\"right\">%d</td>";
2830
2831   if ($txt_fh) {
2832     print $txt_fh "Rejected mail by reason\n";
2833     print $txt_fh "-----------------------";
2834     print $txt_fh "\n                                             Total\n";
2835   }
2836   if ($htm_fh) {
2837     print $htm_fh "<hr><a name=\"patterns\"></a><h2>Rejected mail by reason</h2>\n";
2838     print $htm_fh "<table border=0 width=\"100%\"><tr><td><table border=1>\n";
2839     print $htm_fh "<tr><th>&nbsp;</th><th>Total</th>\n";
2840   }
2841   if ($xls_fh) {
2842     $ws_global->write($row++, $col, "Rejected mail by reason", $f_header2);
2843     &set_worksheet_line($ws_global, $row++, 1, ["Total"], $f_headertab);
2844   }
2845
2846
2847   my $href = ($merge_reports) ? $report_totals{rejected_mail_by_reason} : \%rejected_count_by_reason;
2848   my(@chartdatanames, @chartdatavals_count);
2849
2850   foreach $reason (top_n_sort($topcount, $href, undef, undef)) {
2851     printf $txt_fh ("$txt_format1\n",$reason,$href->{$reason}) if $txt_fh;
2852     printf $htm_fh ("$htm_format1\n",$reason,$href->{$reason}) if $htm_fh;
2853     set_worksheet_line($ws_global, $row++, 0, [$reason,$href->{$reason}], $f_default) if $xls_fh;
2854     push(@chartdatanames, $reason);
2855     push(@chartdatavals_count, $href->{$reason});
2856   }
2857
2858   $row++ if $xls_fh;
2859   print $txt_fh "\n" if $txt_fh;
2860
2861   if ($htm_fh) {
2862     print $htm_fh "</tr></table></td><td>";
2863     if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals_count > 0)) {
2864       # calculate the graph
2865       my @data = (
2866          \@chartdatanames,
2867          \@chartdatavals_count
2868       );
2869       my $graph = GD::Graph::pie->new(200, 200);
2870       $graph->set(
2871           x_label           => 'Rejection Reasons',
2872           y_label           => 'Messages',
2873           title             => 'By count',
2874       );
2875       my $gd = $graph->plot(\@data) or warn($graph->error);
2876       if ($gd) {
2877         open(IMG, ">$chartdir/rejections_count.png") or die "Could not write $chartdir/rejections_count.png: $!\n";
2878         binmode IMG;
2879         print IMG $gd->png;
2880         close IMG;
2881         print $htm_fh "<img src=\"$chartrel/rejections_count.png\">";
2882       }
2883     }
2884     print $htm_fh "</td></tr></table>\n\n";
2885   }
2886 }
2887
2888
2889
2890
2891
2892 #######################################################################
2893 # print_transport();
2894 #
2895 #  print_transport();
2896 #
2897 # Print totals by transport.
2898 #######################################################################
2899 sub print_transport {
2900   my(@chartdatanames);
2901   my(@chartdatavals_count);
2902   my(@chartdatavals_vol);
2903   no integer;                 #Lose this for charting the data.
2904
2905   my $txt_format1 = "  %-18s  %6s      %6d";
2906   my $htm_format1 = "<tr><td>%s</td><td align=\"right\">%s</td><td align=\"right\">%d</td>";
2907
2908   if ($txt_fh) {
2909     print $txt_fh "Deliveries by transport\n";
2910     print $txt_fh "-----------------------";
2911     print $txt_fh "\n                      Volume    Messages\n";
2912   }
2913   if ($htm_fh) {
2914     print $htm_fh "<hr><a name=\"Transport\"></a><h2>Deliveries by Transport</h2>\n";
2915     print $htm_fh "<table border=0 width=\"100%\"><tr><td><table border=1>\n";
2916     print $htm_fh "<tr><th>&nbsp;</th><th>Volume</th><th>Messages</th>\n";
2917   }
2918   if ($xls_fh) {
2919     $ws_global->write(++$row, $col, "Deliveries by transport", $f_header2);
2920     $ws_global->write(++$row, 1, ["Volume", "Messages"], $f_headertab);
2921   }
2922
2923   my($key);
2924   if ($merge_reports) {
2925     # We are getting our data from previous reports.
2926     foreach $key (sort keys %{$report_totals{transport}}) {
2927       my $count = get_report_total($report_totals{transport}{$key},'Messages');
2928       my @content=($key, volume_rounded($report_totals{transport}{$key}{Volume},
2929         $report_totals{transport}{$key}{'Volume-gigs'}), $count);
2930       push(@chartdatanames, $key);
2931       push(@chartdatavals_count, $count);
2932       push(@chartdatavals_vol, $report_totals{transport}{$key}{'Volume-gigs'}*$gig + $report_totals{transport}{$key}{Volume} );
2933       printf $txt_fh ("$txt_format1\n", @content) if $txt_fh;
2934       printf $htm_fh ("$htm_format1\n", @content) if $htm_fh;
2935       $ws_global->write(++$row, 0, \@content) if $xls_fh;
2936     }
2937   }
2938   else {
2939     # We are getting our data from mainlog files.
2940     foreach $key (sort keys %transported_data) {
2941       my @content=($key, volume_rounded($transported_data{$key},$transported_data_gigs{$key}),
2942         $transported_count{$key});
2943       push(@chartdatanames, $key);
2944       push(@chartdatavals_count, $transported_count{$key});
2945       push(@chartdatavals_vol, $transported_data_gigs{$key}*$gig + $transported_data{$key});
2946       printf $txt_fh ("$txt_format1\n", @content) if $txt_fh;
2947       printf $htm_fh ("$htm_format1\n", @content) if $htm_fh;
2948       $ws_global->write(++$row, 0, \@content) if $xls_fh;
2949     }
2950   }
2951   print $txt_fh "\n" if $txt_fh;
2952   if ($htm_fh) {
2953     print $htm_fh "</tr></table></td><td>";
2954
2955     if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals_count > 0))
2956       {
2957       # calculate the graph
2958       my @data = (
2959          \@chartdatanames,
2960          \@chartdatavals_count
2961       );
2962       my $graph = GD::Graph::pie->new(200, 200);
2963       $graph->set(
2964           x_label           => 'Transport',
2965           y_label           => 'Messages',
2966           title             => 'By count',
2967       );
2968       my $gd = $graph->plot(\@data) or warn($graph->error);
2969       if ($gd) {
2970         open(IMG, ">$chartdir/transports_count.png") or die "Could not write $chartdir/transports_count.png: $!\n";
2971         binmode IMG;
2972         print IMG $gd->png;
2973         close IMG;
2974         print $htm_fh "<img src=\"$chartrel/transports_count.png\">";
2975       }
2976     }
2977     print $htm_fh "</td><td>";
2978
2979     if ($HAVE_GD_Graph_pie && $charts && ($#chartdatavals_vol > 0)) {
2980       my @data = (
2981          \@chartdatanames,
2982          \@chartdatavals_vol
2983       );
2984       my $graph = GD::Graph::pie->new(200, 200);
2985       $graph->set(
2986           title             => 'By volume',
2987       );
2988       my $gd = $graph->plot(\@data) or warn($graph->error);
2989       if ($gd) {
2990         open(IMG, ">$chartdir/transports_vol.png") or die "Could not write $chartdir/transports_vol.png: $!\n";
2991         binmode IMG;
2992         print IMG $gd->png;
2993         close IMG;
2994         print $htm_fh "<img src=\"$chartrel/transports_vol.png\">";
2995       }
2996     }
2997
2998     print $htm_fh "</td></tr></table>\n\n";
2999   }
3000 }
3001
3002
3003
3004 #######################################################################
3005 # print_relay();
3006 #
3007 #  print_relay();
3008 #
3009 # Print our totals by relay.
3010 #######################################################################
3011 sub print_relay {
3012   my $row_print_relay=1;
3013   my $temp = "Relayed messages";
3014   print $htm_fh "<hr><a name=\"$temp\"></a><h2>$temp</h2>\n" if $htm_fh;
3015   if (scalar(keys %relayed) > 0 || $relayed_unshown > 0) {
3016     my $shown = 0;
3017     my $spacing = "";
3018     my $txt_format = "%7d %s\n      => %s\n";
3019     my $htm_format = "<tr><td align=\"right\">%d</td><td>%s</td><td>%s</td>\n";
3020
3021     printf $txt_fh ("%s\n%s\n\n", $temp, "-" x length($temp)) if $txt_fh;
3022     if ($htm_fh) {
3023       print $htm_fh "<table border=1>\n";
3024       print $htm_fh "<tr><th>Count</th><th>From</th><th>To</th>\n";
3025     }
3026     if ($xls_fh) {
3027       $ws_relayed->write($row_print_relay++, $col, $temp, $f_header2);
3028       &set_worksheet_line($ws_relayed, $row_print_relay++, 0, ["Count", "From", "To"], $f_headertab);
3029     }
3030
3031
3032     my($key);
3033     foreach $key (sort keys %relayed) {
3034       my $count = $relayed{$key};
3035       $shown += $count;
3036       $key =~ s/[HA]=//g;
3037       my($one,$two) = split(/=> /, $key);
3038       my @content=($count, $one, $two);
3039       printf $txt_fh ($txt_format, @content) if $txt_fh;
3040       printf $htm_fh ($htm_format, @content) if $htm_fh;
3041       if ($xls_fh)
3042       {
3043         &set_worksheet_line($ws_relayed, $row_print_relay++, 0, \@content);
3044       }
3045       $spacing = "\n";
3046     }
3047
3048     print $htm_fh "</table>\n<p>\n" if $htm_fh;
3049     print $txt_fh "${spacing}Total: $shown (plus $relayed_unshown unshown)\n\n" if $txt_fh;
3050     print $htm_fh "${spacing}Total: $shown (plus $relayed_unshown unshown)\n\n" if $htm_fh;
3051     if ($xls_fh)
3052     {
3053        &set_worksheet_line($ws_relayed, $row_print_relay++, 0, [$shown, "Sum of shown" ]);
3054        &set_worksheet_line($ws_relayed, $row_print_relay++, 0, [$relayed_unshown, "unshown"]);
3055        $row_print_relay++;
3056     }
3057   }
3058   else {
3059     print $txt_fh "No relayed messages\n-------------------\n\n" if $txt_fh;
3060     print $htm_fh "No relayed messages\n\n" if $htm_fh;
3061     if ($xls_fh)
3062     {
3063       $row_print_relay++;
3064     }
3065   }
3066 }
3067
3068
3069
3070 #######################################################################
3071 # print_errors();
3072 #
3073 #  print_errors();
3074 #
3075 # Print our errors. In HTML, we display them as a list rather than a table -
3076 # Netscape doesn't like large tables!
3077 #######################################################################
3078 sub print_errors {
3079   my $total_errors = 0;
3080   $row=1;
3081
3082   if (scalar(keys %errors_count) != 0) {
3083     my $temp = "List of errors";
3084     my $htm_format = "<li>%d - %s\n";
3085
3086     printf $txt_fh ("%s\n%s\n\n", $temp, "-" x length($temp)) if $txt_fh;
3087     if ($htm_fh) {
3088       print $htm_fh "<hr><a name=\"errors\"></a><h2>$temp</h2>\n";
3089       print $htm_fh "<ul><li><b>Count - Error</b>\n";
3090     }
3091     if ($xls_fh)
3092     {
3093       $ws_errors->write($row++, 0, $temp, $f_header2);
3094       &set_worksheet_line($ws_errors, $row++, 0, ["Count", "Error"], $f_headertab);
3095     }
3096
3097
3098     my($key);
3099     foreach $key (sort keys %errors_count) {
3100       my $text = $key;
3101       chomp($text);
3102       $text =~ s/\s\s+/ /g;   #Convert multiple spaces to a single space.
3103       $total_errors += $errors_count{$key};
3104
3105       if ($txt_fh) {
3106         printf $txt_fh ("%5d ", $errors_count{$key});
3107         my $text_remaining = $text;
3108         while (length($text_remaining) > 65) {
3109           my($first,$rest) = $text_remaining =~ /(.{50}\S*)\s+(.+)/;
3110           last if !$first;
3111           printf $txt_fh ("%s\n\t    ", $first);
3112           $text_remaining = $rest;
3113         }
3114         printf $txt_fh ("%s\n\n", $text_remaining);
3115       }
3116
3117       if ($htm_fh) {
3118
3119         #Translate HTML tag characters. Sergey Sholokh.
3120         $text =~ s/\</\&lt\;/g;
3121         $text =~ s/\>/\&gt\;/g;
3122
3123         printf $htm_fh ($htm_format,$errors_count{$key},$text);
3124       }
3125       if ($xls_fh)
3126       {
3127         &set_worksheet_line($ws_errors, $row++, 0, [$errors_count{$key},$text]);
3128       }
3129     }
3130
3131     $temp = "Errors encountered: $total_errors";
3132
3133     if ($txt_fh) {
3134       print $txt_fh $temp, "\n";
3135       print $txt_fh "-" x length($temp),"\n";
3136     }
3137     if ($htm_fh) {
3138       print $htm_fh "</ul>\n<p>\n";
3139       print $htm_fh $temp, "\n";
3140     }
3141     if ($xls_fh)
3142     {
3143         &set_worksheet_line($ws_errors, $row++, 0, [$total_errors, "Sum of Errors encountered"]);
3144     }
3145   }
3146
3147 }
3148
3149
3150 #######################################################################
3151 # parse_old_eximstat_reports();
3152 #
3153 #  parse_old_eximstat_reports($fh);
3154 #
3155 # Parse old eximstat output so we can merge daily stats to weekly stats and weekly to monthly etc.
3156 #
3157 # To test that the merging still works after changes, do something like the following.
3158 # All the diffs should produce no output.
3159 #
3160 #  options='-bydomain -byemail -byhost -byedomain'
3161 #  options="$options -show_rt1,2,4 -show_dt 1,2,4"
3162 #  options="$options -pattern 'Completed Messages' /Completed/"
3163 #  options="$options -pattern 'Received Messages' /<=/"
3164 #
3165 #  ./eximstats $options mainlog > mainlog.txt
3166 #  ./eximstats $options -merge mainlog.txt > mainlog.2.txt
3167 #  diff mainlog.txt mainlog.2.txt
3168 #
3169 #  ./eximstats $options -html mainlog > mainlog.html
3170 #  ./eximstats $options -merge -html mainlog.txt  > mainlog.2.html
3171 #  diff mainlog.html mainlog.2.html
3172 #
3173 #  ./eximstats $options -merge mainlog.html > mainlog.3.txt
3174 #  diff mainlog.txt mainlog.3.txt
3175 #
3176 #  ./eximstats $options -merge -html mainlog.html > mainlog.3.html
3177 #  diff mainlog.html mainlog.3.html
3178 #
3179 #  ./eximstats $options -nvr   mainlog > mainlog.nvr.txt
3180 #  ./eximstats $options -merge mainlog.nvr.txt > mainlog.4.txt
3181 #  diff mainlog.txt mainlog.4.txt
3182 #
3183 #  # double_mainlog.txt should have twice the values that mainlog.txt has.
3184 #  ./eximstats $options mainlog mainlog > double_mainlog.txt
3185 #######################################################################
3186 sub parse_old_eximstat_reports {
3187   my($fh) = @_;
3188
3189   my(%league_table_value_entered, %league_table_value_was_zero, %table_order);
3190
3191   my(%user_pattern_index);
3192   my $user_pattern_index = 0;
3193   map {$user_pattern_index{$_} = $user_pattern_index++} @user_descriptions;
3194   my $user_pattern_keys = join('|', @user_descriptions);
3195
3196   while (<$fh>) {
3197     PARSE_OLD_REPORT_LINE:
3198     if (/Exim statistics from ([\d\-]+ [\d:]+(\s+[\+\-]\d+)?) to ([\d\-]+ [\d:]+(\s+[\+\-]\d+)?)/) {
3199       $begin = $1 if ($1 lt $begin);
3200       $end   = $3 if ($3 gt $end);
3201     }
3202     elsif (/Grand total summary/) {
3203       # Fill in $report_totals{Received|Delivered}{Volume|Messages|Addresses|Hosts|Domains|...|Delayed|DelayedPercent|Failed|FailedPercent}
3204       my(@fields, @delivered_fields);
3205       my $doing_table = 0;
3206       while (<$fh>) {
3207         $_ = html2txt($_);       #Convert general HTML markup to text.
3208         s/At least one addr//g;  #Another part of the HTML output we don't want.
3209
3210 #  TOTAL               Volume    Messages Addresses   Hosts Domains      Delayed       Failed
3211 #  Received              26MB         237               177      23       8  3.4%     28 11.8%
3212 #  Delivered             13MB         233       250      99      88
3213         if (/TOTAL\s+(.*?)\s*$/) {
3214           $doing_table = 1;
3215           @delivered_fields = split(/\s+/,$1);
3216
3217           #Delayed and Failed have two columns each, so add the extra field names in.
3218           splice(@delivered_fields,-1,1,'DelayedPercent','Failed','FailedPercent');
3219
3220           # Addresses only figure in the Delivered row, so remove them from the
3221           # normal fields.
3222           @fields = grep !/Addresses/, @delivered_fields;
3223         }
3224         elsif (/(Received)\s+(.*?)\s*$/) {
3225           print STDERR "Parsing $_" if $debug;
3226           add_to_totals($report_totals{$1},\@fields,$2);
3227         }
3228         elsif (/(Delivered)\s+(.*?)\s*$/) {
3229           print STDERR "Parsing $_" if $debug;
3230           add_to_totals($report_totals{$1},\@delivered_fields,$2);
3231           my $data = $2;
3232           # If we're merging an old report which doesn't include addresses,
3233           # then use the Messages field instead.
3234           unless (grep(/Addresses/, @delivered_fields)) {
3235             my %tmp;
3236             line_to_hash(\%tmp,\@delivered_fields,$data);
3237             add_to_totals($report_totals{Delivered},['Addresses'],$tmp{Messages});
3238           }
3239         }
3240         elsif (/(Temp Rejects|Rejects|Ham|Spam)\s+(.*?)\s*$/) {
3241           print STDERR "Parsing $_" if $debug;
3242           add_to_totals($report_totals{$1},['Messages','Hosts'],$2);
3243         }
3244         else {
3245           last if $doing_table;
3246         }
3247       }
3248     }
3249
3250     elsif (/User Specified Patterns/i) {
3251 #User Specified Patterns
3252 #-----------------------
3253 #                       Total
3254 #  Description             85
3255
3256       while (<$fh>) { last if (/Total/); }  #Wait until we get the table headers.
3257       while (<$fh>) {
3258         print STDERR "Parsing $_" if $debug;
3259         $_ = html2txt($_);              #Convert general HTML markup to text.
3260         if (/^\s*(.*?)\s+(\d+)\s*$/) {
3261           $report_totals{patterns}{$1} = {} unless (defined $report_totals{patterns}{$1});
3262           add_to_totals($report_totals{patterns}{$1},['Total'],$2);
3263         }
3264         last if (/^\s*$/);              #Finished if we have a blank line.
3265       }
3266     }
3267
3268     elsif (/(^|<h2>)($user_pattern_keys) per /o) {
3269       # Parse User defined pattern histograms if they exist.
3270       parse_histogram($fh, $user_pattern_interval_count[$user_pattern_index{$2}] );
3271     }
3272
3273
3274     elsif (/Deliveries by transport/i) {
3275 #Deliveries by transport
3276 #-----------------------
3277 #                      Volume    Messages
3278 #  :blackhole:           70KB          51
3279 #  address_pipe         655KB           1
3280 #  smtp                  11MB         151
3281
3282       while (<$fh>) { last if (/Volume/); }  #Wait until we get the table headers.
3283       while (<$fh>) {
3284         print STDERR "Parsing $_" if $debug;
3285         $_ = html2txt($_);              #Convert general HTML markup to text.
3286         if (/(\S+)\s+(\d+\S*\s+\d+)/) {
3287           $report_totals{transport}{$1} = {} unless (defined $report_totals{transport}{$1});
3288           add_to_totals($report_totals{transport}{$1},['Volume','Messages'],$2);
3289         }
3290         last if (/^\s*$/);              #Finished if we have a blank line.
3291       }
3292     }
3293     elsif (/Messages received per/) {
3294       parse_histogram($fh, \@received_interval_count);
3295     }
3296     elsif (/Deliveries per/) {
3297       parse_histogram($fh, \@delivered_interval_count);
3298     }
3299
3300     #elsif (/Time spent on the queue: (all messages|messages with at least one remote delivery)/) {
3301     elsif (/(Time spent on the queue|Delivery times|Receipt times): ((\S+) messages|messages with at least one remote delivery)((<[^>]*>)*\s*)$/) {
3302 #Time spent on the queue: all messages
3303 #-------------------------------------
3304 #
3305 #Under   1m      217  91.9%   91.9%
3306 #        5m        2   0.8%   92.8%
3307 #        3h        8   3.4%   96.2%
3308 #        6h        7   3.0%   99.2%
3309 #       12h        2   0.8%  100.0%
3310
3311       # Set a pointer to the queue bin so we can use the same code
3312       # block for both all messages and remote deliveries.
3313       #my $bin_aref = ($1 eq 'all messages') ? \@qt_all_bin : \@qt_remote_bin;
3314       my($bin_aref, $times_aref, $overflow_sref);
3315       if ($1 eq 'Time spent on the queue') {
3316         $times_aref = \@queue_times;
3317         if ($2 eq 'all messages') {
3318           $bin_aref = \@qt_all_bin;
3319           $overflow_sref = \$qt_all_overflow;
3320         }
3321         else {
3322           $bin_aref = \@qt_remote_bin;
3323           $overflow_sref = \$qt_remote_overflow;
3324         }
3325       }
3326       elsif ($1 eq 'Delivery times') {
3327         $times_aref = \@delivery_times;
3328         if ($2 eq 'all messages') {
3329           $bin_aref = \@dt_all_bin;
3330           $overflow_sref = \$dt_all_overflow;
3331         }
3332         else {
3333           $bin_aref = \@dt_remote_bin;
3334           $overflow_sref = \$dt_remote_overflow;
3335         }
3336       }
3337       else {
3338         unless (exists $rcpt_times_bin{$3}) {
3339           initialise_rcpt_times($3);
3340         }
3341         $bin_aref = $rcpt_times_bin{$3};
3342         $times_aref = \@rcpt_times;
3343         $overflow_sref = \$rcpt_times_overflow{$3};
3344       }
3345
3346
3347       my ($blank_lines, $reached_table) = (0,0);
3348       while (<$fh>) {
3349         $_ = html2txt($_);              #Convert general HTML markup to text.
3350         # The table is preceded by one blank line, and has one blank line
3351         # following it. As the table may be empty, the best way to determine
3352         # that we've finished it is to look for the second blank line.
3353         ++$blank_lines if /^\s*$/;
3354         last if ($blank_lines >=2);     #Finished the table ?
3355         $reached_table = 1 if (/\d/);
3356         next unless $reached_table;
3357         my $previous_seconds_on_queue = 0;
3358         if (/^\s*(Under|Over|)\s+(\d+[smhdw])\s+(\d+)/) {
3359           print STDERR "Parsing $_" if $debug;
3360           my($modifier,$formated_time,$count) = ($1,$2,$3);
3361           my $seconds = unformat_time($formated_time);
3362           my $time_on_queue = ($seconds + $previous_seconds_on_queue) / 2;
3363           $previous_seconds_on_queue = $seconds;
3364           $time_on_queue = $seconds * 2 if ($modifier eq 'Over');
3365           my($i);
3366           for ($i = 0; $i <= $#$times_aref; $i++) {
3367             if ($time_on_queue < $times_aref->[$i]) {
3368               $$bin_aref[$i] += $count;
3369               last;
3370             }
3371           }
3372           $$overflow_sref += $count if ($i > $#$times_aref);
3373
3374         }
3375       }
3376     }
3377
3378     elsif (/Relayed messages/) {
3379 #Relayed messages
3380 #----------------
3381 #
3382 #      1 addr.domain.com [1.2.3.4] a.user@domain.com
3383 #      => addr2.domain2.com [5.6.7.8] a2.user2@domain2.com
3384 #
3385 #<tr><td align="right">1</td><td>addr.domain.com [1.2.3.4] a.user@domain.com </td><td>addr2.domain2.com [5.6.7.8] a2.user2@domain2.com</td>
3386
3387       my $reached_table = 0;
3388       my($count,$sender);
3389       while (<$fh>) {
3390         unless ($reached_table) {
3391           last if (/No relayed messages/);
3392           $reached_table = 1 if (/^\s*\d/ || />\d+</);
3393           next unless $reached_table;
3394         }
3395         if (/>(\d+)<.td><td>(.*?) ?<.td><td>(.*?)</) {
3396           update_relayed($1,$2,$3);
3397         }
3398         elsif (/^\s*(\d+)\s+(.*?)\s*$/) {
3399           ($count,$sender) = ($1,$2);
3400         }
3401         elsif (/=>\s+(.*?)\s*$/) {
3402           update_relayed($count,$sender,$1);
3403         }
3404         else {
3405           last;                           #Finished the table ?
3406         }
3407       }
3408     }
3409
3410     elsif (/Top (.*?) by (message count|volume)/) {
3411 #Top 50 sending hosts by message count
3412 #-------------------------------------
3413 #
3414 #     48     1468KB   local
3415 # Could also have average values for HTML output.
3416 #     48     1468KB   30KB  local
3417
3418       my($category,$by_count_or_volume) = ($1,$2);
3419
3420       #As we show 2 views of each table (by count and by volume),
3421       #most (but not all) entries will appear in both tables.
3422       #Set up a hash to record which entries we have already seen
3423       #and one to record which ones we are seeing for the first time.
3424       if ($by_count_or_volume =~ /count/) {
3425         undef %league_table_value_entered;
3426         undef %league_table_value_was_zero;
3427         undef %table_order;
3428       }
3429
3430       #As this section processes multiple different table categories,
3431       #set up pointers to the hashes to be updated.
3432       my($messages_href,$addresses_href,$data_href,$data_gigs_href);
3433       if ($category =~ /local sender/) {
3434         $messages_href   = \%received_count_user;
3435         $addresses_href  = undef;
3436         $data_href       = \%received_data_user;
3437         $data_gigs_href  = \%received_data_gigs_user;
3438       }
3439       elsif ($category =~ /sending (\S+?)s?\b/) {
3440         #Top 50 sending (host|domain|email|edomain)s
3441         #Top sending (host|domain|email|edomain)
3442         $messages_href   = \%{$received_count{"\u$1"}};
3443         $data_href       = \%{$received_data{"\u$1"}};
3444         $data_gigs_href  = \%{$received_data_gigs{"\u$1"}};
3445       }
3446       elsif ($category =~ /local destination/) {
3447         $messages_href   = \%delivered_messages_user;
3448         $addresses_href  = \%delivered_addresses_user;
3449         $data_href       = \%delivered_data_user;
3450         $data_gigs_href  = \%delivered_data_gigs_user;
3451       }
3452       elsif ($category =~ /local domain destination/) {
3453         $messages_href   = \%delivered_messages_local_domain;
3454         $addresses_href  = \%delivered_addresses_local_domain;
3455         $data_href       = \%delivered_data_local_domain;
3456         $data_gigs_href  = \%delivered_data_gigs_local_domain;
3457       }
3458       elsif ($category =~ /(\S+) destination/) {
3459         #Top 50 (host|domain|email|edomain) destinations
3460         #Top (host|domain|email|edomain) destination
3461         $messages_href   = \%{$delivered_messages{"\u$1"}};
3462         $addresses_href  = \%{$delivered_addresses{"\u$1"}};
3463         $data_href       = \%{$delivered_data{"\u$1"}};
3464         $data_gigs_href  = \%{$delivered_data_gigs{"\u$1"}};
3465       }
3466       elsif ($category =~ /temporarily rejected ips/) {
3467         $messages_href      = \%temporarily_rejected_count_by_ip;
3468       }
3469       elsif ($category =~ /rejected ips/) {
3470         $messages_href      = \%rejected_count_by_ip;
3471       }
3472       elsif ($category =~ /non-rejected spamming ips/) {
3473         $messages_href      = \%spam_count_by_ip;
3474       }
3475       elsif ($category =~ /mail temporary rejection reasons/) {
3476         $messages_href      = \%temporarily_rejected_count_by_reason;
3477       }
3478       elsif ($category =~ /mail rejection reasons/) {
3479         $messages_href      = \%rejected_count_by_reason;
3480       }
3481
3482       my $reached_table = 0;
3483       my $row_re;
3484       while (<$fh>) {
3485         # Watch out for empty tables.
3486         goto PARSE_OLD_REPORT_LINE if (/<h2>/ or (/^\s*[a-zA-Z]/ && !/^\s*Messages/));
3487
3488         $_ = html2txt($_);              #Convert general HTML markup to text.
3489
3490         # Messages      Addresses  Bytes  Average
3491         if (/^\s*Messages/) {
3492           my $pattern = '^\s*(\d+)';
3493           $pattern .= (/Addresses/) ? '\s+(\d+)' : '()';
3494           $pattern .= (/Bytes/)     ? '\s+([\dKMGB]+)' : '()';
3495           $pattern .= (/Average/)   ? '\s+[\dKMGB]+' : '';
3496           $pattern .= '\s+(.*?)\s*$';
3497           $row_re = qr/$pattern/;
3498           $reached_table = 1;
3499           next;
3500         }
3501         next unless $reached_table;
3502
3503         my($messages, $addresses, $rounded_volume, $entry);
3504
3505         if (/$row_re/) {
3506           ($messages, $addresses, $rounded_volume, $entry) = ($1, $2, $3, $4);
3507         }
3508         else {
3509           #Else we have finished the table and we may need to do some
3510           #kludging to retain the order of the entries.
3511
3512           if ($by_count_or_volume =~ /volume/) {
3513             #Add a few bytes to appropriate entries to preserve the order.
3514             foreach $rounded_volume (keys %table_order) {
3515               #For each rounded volume, we want to create a list which has things
3516               #ordered from the volume table at the front, and additional things
3517               #from the count table ordered at the back.
3518               @{$table_order{$rounded_volume}{volume}} = () unless defined $table_order{$rounded_volume}{volume};
3519               @{$table_order{$rounded_volume}{'message count'}} = () unless defined $table_order{$rounded_volume}{'message count'};
3520               my(@order,%mark);
3521               map {$mark{$_} = 1} @{$table_order{$rounded_volume}{volume}};
3522               @order = @{$table_order{$rounded_volume}{volume}};
3523               map {push(@order,$_)} grep(!$mark{$_},@{$table_order{$rounded_volume}{'message count'}});
3524
3525               my $bonus_bytes = $#order;
3526               $bonus_bytes = 511 if ($bonus_bytes > 511);  #Don't go over the half-K boundary!
3527               while (@order and ($bonus_bytes > 0)) {
3528                 my $entry = shift(@order);
3529                 if ($league_table_value_was_zero{$entry}) {
3530                   $$data_href{$entry} += $bonus_bytes;
3531                   print STDERR "$category by $by_count_or_volume: added $bonus_bytes bonus bytes to $entry\n" if $debug;
3532                 }
3533                 $bonus_bytes--;
3534               }
3535             }
3536           }
3537           last;
3538         }
3539
3540         # Store a new table entry.
3541
3542         # Add the entry into the %table_order hash if it has a rounded
3543         # volume (KB/MB/GB).
3544         push(@{$table_order{$rounded_volume}{$by_count_or_volume}},$entry) if ($rounded_volume =~ /\D/);
3545
3546         unless ($league_table_value_entered{$entry}) {
3547           $league_table_value_entered{$entry} = 1;
3548           unless ($$messages_href{$entry}) {
3549             $$messages_href{$entry}  = 0;
3550             $$addresses_href{$entry} = 0;
3551             $$data_href{$entry}      = 0;
3552             $$data_gigs_href{$entry} = 0;
3553             $league_table_value_was_zero{$entry} = 1;
3554           }
3555
3556           $$messages_href{$entry} += $messages;
3557
3558           # When adding the addresses, be aware that we could be merging
3559           # an old report which does not include addresses. In this case,
3560           # we add the messages instead.
3561           $$addresses_href{$entry} += ($addresses) ? $addresses : $messages;
3562
3563           #Add the rounded value to the data and data_gigs hashes.
3564           un_round($rounded_volume,\$$data_href{$entry},\$$data_gigs_href{$entry}) if $rounded_volume;
3565           print STDERR "$category by $by_count_or_volume: added $messages,$rounded_volume to $entry\n" if $debug;
3566         }
3567
3568       }
3569     }
3570     elsif (/List of errors/) {
3571 #List of errors
3572 #--------------
3573 #
3574 #    1 07904931641@one2one.net R=external T=smtp: SMTP error
3575 #            from remote mailer after RCPT TO:<07904931641@one2one.net>:
3576 #            host mail.one2one.net [193.133.192.24]: 550 User unknown
3577 #
3578 #<li>1 - ally.dufc@dunbar.org.uk R=external T=smtp: SMTP error from remote mailer after RCPT TO:<ally.dufc@dunbar.org.uk>: host mail.dunbar.org.uk [216.167.89.88]: 550 Unknown local part ally.dufc in <ally.dufc@dunbar.org.uk>
3579
3580
3581       my $reached_table = 0;
3582       my($count,$error,$blanks);
3583       while (<$fh>) {
3584         $reached_table = 1 if (/^( *|<li>)(\d+)/);
3585         next unless $reached_table;
3586
3587         s/^<li>(\d+) -/$1/;     #Convert an HTML line to a text line.
3588         $_ = html2txt($_);      #Convert general HTML markup to text.
3589
3590         if (/\t\s*(.*)/) {
3591           $error .= ' ' . $1;   #Join a multiline error.
3592         }
3593         elsif (/^\s*(\d+)\s+(.*)/) {
3594           if ($error) {
3595             #Finished with a previous multiline error so save it.
3596             $errors_count{$error} = 0 unless $errors_count{$error};
3597             $errors_count{$error} += $count;
3598           }
3599           ($count,$error) = ($1,$2);
3600         }
3601         elsif (/Errors encountered/) {
3602           if ($error) {
3603             #Finished the section, so save our stored last error.
3604             $errors_count{$error} = 0 unless $errors_count{$error};
3605             $errors_count{$error} += $count;
3606           }
3607           last;
3608         }
3609       }
3610     }
3611
3612   }
3613 }
3614
3615 #######################################################################
3616 # parse_histogram($fh, \@delivered_interval_count);
3617 # Parse a histogram into the provided array of counters.
3618 #######################################################################
3619 sub parse_histogram {
3620   my($fh, $counters_aref) = @_;
3621
3622   #      Messages received per hour (each dot is 2 messages)
3623   #---------------------------------------------------
3624   #
3625   #00-01    106 .....................................................
3626   #01-02    103 ...................................................
3627
3628   my $reached_table = 0;
3629   while (<$fh>) {
3630     $reached_table = 1 if (/^00/);
3631     next unless $reached_table;
3632     print STDERR "Parsing $_" if $debug;
3633     if (/^(\d+):(\d+)\s+(\d+)/) {           #hh:mm start time format ?
3634       $$counters_aref[($1*60 + $2)/$hist_interval] += $3 if $hist_opt;
3635     }
3636     elsif (/^(\d+)-(\d+)\s+(\d+)/) {        #hh-hh start-end time format ?
3637       $$counters_aref[($1*60)/$hist_interval] += $3 if $hist_opt;
3638     }
3639     else {                                  #Finished the table ?
3640       last;
3641     }
3642   }
3643 }
3644
3645
3646 #######################################################################
3647 # update_relayed();
3648 #
3649 #  update_relayed($count,$sender,$recipient);
3650 #
3651 # Adds an entry into the %relayed hash. Currently only used when
3652 # merging reports.
3653 #######################################################################
3654 sub update_relayed {
3655   my($count,$sender,$recipient) = @_;
3656
3657   #When generating the key, put in the 'H=' and 'A=' which can be used
3658   #in searches.
3659   my $key = "H=$sender => H=$recipient";
3660   $key =~ s/ ([^=\s]+\@\S+|<>)/ A=$1/g;
3661   if (!defined $relay_pattern || $key !~ /$relay_pattern/o) {
3662     $relayed{$key} = 0 if !defined $relayed{$key};
3663     $relayed{$key} += $count;
3664   }
3665   else {
3666     $relayed_unshown += $count;
3667   }
3668 }
3669
3670
3671 #######################################################################
3672 # add_to_totals();
3673 #
3674 #  add_to_totals(\%totals,\@keys,$values);
3675 #
3676 # Given a line of space seperated values, add them into the provided hash using @keys
3677 # as the hash keys.
3678 #
3679 # If the value contains a '%', then the value is set rather than added. Otherwise, we
3680 # convert the value to bytes and gigs. The gigs get added to I<Key>-gigs.
3681 #######################################################################
3682 sub add_to_totals {
3683   my($totals_href,$keys_aref,$values) = @_;
3684   my(@values) = split(/\s+/,$values);
3685
3686   for(my $i = 0; $i < @values && $i < @$keys_aref; ++$i) {
3687     my $key = $keys_aref->[$i];
3688     if ($values[$i] =~ /%/) {
3689       $$totals_href{$key} = $values[$i];
3690     }
3691     else {
3692       $$totals_href{$key} = 0 unless ($$totals_href{$key});
3693       $$totals_href{"$key-gigs"} = 0 unless ($$totals_href{"$key-gigs"});
3694       un_round($values[$i], \$$totals_href{$key}, \$$totals_href{"$key-gigs"});
3695       print STDERR "Added $values[$i] to $key - $$totals_href{$key} , " . $$totals_href{"$key-gigs"} . "GB.\n" if $debug;
3696     }
3697   }
3698 }
3699
3700
3701 #######################################################################
3702 # line_to_hash();
3703 #
3704 #  line_to_hash(\%hash,\@keys,$line);
3705 #
3706 # Given a line of space seperated values, set them into the provided hash
3707 # using @keys as the hash keys.
3708 #######################################################################
3709 sub line_to_hash {
3710   my($href,$keys_aref,$values) = @_;
3711   my(@values) = split(/\s+/,$values);
3712   for(my $i = 0; $i < @values && $i < @$keys_aref; ++$i) {
3713     $$href{$keys_aref->[$i]} = $values[$i];
3714   }
3715 }
3716
3717
3718 #######################################################################
3719 # get_report_total();
3720 #
3721 #  $total = get_report_total(\%hash,$key);
3722 #
3723 # If %hash contains values split into Units and Gigs, we calculate and return
3724 #
3725 #   $hash{$key} + 1024*1024*1024 * $hash{"${key}-gigs"}
3726 #######################################################################
3727 sub get_report_total {
3728   no integer;
3729   my($hash_ref,$key) = @_;
3730   if ($$hash_ref{"${key}-gigs"}) {
3731     return $$hash_ref{$key} + $gig * $$hash_ref{"${key}-gigs"};
3732   }
3733   return $$hash_ref{$key} || 0;
3734 }
3735
3736 #######################################################################
3737 # html2txt();
3738 #
3739 #  $text_line = html2txt($html_line);
3740 #
3741 # Convert a line from html to text. Currently we just convert HTML tags to spaces
3742 # and convert &gt;, &lt;, and &nbsp; tags back.
3743 #######################################################################
3744 sub html2txt {
3745   ($_) = @_;
3746
3747   # Convert HTML tags to spacing. Note that the reports may contain <Userid> and
3748   # <Userid@Domain> words, so explicitly specify the HTML tags we will remove
3749   # (the ones used by this program). If someone is careless enough to have their
3750   # Userid the same as an HTML tag, there's not much we can do about it.
3751   s/<\/?(html|head|title|body|h\d|ul|li|a\s+|table|tr|td|th|pre|hr|p|br)\b.*?>/ /g;
3752
3753   s/\&lt\;/\</og;             #Convert '&lt;' to '<'.
3754   s/\&gt\;/\>/og;             #Convert '&gt;' to '>'.
3755   s/\&nbsp\;/ /og;            #Convert '&nbsp;' to ' '.
3756   return($_);
3757 }
3758
3759 #######################################################################
3760 # get_next_arg();
3761 #
3762 #  $arg = get_next_arg();
3763 #
3764 # Because eximstats arguments are often passed as variables,
3765 # we can't rely on shell parsing to deal with quotes. This
3766 # subroutine returns $ARGV[1] and does a shift. If $ARGV[1]
3767 # starts with a quote (' or "), and doesn't end in one, then
3768 # we append the next argument to it and shift again. We repeat
3769 # until we've got all of the argument.
3770 #
3771 # This isn't perfect as all white space gets reduced to one space,
3772 # but it's as good as we can get! If it's esential that spacing
3773 # be preserved precisely, then you get that by not using shell
3774 # variables.
3775 #######################################################################
3776 sub get_next_arg {
3777   my $arg = '';
3778   my $matched_pattern = 0;
3779   while ($ARGV[1]) {
3780     $arg .= ' ' if $arg;
3781     $arg .= $ARGV[1]; shift(@ARGV);
3782     if ($arg !~ /^['"]/) {
3783       $matched_pattern = 1;
3784       last;
3785     }
3786     if ($arg =~ s/^(['"])(.*)\1$/$2/) {
3787       $matched_pattern = 1;
3788       last;
3789     }
3790   }
3791   die "Mismatched argument quotes - <$arg>.\n" unless $matched_pattern;
3792   return $arg;
3793 }
3794
3795 #######################################################################
3796 # set_worksheet_line($ws_global, $startrow, $startcol, \@content, $format);
3797 #
3798 # set values to a sequence of cells in a row.
3799 #
3800 #######################################################################
3801 sub set_worksheet_line {
3802   my ($worksheet, $row, $col, $content, $format) = @_;
3803
3804   foreach my $token (@$content)
3805   {
3806      $worksheet->write($row, $col++, $token, $format );
3807   }
3808
3809 }
3810
3811 #######################################################################
3812 # @rcpt_times = parse_time_list($string);
3813 #
3814 # Parse a comma seperated list of time values in seconds given by
3815 # the user and fill an array.
3816 #
3817 # Return a default list if $string is undefined.
3818 # Return () if $string eq '0'.
3819 #######################################################################
3820 sub parse_time_list {
3821   my($string) = @_;
3822   if (! defined $string) {
3823     return(60, 5*60, 15*60, 30*60, 60*60, 3*60*60, 6*60*60, 12*60*60, 24*60*60);
3824   }
3825   my(@times) = split(/,/, $string);
3826   foreach my $q (@times) { $q = eval($q) + 0 }
3827   @times = sort { $a <=> $b } @times;
3828   @times = () if ($#times == 0 && $times[0] == 0);
3829   return(@times);
3830 }
3831
3832
3833 #######################################################################
3834 # initialise_rcpt_times($protocol);
3835 # Initialise an array of rcpt_times to 0 for the specified protocol.
3836 #######################################################################
3837 sub initialise_rcpt_times {
3838   my($protocol) = @_;
3839   for (my $i = 0; $i <= $#rcpt_times; ++$i) {
3840     $rcpt_times_bin{$protocol}[$i] = 0;
3841   }
3842   $rcpt_times_overflow{$protocol} = 0;
3843 }
3844
3845
3846 ##################################################
3847 #                 Main Program                   #
3848 ##################################################
3849
3850
3851 $last_timestamp = '';
3852 $last_date = '';
3853 $show_errors = 1;
3854 $show_relay = 1;
3855 $show_transport = 1;
3856 $topcount = 50;
3857 $local_league_table = 1;
3858 $include_remote_users = 0;
3859 $include_original_destination = 0;
3860 $hist_opt = 1;
3861 $volume_rounding = 1;
3862 $localtime_offset = calculate_localtime_offset();    # PH/FANF
3863
3864 $charts = 0;
3865 $charts_option_specified = 0;
3866 $chartrel = ".";
3867 $chartdir = ".";
3868
3869 @queue_times = parse_time_list();
3870 @rcpt_times = ();
3871 @delivery_times = ();
3872
3873 $last_offset = '';
3874 $offset_seconds = 0;
3875
3876 $row=1;
3877 $col=0;
3878 $col_hist=0;
3879 $run_hist=0;
3880 my(%output_files);     # What output files have been specified?
3881
3882 # Decode options
3883
3884 while (@ARGV > 0 && substr($ARGV[0], 0, 1) eq '-') {
3885   if    ($ARGV[0] =~ /^\-h(\d+)$/) { $hist_opt = $1 }
3886   elsif ($ARGV[0] =~ /^\-ne$/)     { $show_errors = 0 }
3887   elsif ($ARGV[0] =~ /^\-nr(.?)(.*)\1$/) {
3888     if ($1 eq "") { $show_relay = 0 } else { $relay_pattern = $2 }
3889   }
3890   elsif ($ARGV[0] =~ /^\-q([,\d\+\-\*\/]+)$/) { @queue_times = parse_time_list($1) }
3891   elsif ($ARGV[0] =~ /^-nt$/)       { $show_transport = 0 }
3892   elsif ($ARGV[0] =~ /^\-nt(.?)(.*)\1$/)
3893     {
3894     if ($1 eq "") { $show_transport = 0 } else { $transport_pattern = $2 }
3895     }
3896   elsif ($ARGV[0] =~ /^-t(\d+)$/)   { $topcount = $1 }
3897   elsif ($ARGV[0] =~ /^-tnl$/)      { $local_league_table = 0 }
3898   elsif ($ARGV[0] =~ /^-txt=?(\S*)$/)  { $txt_fh = get_filehandle($1,\%output_files) }
3899   elsif ($ARGV[0] =~ /^-html=?(\S*)$/) { $htm_fh = get_filehandle($1,\%output_files) }
3900   elsif ($ARGV[0] =~ /^-xls=?(\S*)$/) {
3901     if ($HAVE_Spreadsheet_WriteExcel) {
3902       $xls_fh = get_filehandle($1,\%output_files);
3903     }
3904     else {
3905       warn "WARNING: CPAN Module Spreadsheet::WriteExcel not installed. Obtain from www.cpan.org\n";
3906     }
3907   }
3908   elsif ($ARGV[0] =~ /^-merge$/)    { $merge_reports = 1 }
3909   elsif ($ARGV[0] =~ /^-charts$/)   {
3910     $charts = 1;
3911     warn "WARNING: CPAN Module GD::Graph::pie not installed. Obtain from www.cpan.org\n" unless $HAVE_GD_Graph_pie;
3912     warn "WARNING: CPAN Module GD::Graph::linespoints not installed. Obtain from www.cpan.org\n" unless $HAVE_GD_Graph_linespoints;
3913   }
3914   elsif ($ARGV[0] =~ /^-chartdir$/) { $chartdir = $ARGV[1]; shift; $charts_option_specified = 1; }
3915   elsif ($ARGV[0] =~ /^-chartrel$/) { $chartrel = $ARGV[1]; shift; $charts_option_specified = 1; }
3916   elsif ($ARGV[0] =~ /^-include_original_destination$/)    { $include_original_destination = 1 }
3917   elsif ($ARGV[0] =~ /^-cache$/)    { } #Not currently used.
3918   elsif ($ARGV[0] =~ /^-byhost$/)   { $do_sender{Host} = 1 }
3919   elsif ($ARGV[0] =~ /^-bydomain$/) { $do_sender{Domain} = 1 }
3920   elsif ($ARGV[0] =~ /^-byemail$/)  { $do_sender{Email} = 1 }
3921   elsif ($ARGV[0] =~ /^-byemaildomain$/)  { $do_sender{Edomain} = 1 }
3922   elsif ($ARGV[0] =~ /^-byedomain$/)  { $do_sender{Edomain} = 1 }
3923   elsif ($ARGV[0] =~ /^-bylocaldomain$/)  { $do_local_domain = 1 }
3924   elsif ($ARGV[0] =~ /^-emptyok$/)  { $emptyOK = 1 }
3925   elsif ($ARGV[0] =~ /^-nvr$/)      { $volume_rounding = 0 }
3926   elsif ($ARGV[0] =~ /^-show_rt([,\d\+\-\*\/]+)?$/) { @rcpt_times = parse_time_list($1) }
3927   elsif ($ARGV[0] =~ /^-show_dt([,\d\+\-\*\/]+)?$/) { @delivery_times = parse_time_list($1) }
3928   elsif ($ARGV[0] =~ /^-d$/)        { $debug = 1 }
3929   elsif ($ARGV[0] =~ /^--?h(elp)?$/){ help() }
3930   elsif ($ARGV[0] =~ /^-t_remote_users$/) { $include_remote_users = 1 }
3931   elsif ($ARGV[0] =~ /^-pattern$/)
3932     {
3933     push(@user_descriptions,get_next_arg());
3934     push(@user_patterns,get_next_arg());
3935     }
3936   elsif ($ARGV[0] =~ /^-utc$/)
3937     {
3938     # We don't need this value if the log is in UTC.
3939     $localtime_offset = undef;
3940     }
3941   else
3942     {
3943     print STDERR "Eximstats: Unknown or malformed option $ARGV[0]\n";
3944     help();
3945     }
3946   shift;
3947   }
3948
3949   # keep old default behaviour
3950   if (! ($xls_fh or $htm_fh or $txt_fh)) {
3951     $txt_fh = \*STDOUT;
3952   }
3953
3954   # Check that all the charts options are specified.
3955   warn "-charts option not specified. Use -help for help.\n" if ($charts_option_specified && ! $charts);
3956
3957   # Default to display tables by sending Host.
3958   $do_sender{Host} = 1 unless ($do_sender{Domain} || $do_sender{Email} || $do_sender{Edomain});
3959
3960   # prepare xls Excel Workbook
3961   if (defined $xls_fh) {
3962
3963     # Create a new Excel workbook
3964     $workbook  = Spreadsheet::WriteExcel->new($xls_fh);
3965
3966     # Add worksheets
3967     $ws_global = $workbook->addworksheet('Exim Statistik');
3968     # show $ws_global as initial sheet
3969     $ws_global->set_first_sheet();
3970     $ws_global->activate();
3971
3972     if ($show_relay) {
3973       $ws_relayed = $workbook->addworksheet('Relayed Messages');
3974       $ws_relayed->set_column(1, 2,  80);
3975     }
3976     if ($show_errors) {
3977       $ws_errors = $workbook->addworksheet('Errors');
3978     }
3979
3980
3981     # set column widths
3982     $ws_global->set_column(0, 2,  20); # Columns B-D width set to 30
3983     $ws_global->set_column(3, 3,  15); # Columns B-D width set to 30
3984     $ws_global->set_column(4, 4,  25); # Columns B-D width set to 30
3985
3986     # Define Formats
3987     $f_default = $workbook->add_format();
3988
3989     $f_header1 = $workbook->add_format();
3990     $f_header1->set_bold();
3991     #$f_header1->set_color('red');
3992     $f_header1->set_size('15');
3993     $f_header1->set_valign();
3994     # $f_header1->set_align('center');
3995     # $ws_global->write($row++, 2, "Testing Headers 1", $f_header1);
3996
3997     $f_header2 = $workbook->add_format();
3998     $f_header2->set_bold();
3999     $f_header2->set_size('12');
4000     $f_header2->set_valign();
4001     # $ws_global->write($row++, 2, "Testing Headers 2", $f_header2);
4002
4003     # Create another header2 for use in merged cells.
4004     $f_header2_m = $workbook->add_format();
4005     $f_header2_m->set_bold();
4006     $f_header2_m->set_size('8');
4007     $f_header2_m->set_valign();
4008     $f_header2_m->set_align('center');
4009
4010     $f_percent = $workbook->add_format();
4011     $f_percent->set_num_format('0.0%');
4012
4013     $f_headertab = $workbook->add_format();
4014     $f_headertab->set_bold();
4015     $f_headertab->set_valign();
4016     # $ws_global->write($row++, 2, "Testing Headers tab", $f_headertab);
4017
4018   }
4019
4020
4021 # Initialise the queue/delivery/rcpt time counters.
4022 for (my $i = 0; $i <= $#queue_times; $i++) {
4023   $qt_all_bin[$i] = 0;
4024   $qt_remote_bin[$i] = 0;
4025 }
4026 for (my $i = 0; $i <= $#delivery_times; $i++) {
4027   $dt_all_bin[$i] = 0;
4028   $dt_remote_bin[$i] = 0;
4029 }
4030 initialise_rcpt_times('all');
4031
4032
4033 # Compute the number of slots for the histogram
4034 if ($hist_opt > 0)
4035   {
4036   if ($hist_opt > 60 || 60 % $hist_opt != 0)
4037     {
4038     print STDERR "Eximstats: -h must specify a factor of 60\n";
4039     exit 1;
4040     }
4041   $hist_interval = 60/$hist_opt;                #Interval in minutes.
4042   $hist_number = (24*60)/$hist_interval;        #Number of intervals per day.
4043   @received_interval_count = (0) x $hist_number;
4044   @delivered_interval_count = (0) x $hist_number;
4045   my $user_pattern_index = 0;
4046   for (my $user_pattern_index = 0; $user_pattern_index <= $#user_patterns; ++$user_pattern_index) {
4047     @{$user_pattern_interval_count[$user_pattern_index]} = (0) x $hist_number;
4048   }
4049   @dt_all_bin = (0) x $hist_number;
4050   @dt_remote_bin = (0) x $hist_number;
4051 }
4052
4053 #$queue_unknown = 0;
4054
4055 $total_received_data = 0;
4056 $total_received_data_gigs = 0;
4057 $total_received_count = 0;
4058
4059 $total_delivered_data = 0;
4060 $total_delivered_data_gigs = 0;
4061 $total_delivered_messages = 0;
4062 $total_delivered_addresses = 0;
4063
4064 $qt_all_overflow = 0;
4065 $qt_remote_overflow = 0;
4066 $dt_all_overflow = 0;
4067 $dt_remote_overflow = 0;
4068 $delayed_count = 0;
4069 $relayed_unshown = 0;
4070 $message_errors = 0;
4071 $begin = "9999-99-99 99:99:99";
4072 $end = "0000-00-00 00:00:00";
4073 my($section,$type);
4074 foreach $section ('Received','Delivered','Temp Rejects', 'Rejects','Ham','Spam') {
4075   foreach $type ('Volume','Messages','Delayed','Failed','Hosts','Domains','Emails','Edomains') {
4076     $report_totals{$section}{$type} = 0;
4077   }
4078 }
4079
4080 # Generate our parser.
4081 my $parser = generate_parser();
4082
4083
4084
4085 if (@ARGV) {
4086   # Scan the input files and collect the data
4087   foreach my $file (@ARGV) {
4088     if ($file =~ /\.gz/) {
4089       unless (open(FILE,"gunzip -c $file |")) {
4090         print STDERR "Failed to gunzip -c $file: $!";
4091         next;
4092       }
4093     }
4094     elsif ($file =~ /\.Z/) {
4095       unless (open(FILE,"uncompress -c $file |")) {
4096         print STDERR "Failed to uncompress -c $file: $!";
4097         next;
4098       }
4099     }
4100     else {
4101       unless (open(FILE,$file)) {
4102         print STDERR "Failed to read $file: $!";
4103         next;
4104       }
4105     }
4106     #Now parse the filehandle, updating the global variables.
4107     parse($parser,\*FILE);
4108     close FILE;
4109   }
4110 }
4111 else {
4112   #No files provided. Parse STDIN, updating the global variables.
4113   parse($parser,\*STDIN);
4114 }
4115
4116
4117 if ($begin eq "9999-99-99 99:99:99" && ! $emptyOK) {
4118   print STDERR "**** No valid log lines read\n";
4119   exit 1;
4120 }
4121
4122 # Output our results.
4123 print_header();
4124 print_grandtotals();
4125
4126 # Print counts of user specified patterns if required.
4127 print_user_patterns() if @user_patterns;
4128
4129 # Print rejection reasons.
4130 # print_rejects();
4131
4132 # Print totals by transport if required.
4133 print_transport() if $show_transport;
4134
4135 # Print the deliveries per interval as a histogram, unless configured not to.
4136 # First find the maximum in one interval and scale accordingly.
4137 if ($hist_opt > 0) {
4138   print_histogram("Messages received", 'message', @received_interval_count);
4139   print_histogram("Deliveries", 'delivery', @delivered_interval_count);
4140 }
4141
4142 # Print times on queue if required.
4143 if ($#queue_times >= 0) {
4144   print_duration_table("Time spent on the queue", "all messages", \@queue_times, \@qt_all_bin,$qt_all_overflow);
4145   print_duration_table("Time spent on the queue", "messages with at least one remote delivery", \@queue_times, \@qt_remote_bin,$qt_remote_overflow);
4146 }
4147
4148 # Print delivery times if required.
4149 if ($#delivery_times >= 0) {
4150   print_duration_table("Delivery times", "all messages", \@delivery_times, \@dt_all_bin,$dt_all_overflow);
4151   print_duration_table("Delivery times", "messages with at least one remote delivery", \@delivery_times, \@dt_remote_bin,$dt_remote_overflow);
4152 }
4153
4154 # Print rcpt times if required.
4155 if ($#rcpt_times >= 0) {
4156   foreach my $protocol ('all', grep(!/^all$/, sort keys %rcpt_times_bin)) {
4157     print_duration_table("Receipt times", "$protocol messages", \@rcpt_times, $rcpt_times_bin{$protocol}, $rcpt_times_overflow{$protocol});
4158   }
4159 }
4160
4161 # Print relay information if required.
4162 print_relay() if $show_relay;
4163
4164 # Print the league tables, if topcount isn't zero.
4165 if ($topcount > 0) {
4166   my($ws_rej, $ws_top50, $ws_rej_row, $ws_top50_row, $ws_temp_rej, $ws_temp_rej_row);
4167   $ws_rej_row = $ws_temp_rej_row = $ws_top50_row = 0;
4168   if ($xls_fh) {
4169     $ws_top50 = $workbook->addworksheet('Deliveries');
4170     $ws_rej = $workbook->addworksheet('Rejections') if (%rejected_count_by_reason || %rejected_count_by_ip || %spam_count_by_ip);
4171     $ws_temp_rej = $workbook->addworksheet('Temporary Rejections') if (%temporarily_rejected_count_by_reason || %temporarily_rejected_count_by_ip);
4172   }
4173
4174   print_league_table("mail rejection reason", \%rejected_count_by_reason, undef, undef, undef, $ws_rej, \$ws_rej_row) if %rejected_count_by_reason;
4175   print_league_table("mail temporary rejection reason", \%temporarily_rejected_count_by_reason, undef, undef, undef, $ws_temp_rej, \$ws_temp_rej_row) if %temporarily_rejected_count_by_reason;
4176
4177   foreach ('Host','Domain','Email','Edomain') {
4178     next unless $do_sender{$_};
4179     print_league_table("sending \l$_", $received_count{$_}, undef, $received_data{$_},$received_data_gigs{$_}, $ws_top50, \$ws_top50_row);
4180   }
4181
4182   print_league_table("local sender", \%received_count_user, undef,
4183     \%received_data_user,\%received_data_gigs_user, $ws_top50, \$ws_top50_row) if (($local_league_table || $include_remote_users) && %received_count_user);
4184   foreach ('Host','Domain','Email','Edomain') {
4185     next unless $do_sender{$_};
4186     print_league_table("\l$_ destination", $delivered_messages{$_}, $delivered_addresses{$_}, $delivered_data{$_},$delivered_data_gigs{$_}, $ws_top50, \$ws_top50_row);
4187   }
4188   print_league_table("local destination", \%delivered_messages_user, \%delivered_addresses_user, \%delivered_data_user,\%delivered_data_gigs_user, $ws_top50, \$ws_top50_row) if (($local_league_table || $include_remote_users) && %delivered_messages_user);
4189   print_league_table("local domain destination", \%delivered_messages_local_domain, \%delivered_addresses_local_domain, \%delivered_data_local_domain,\%delivered_data_gigs_local_domain, $ws_top50, \$ws_top50_row) if (($local_league_table || $include_remote_users) && %delivered_messages_local_domain);
4190
4191   print_league_table("rejected ip", \%rejected_count_by_ip, undef, undef, undef, $ws_rej, \$ws_rej_row) if %rejected_count_by_ip;
4192   print_league_table("temporarily rejected ip", \%temporarily_rejected_count_by_ip, undef, undef, undef, $ws_rej, \$ws_rej_row) if %temporarily_rejected_count_by_ip;
4193   print_league_table("non-rejected spamming ip", \%spam_count_by_ip, undef, undef, undef, $ws_rej, \$ws_rej_row) if %spam_count_by_ip;
4194
4195 }
4196
4197 # Print the error statistics if required.
4198 print_errors() if $show_errors;
4199
4200 print $htm_fh "</body>\n</html>\n" if $htm_fh;
4201
4202
4203 $txt_fh->close if $txt_fh && ref $txt_fh;
4204 $htm_fh->close if $htm_fh;
4205
4206 if ($xls_fh) {
4207   # close Excel Workbook
4208   $ws_global->set_first_sheet();
4209   # FIXME: whyever - activate does not work :-/
4210   $ws_global->activate();
4211   $workbook->close();
4212 }
4213
4214
4215 # End of eximstats