/calamaris-2.59/calamaris

# · Perl · 3372 lines · 3172 code · 74 blank · 126 comment · 356 complexity · 8d9cb1a84b53ca09ed88d6b075ab5133 MD5 · raw file 

    

  1. #!/usr/bin/perl -w
    2. 

  2. #
    3. 

  3. # $Id: calamaris,v 2.59 2004/06/06 16:26:14 cord Exp $
    4. 

  4. #
    5. 

  5. # DESCRIPTION: calamaris - statistic package for diverse Proxy-Cache-Servers
    6. 

  6. #
    7. 

  7. # Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Cord Beermann
    8. 

  8. #
    9. 

  9. # URL: http://Calamaris.Cord.de/
    10. 

  10. # Announcement-Mailing-list: send Mail with 'subscribe' in the Mail-Body to
    11. 

  11. #			     Calamaris-announce-request@Cord.de
    12. 

  12. #
    13. 

  13. # AUTHOR: Cord Beermann <Cord@Wunder-Nett.org>
    14. 

  14. #
    15. 

  15. # Thanks to these contributors, bug reporters, and feature requesters:
    16. 

  16. #	John Heaton <John@MCC.ac.uk>
    17. 

  17. #	Andreas Lamprecht <Andreas.Lamprecht@siemens.at>
    18. 

  18. #	Kenny Ng <kennyng@cyberway.com.sg>
    19. 

  19. #	Claus Langhans <langhans@rz.uni-frankfurt.de>
    20. 

  20. #	Andreas Jung <ajung@sz-sb.de>
    21. 

  21. #	Ernst Heiri <heiri@switch.ch>
    22. 

  22. #	Shamil R. Yahin <SSHY@cclib.nsu.ru>
    23. 

  23. #	Thoralf Freitag <Thoralf.Freitag@isst.fhg.de>
    24. 

  24. #	Marco Paganini <paganini@paganini.net>
    25. 

  25. #	Michael Riedel <mr@fto.de>
    26. 

  26. #	Kris Boulez <krbou@pgsgent.be>
    27. 

  27. #	Mark Visser <mark@snt.utwente.nl>
    28. 

  28. #	Gary Palmer <gjp@erols.com>
    29. 

  29. #	Stefan Watermann <stefan@metronet.de>
    30. 

  30. #	Roar Smith <Roar.Smith@Ericsson.Dk>
    31. 

  31. #	Bernd Lienau <lienau@tli.de>
    32. 

  32. #	Gary Lindstrom <gplindstrom@exodus.nnc.edu>
    33. 

  33. #	Jost Krieger <Jost.Krieger@ruhr-uni-bochum.de>
    34. 

  34. #	Gerd Michael Hoffmann <Hoffmann@dvgw.de>
    35. 

  35. #	Gerold Meerkoetter <gerold@noc.fh-lippe.de>
    36. 

  36. #	Iain Lea <iain@bricbrac.de>
    37. 

  37. #	Emmanuel Adeline <emmanuel.adeline@mail.dotcom.fr>
    38. 

  38. #	John Line <webadm@info.cam.ac.uk>
    39. 

  39. #	Christos Cheretakis <xalkina@otenet.gr>
    40. 

  40. #	Ryan Donnelly <rmd@doit.wisc.edu>
    41. 

  41. #	Richard Vaughan <richard_vaughan@timewarp.co.uk>
    42. 

  42. #	Jonas Luster <jonas@nethammer.qad.org>
    43. 

  43. #	Clare Lahiff <Clare.Lahiff@anu.edu.au>
    44. 

  44. #	Toni Andjelkovic <toni@telecom.at>
    45. 

  45. #	Chris Teakle <ccteakle@its.uq.edu.au>
    46. 

  46. #	Dancer Vesperman <dancer@zeor.simegen.com>
    47. 

  47. #	Vincent ? <vincent@aib.net>
    48. 

  48. #	Elrond ? <Elrond@Wunder-Nett.org>
    49. 

  49. #	Holger Marzen <holger@marzen.de>
    50. 

  50. #	Panagiotis Christias <P.Christias@noc.ntua.gr>
    51. 

  51. #	Patrik Rak <patrik@ash.ein.cz>
    52. 

  52. #	Steve Snyder <swsnyder@insightbb.com>
    53. 

  53. #	Michael Copeland <michael.copeland@bell.ca>
    54. 

  54. #	Warren Brown <wbrown@inktomi.com>
    55. 

  55. #	Andy Nik <nik@che.nsk.su>
    56. 

  56. #	Frank Roechter <frank@fhd.de>
    57. 

  57. #	Antonio Casado Rodríguez <acasado@ualm.es>
    58. 

  58. #	Pavol Adamec <pavol_adamec@tempest.sk>
    59. 

  59. #	Ram Cherukuri <ram@edgix.com>
    60. 

  60. #	Marco Koch <MK@electricpaper.de>
    61. 

  61. #	Stephen Welker <stephen.welker@nemostar.com.au>
    62. 

  62. #	Christian Niederdorfer <christian.niederdorfer@infineon.com>
    63. 

  63. #	Klaus Brinkmeyer <Klaus_Brinkmeyer@inasys.de>
    64. 

  64. #	Filip ? <mechanix@digibel.org>
    65. 

  65. #	Matt Hubbard <m.hubbard@ic.ac.uk>
    66. 

  66. #	James Crocker <jcrocker@menasha.com>
    67. 

  67. #	Enrico Ardizzoni <enrico@unife.it>
    68. 

  68. #	Shawn Switenky <S.Switenky@telesat.ca>
    69. 

  69. #	Jarkko Saloranta <jjs@kpo.fi>
    70. 

  70. #	Jigar Rasalawala <jrasalawala@fourelle.com>
    71. 

  71. #	Philipp Frauenfelder <philipp.frauenfelder@swissonline.ch>
    72. 

  72. #	Alexey Markov <markov@crpi.ru>
    73. 

  73. #	Mark Güthling <privat@mague-pcservice.de>
    74. 

  74. #	Sergey Zarubin <serge-home@yandex.ru>
    75. 

  75. #	Helge Oldach <calamaris@oldach.net>
    76. 

  76. #	Michael R. Schwarzbach <spg@fs.tum.de>
    77. 

  77. #	Radu - Eosif Mihailescu <rmihailescu@lumina.ro>
    78. 

  78. #	Michael Pophal <michael.pophal@nefkom.net>
    79. 

  79. #	Steffen Sledz <sledz@zone42.org>
    80. 

  80. #	Kenytt Avery <kavery@willingminds.com>
    81. 

  81. #	SO Kwok Tsun <ktso@cuhk.edu.hk>
    82. 

  82. #	Chris Knight <chris@aims.com.au>
    83. 

  83. #	ycdtosa ? <ycdtosa@eupla.unizar.es>
    84. 

  84. #	Peter W. Osel <pwo@Infineon.COM>
    85. 

  85. #	Pawel Worach <pawel.worach@nordea.com>
    86. 

  86. 

  87. # This program is free software; you can redistribute it and/or modify it
    88. 

  88. # under the terms of the GNU General Public License as published by the Free
    89. 

  89. # Software Foundation; either version 2 of the License, or (at your option)
    90. 

  90. # any later version.
    91. 

  91. 

  92. # (If you modify and want to publish it under the name 'Calamaris', please ask
    93. 

  93. # me. I don't want to confuse the 'audience' with many different versions of
    94. 

  94. # the same name and/or Version number. (This is not part of the license, it
    95. 

  95. # is only a favour i asked of you.))
    96. 

  96. 

  97. # This program is distributed in the hope that it will be useful, but WITHOUT
    98. 

  98. # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    99. 

  99. # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
    100. 

  100. # more details.
    101. 

  101. 

  102. # You should have received a copy of the GNU General Public License along with
    103. 

  103. # this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    104. 

  104. # Place - Suite 330, Boston, MA 02111-1307, USA.
    105. 

  105. 

  106. 

  107. # A Perl script is "correct" if it gets the job done before your boss fires
    108. 

  108. # you.
    109. 

  109. #   -- 'Programming Perl Second Edition'
    110. 

  110. #	by Larry Wall, Tom Christiansen & Randal L. Schwartz
    111. 

  111. 

  112. # If you have to remove this, read the README!
    113. 

  113. require 5.002;
    114. 

  114. use vars qw($opt_3 $opt_a $opt_b $opt_c $opt_C $opt_d $opt_D $opt_f $opt_F
    115. 

  115. 	    $opt_h $opt_H $opt_i $opt_I $opt_l $opt_L $opt_m $opt_M $opt_n
    116. 

  116. 	    $opt_N $opt_o $opt_O $opt_p $opt_P $opt_r $opt_R $opt_s $opt_S
    117. 

  117. 	    $opt_t $opt_T $opt_u $opt_U $opt_v $opt_V $opt_w $opt_W $opt_z);
    118. 

  118. use Getopt::Std;
    119. 

  119. use Sys::Hostname;
    120. 

  120. 

  121. getopts('3ab:cCd:D:f:F:hH:i:I:l:LmM:nN:o:Op:P:r:R:sS:t:T:uU:vVwWz');
    122. 

  122. 

  123. if ( $opt_b and $opt_b < 1 ) {
    124. 

  124.   print STDERR "$0: wrong value at -b -option: \"$opt_b\"\n\n";
    125. 

  125.   $usage_err = 1;
    126. 

  126. } else {
    127. 

  127.   $| = 1;
    128. 

  128. }
    129. 

  129. 

  130. if ($opt_U) {
    131. 

  131.   unless ( $opt_U =~ m#^[KMGT]$# ) {
    132. 

  132.     print STDERR "$0: wrong value at -U -option: \"$opt_U\"\n\n";
    133. 

  133.     $usage_err = 1;
    134. 

  134.   }
    135. 

  135. } else {
    136. 

  136.   $opt_U = '';
    137. 

  137. }
    138. 

  138. 

  139. if ($opt_D) {
    140. 

  140.   if ( $opt_D <= 1 ) {
    141. 

  141.     print STDERR "$0: wrong value at -D -option: \"$opt_D\"\n\n";
    142. 

  142.     $usage_err = 1;
    143. 

  143.   }
    144. 

  144. }
    145. 

  145. 

  146. if ($opt_H) {
    147. 

  147.   if ( $opt_H eq '1' or $opt_H eq 'lookup' ) {
    148. 

  148.     $host_name = hostname() . ' ';
    149. 

  149.   } else {
    150. 

  150.     $host_name = $opt_H . ' ';
    151. 

  151.   }
    152. 

  152. } else {
    153. 

  153.   $host_name = '';
    154. 

  154. }
    155. 

  155. 

  156. if ( $opt_N and $opt_N != -1 and $opt_N < 2 ) {
    157. 

  157.   print STDERR "$0: wrong value at -N -option: \"$opt_N\"\n\n";
    158. 

  158.   $usage_err = 1;
    159. 

  159. }
    160. 

  160. 

  161. if ($opt_I) {
    162. 

  162.   use Time::Local;
    163. 

  163.   ( $interval_begin, $interval_end ) = split ( '-', $opt_I );
    164. 

  164.   if ($interval_begin > $interval_end) { 
    165. 

  165.     print STDERR "$0: wrong value at -I -option: \"$opt_I\". Interval begin newer than interval end!\n\n";
    166. 

  166.     $usage_err = 1;
    167. 

  167.   }
    168. 

  168.   if ( $interval_begin =~ m#^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$# ) {
    169. 

  169.     $interval_begin = timegm( $6, $5, $4, $3, $2 - 1, $1 - 1900 );
    170. 

  170.   } elsif ( $interval_begin eq '' ) {
    171. 

  171.     $interval_begin = 0;
    172. 

  172.   } else {
    173. 

  173.     print STDERR "$0: wrong value at -I -option: \"$opt_I\"\n\n";
    174. 

  174.     $usage_err = 1;
    175. 

  175.   }
    176. 

  176.   if ( $interval_end =~ m#^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$# ) {
    177. 

  177.     $interval_end = timegm( $6, $5, $4, $3, $2 - 1, $1 - 1900 );
    178. 

  178.   } elsif ( $interval_end eq '' ) {
    179. 

  179.     $interval_end = 9999999999;
    180. 

  180.   } else {
    181. 

  181.     print STDERR "$0: wrong value at -I -option: \"$opt_I\"\n\n";
    182. 

  182.     $usage_err = 1;
    183. 

  183.   }
    184. 

  184. }
    185. 

  185. 

  186. if ($opt_F) {
    187. 

  187.   foreach $output ( split ( /\s*,\s*/, $opt_F ) ) {
    188. 

  188.     if ( $output eq 'mail' ) {
    189. 

  189.       $outtype_mail = 1;
    190. 

  190.     } elsif ( $output eq 'html' ) {
    191. 

  191.       $outtype_html = 1;
    192. 

  192.     } elsif ( $output eq 'html-embed' ) {
    193. 

  193.       $outtype_htmlembed = 1;
    194. 

  194.     } elsif ( $output eq 'unformatted' ) {
    195. 

  195.       $outtype_unformatted = 1;
    196. 

  196.     } else {
    197. 

  197.       print STDERR "$0: unknown output-format: $output\n\n";
    198. 

  198.       $usage_err = 1;
    199. 

  199.     }
    200. 

  200.   }
    201. 

  201. }
    202. 

  202. 

  203. # remove this at end of 2003
    204. 

  204. if ($opt_3) {
    205. 

  205.   print STDERR "$0: obsoleted option -3: use -N3 instead\n\n";
    206. 

  206.   $usage_err = 1;
    207. 

  207. }
    208. 

  208. 

  209. # remove at end of 2004
    210. 

  210. if ( defined $opt_f and $opt_f =~ m#^squid-(mime|smartfilter)$# ) {
    211. 

  211.   print STDERR "$0: obsoleted input format '$opt_f':
    212. 

  212. 	use -f 'squid-extended' instead\n\n";
    213. 

  213.   $usage_err = 1;
    214. 

  214. }
    215. 

  215. 

  216. # change at end of 2003
    217. 

  217. # remove at end of 2004
    218. 

  218. if ( defined $opt_w ) {
    219. 

  219.   print STDERR "$0: obsoleted output format switch -w:
    220. 

  220.         use -F 'html' instead\n\n";
    221. 

  221.   $outtype_html = 1;
    222. 

  222.   $output_warn = 1;
    223. 

  223. }
    224. 

  224. 

  225. # change at end of 2003
    226. 

  226. # remove at end of 2004
    227. 

  227. if ( defined $opt_W ) {
    228. 

  228.   print STDERR "$0: obsoleted output format switch -W:
    229. 

  229. 	use -F 'html-embed' instead\n\n";
    230. 

  230.   $outtype_htmlembed = 1;
    231. 

  231.   $output_warn = 1;
    232. 

  232. }
    233. 

  233. 

  234. # change at end of 2003
    235. 

  235. # remove at end of 2004
    236. 

  236. if ( defined $opt_m ) {
    237. 

  237.   print STDERR "$0: obsoleted output format switch -m:
    238. 

  238. 	use -F 'mail' instead\n\n";
    239. 

  239.   $outtype_mail = 1;
    240. 

  240.   $output_warn = 1;
    241. 

  241. }
    242. 

  242. 

  243. $sortorder = '';
    244. 

  244. $sortorder = '_size' if ($opt_O);
    245. 

  245. 

  246. if ($opt_a) {
    247. 

  247.   $opt_s = 1;
    248. 

  248.   $opt_P = 60 unless $opt_P;
    249. 

  249.   $opt_d = 20 unless $opt_d;
    250. 

  250.   $opt_r = 20 unless $opt_r;
    251. 

  251.   $opt_t = 20 unless $opt_t;
    252. 

  252.   $opt_D = 10 unless $opt_D;
    253. 

  253. }
    254. 

  254. 

  255. $opt_N = 2 unless $opt_N;
    256. 

  256. $opt_T = 0 unless $opt_T;
    257. 

  257. $opt_r = $opt_R unless $opt_r;
    258. 

  258. 

  259. $P = $opt_P ? "$opt_P minute" : '60 minute';
    260. 

  260. if ( defined($opt_P) and ($opt_P%60) == 0 ) { $P =  $opt_P/60 . " hour" };
    261. 

  261. if ( defined($opt_P) and ($opt_P%1440) == 0 ) { $P =  $opt_P/1440 . " day" };
    262. 

  262. 

  263. if ( $opt_N == -1 or $opt_N > 2 ) {
    264. 

  264.   if ( $opt_N == 3 ) {
    265. 

  265.     $N = '3rd';
    266. 

  266.   } elsif ( $opt_N == -1 ) {
    267. 

  267.     $N = 'all';
    268. 

  268.   } else {
    269. 

  269.     $N = $opt_N . 'th';
    270. 

  270.   }
    271. 

  271. } else {
    272. 

  272.   $N = '2nd';
    273. 

  273. }
    274. 

  274. 

  275. @reports = (
    276. 

  276. 	    'Summary', 'Incoming request peak per protocol',
    277. 

  277. 	    'Incoming transfer volume per protocol',
    278. 

  278. 	    'Incoming requests by method', 'Incoming UDP-requests by status',
    279. 

  279. 	    'Incoming TCP-requests by status', 'Outgoing requests by status',
    280. 

  280. 	    'Outgoing requests by destination',
    281. 

  281. 	    "Request-destinations by ${N}-level-domain",
    282. 

  282. 	    'Request-destinations by toplevel-domain', 'TCP-Request-protocol',
    283. 

  283. 	    'Requested content-type', 'Requested extensions',
    284. 

  284. 	    'Incoming UDP-requests by host', 'Incoming TCP-requests by host',
    285. 

  285. 	    'Distribution Histogram', "Performance in $P steps"
    286. 

  286. 	    );
    287. 

  287. 

  288. $VERSION='Calamaris $Revision: 2.59 $';
    289. 

  289. 

  290. $COPYRIGHT =
    291. 

  291. 'Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Cord Beermann.
    292. 

  292. Calamaris comes with ABSOLUTELY NO WARRANTY. It is free software, and you are
    293. 

  293. welcome to redistribute it under certain conditions. See source for details.
    294. 

  294. Calamaris-Homepage: http://Calamaris.Cord.de/';
    295. 

  295. 

  296. $USAGE = 'Usage: cat log | ' . $0 . ' [switches]
    297. 

    298. 

  298. Reports:
    299. 

  299. -a	all	(extracts all reports available,
    300. 

  300. 		 -a equals -D 10 -d 20 -P 60 -r 20 -s -t 20)
    301. 

  301. -d n	domain	(show n Top-level and n second-level destinations,
    302. 

  302. 		 -1 = unlimited)
    303. 

  303. -p type	peak	(measure peak requests)
    304. 

  304. 		old = make old request-peak mesurement
    305. 

  305. 		new = make new request&byte-peak measurement
    306. 

  306. 		(both slow Calamaris significantly down.)
    307. 

  307. -P n	Performance (show throughput data for every n minutes)
    308. 

  308. -r n	requester (show n Requesters, -1 = unlimited)
    309. 

  309. -R n	targets for requester (show n targets for every Requester,
    310. 

  310. 		-1 = unlimited), implies -r (*)
    311. 

  311. -s	status	(show verbose status reports)
    312. 

  312. -t n	type	(show n content-type, n extensions and requested protocols,
    313. 

  313. 		 -1 = unlimited)
    314. 

  314. -D n    Distribution Histogram (shows size-based distribution of requested
    315. 

  315. 		objects, smaller numbers result in more verbose reports.
    316. 

  316. 		choose 2, 10 or 100 for useful output. (You can also play
    317. 

  317. 		with this ;-))
    318. 

  318. 

  319. Input:
    320. 

  320. -z	zero	(no input via stdin)
    321. 

  321. -f type	format	(sets the type of input logfiles)
    322. 

  322. 		auto = tries to guess the input format
    323. 

  323. 		(This is the Default)
    324. 

  324. 		squid = Native-Logfile derived from Squid V1.1.beta26-V2.x
    325. 

  325. 		squid-extended = Native-Logfile with log_mime_hdrs enabled
    326. 

  326. 			derived from Squid V1.1.beta26-V2.x (*)
    327. 

  327. 			or Cisco Content Engines (*)
    328. 

  328. 			or Squid with SmartFilter-patch (*)
    329. 

  329. 		squid-old = Native-Logfile derived from Squid
    330. 

  330. 			V1.1.alpha1-V1.1.beta25
    331. 

  331. 		nc = Squid-style Logfiles derived from NetCache V?? (<5.x)
    332. 

  332. 		its = Logfiles derived from Inktomi Traffic Server
    333. 

  333. 		elff = Extended Logfile Format (i.e Compaq Tasksmart, Novell
    334. 

  334. 			Internet Caching System, NetCache 5.x)
    335. 

  335. 		nse = Netscape Extended-1/2 Logfile Format
    336. 

  336. 

  337. Output: (Default is plain formatted text)
    338. 

  338. -F type	Format	  (output format (comma-seperated list))
    339. 

  339. 		  mail = mail format
    340. 

  340. 		  html = HTML format
    341. 

  341. 		  html-embed = HTML format without HTML-headers
    342. 

  342. 		  unformatted = plain unformatted output
    343. 

  343. -l string logo	  (add this string to the head of the report. works only in
    344. 

  344. 		   combination with -F html)
    345. 

  345. -M string Meta    (includes the given strings in html-<head>. works only in
    346. 

  346. 		   combination with -F html)
    347. 

  347. -H name Host-name (a name for the Output, -H \'lookup\' issues a lookup for
    348. 

  348. 		   the current host)
    349. 

  349. -O	Order	  (changes the sort order in the reports to request size,
    350. 

  350. 		   default is sorting by number of requests)
    351. 

  351. -N n	N-level   (change all 2nd-level-reports to N-level-reports. N can be
    352. 

  352. 		   any number from 2 up. -1 means full report.)
    353. 

  353. -U string Unit    (define the Unit for the Byte-values, else it will be auto)
    354. 

  354. 		   K(ilo), M(ega), G(iga), T(era)
    355. 

  355. -S list Show      (Shows only the defined reports (comma-seperated list) in the
    356. 

  356. 		   specified order.) The following numbers are defined:
    357. 

  357. ';
    358. 

  358. foreach ( 0 .. $#reports ) {
    359. 

  359.   $USAGE .= "\t\t$_\t$reports[$_]\n";
    360. 

  360. }
    361. 

  361. 

  362. $USAGE .=
    363. 

  363. '		(Note: only putting out one report does not speed up Calamaris
    364. 

  364. 		 as the internal operations were done based on the
    365. 

  365. 		 report-switches. Default: Reports are displayed based on
    366. 

  366. 		 activated reports.)
    367. 

  367. 

  368. Caching:
    369. 

  369. -i file	input-file (input-datafile for caching, to add many files separate
    370. 

  370. 		    them with a \':\')
    371. 

  371. -o file	output-file (output-datafile for caching, can be the same as -i)
    372. 

  372. 

  373. Misc:
    374. 

  374. -n	no-lookup (don\'t look IP-Numbers up)
    375. 

  375. -T n	Time	(adjust the Performance-Report in minutes)
    376. 

  376. -c	case	(switch to case-insensitive (useful for extensions-report))
    377. 

  377. -u	user	(use ident information if available) (*)
    378. 

  378. -I t-t  Interval (defines which time-interval should be parsed)
    379. 

  379. 		  t has to be the format yyyymmddhhmmss
    380. 

  380. 		  omitting the beginning or ending is allowed.
    381. 

  381. 

  382. -b n	benchmark (prints a hash-sign (#) to stderr for each n lines
    383. 

  383. 		   processed)
    384. 

  384. -v	verbose (print information what Calamaris is doing. Useful for
    385. 

  385. 		 debugging.)
    386. 

  386. -L	Loop (dumps the generated internal loop to STDERR for debugging.)
    387. 

  387. 

  388. -C	copyright (prints the copyright)
    389. 

  389. -h	help	(prints out this message)
    390. 

  390. -V	Version (prints version-info)
    391. 

  391. 

  392. (*) These options break the privacy of your users. Please read the README
    393. 

  393. on this.';
    394. 

    395. 

  395. print "$USAGE\n\n" if $opt_h;
    396. 

  396. print "$VERSION\n\n" if $opt_V;
    397. 

  397. print "$COPYRIGHT\n\n" if $opt_C or $opt_h or $opt_V;
    398. 

  398. 

  399. exit 0 if $opt_h or $opt_C or $opt_V;
    400. 

  400. 

  401. if ($usage_err) {
    402. 

  402.   print STDERR "run '$0 -h' for help.\n\n";
    403. 

  403.   exit 1;
    404. 

  404. }
    405. 

  405. 

  406. # initialize variables
    407. 

  407. $counter = $hier = $hier_direct = $hier_direct_size = $hier_direct_time =
    408. 

  408.   $hier_parent = $hier_parent_size = $hier_parent_time = $hier_sibling =
    409. 

  409.   $hier_sibling_size = $hier_sibling_time = $hier_size = $hier_time =
    410. 

  410.   $invalid = $peak_all_min = $peak_all_min_time = $peak_all_sec =
    411. 

  411.   $peak_all_sec_time = $peak_all_hour = $peak_all_hour_time = $peak_tcp_min =
    412. 

  412.   $peak_tcp_min_time = $peak_tcp_sec = $peak_tcp_sec_time = $peak_tcp_hour =
    413. 

  413.   $peak_tcp_hour_time = $peak_udp_min = $peak_udp_min_time = $peak_udp_sec =
    414. 

  414.   $peak_udp_sec_time = $peak_udp_hour = $peak_udp_hour_time = $size =
    415. 

  415.   $skipped = $tcp = $tcp_hit = $tcp_hit_size = $tcp_hit_time = $tcp_miss =
    416. 

  416.   $tcp_miss_none = $tcp_miss_none_size = $tcp_miss_none_time =
    417. 

  417.   $tcp_miss_size = $tcp_miss_time = $tcp_size = $tcp_time = $time =
    418. 

  418.   $time_end = $time_run = $udp = $udp_hit = $udp_hit_size = $udp_hit_time =
    419. 

  419.   $udp_miss = $udp_miss_size = $udp_miss_time = $udp_size = $udp_time = 0;
    420. 

  420. $time_begin = 9999999999;
    421. 

  421. @months = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
    422. 

  422. 

  423. ### Read Cache.
    424. 

  424. if ($opt_i) {
    425. 

  425.   foreach $file ( split ':', $opt_i ) {
    426. 

  426.     open( CACHE, "$file" ) or die ("$0: can't open $file for reading: $!\n");
    427. 

  427.     while (<CACHE>) {
    428. 

  428.       chomp;
    429. 

  429.       @cache = split '?';
    430. 

  430.       $x = shift (@cache);
    431. 

  431.       next unless ($x);
    432. 

  432.       if ( $x eq 'A' and $#cache == 39 ) {
    433. 

  433. 	$time_begin = $cache[0] if $cache[0] < $time_begin;
    434. 

  434. 	$time_end = $cache[1] if $cache[1] > $time_end;
    435. 

  435. 	$counter += $cache[2];
    436. 

  436. 	$size += $cache[3];
    437. 

  437. 	$time += $cache[4];
    438. 

  438. 	$invalid += $cache[5];
    439. 

  439. 	$time_run += $cache[6];
    440. 

  440. 	$udp += $cache[7];
    441. 

  441. 	$udp_size += $cache[8];
    442. 

  442. 	$udp_time += $cache[9];
    443. 

  443. 	$udp_hit += $cache[10];
    444. 

  444. 	$udp_hit_size += $cache[11];
    445. 

  445. 	$udp_hit_time += $cache[12];
    446. 

  446. 	$udp_miss += $cache[13];
    447. 

  447. 	$udp_miss_size += $cache[14];
    448. 

  448. 	$udp_miss_time += $cache[15];
    449. 

  449. 	$tcp += $cache[16];
    450. 

  450. 	$tcp_size += $cache[17];
    451. 

  451. 	$tcp_time += $cache[18];
    452. 

  452. 	$tcp_hit += $cache[19];
    453. 

  453. 	$tcp_hit_size += $cache[20];
    454. 

  454. 	$tcp_hit_time += $cache[21];
    455. 

  455. 	$tcp_miss += $cache[22];
    456. 

  456. 	$tcp_miss_size += $cache[23];
    457. 

  457. 	$tcp_miss_time += $cache[24];
    458. 

  458. 	$tcp_miss_none += $cache[25];
    459. 

  459. 	$tcp_miss_none_size += $cache[26];
    460. 

  460. 	$tcp_miss_none_time += $cache[27];
    461. 

  461. 	$hier += $cache[28];
    462. 

  462. 	$hier_size += $cache[29];
    463. 

  463. 	$hier_time += $cache[30];
    464. 

  464. 	$hier_direct += $cache[31];
    465. 

  465. 	$hier_direct_size += $cache[32];
    466. 

  466. 	$hier_direct_time += $cache[33];
    467. 

  467. 	$hier_sibling += $cache[34];
    468. 

  468. 	$hier_sibling_size += $cache[35];
    469. 

  469. 	$hier_sibling_time += $cache[36];
    470. 

  470. 	$hier_parent += $cache[37];
    471. 

  471. 	$hier_parent_size += $cache[38];
    472. 

  472. 	$hier_parent_time += $cache[39];
    473. 

  473.       } elsif ( $x eq 'B' and $#cache == 17 ) {
    474. 

  474. 	unless ( $peak_udp_sec == 0 ) {
    475. 

  475. 	  warn("multiple cache files.\n") if $opt_v;
    476. 

  476. 	  $peak_warn = 'Peak values are possibly wrong!';
    477. 

  477. 	}
    478. 

  478. 	if ( $peak_udp_sec < $cache[0] ) {
    479. 

  479. 	  $peak_udp_sec = $cache[0];
    480. 

  480. 	  $peak_udp_sec_time = $cache[1];
    481. 

  481. 	}
    482. 

  482. 	if ( $peak_udp_min < $cache[2] ) {
    483. 

  483. 	  $peak_udp_min = $cache[2];
    484. 

  484. 	  $peak_udp_min_time = $cache[3];
    485. 

  485. 	}
    486. 

  486. 	$peak_udp_hour{ $cache[5] } = 0
    487. 

  487. 	  unless defined $peak_udp_hour{ $cache[5] };
    488. 

  488. 	$peak_udp_hour{ $cache[5] } += $cache[4];
    489. 

  489. 	if ( $peak_tcp_sec < $cache[6] ) {
    490. 

  490. 	  $peak_tcp_sec = $cache[6];
    491. 

  491. 	  $peak_tcp_sec_time = $cache[7];
    492. 

  492. 	}
    493. 

  493. 	if ( $peak_tcp_min < $cache[8] ) {
    494. 

  494. 	  $peak_tcp_min = $cache[8];
    495. 

  495. 	  $peak_tcp_min_time = $cache[9];
    496. 

  496. 	}
    497. 

  497. 	$peak_tcp_hour{ $cache[11] } = 0
    498. 

  498. 	  unless defined $peak_tcp_hour{ $cache[11] };
    499. 

  499. 	$peak_tcp_hour{ $cache[11] } += $cache[10];
    500. 

  500. 	if ( $peak_all_sec < $cache[12] ) {
    501. 

  501. 	  $peak_all_sec = $cache[12];
    502. 

  502. 	  $peak_all_sec_time = $cache[13];
    503. 

  503. 	}
    504. 

  504. 	if ( $peak_all_min < $cache[14] ) {
    505. 

  505. 	  $peak_all_min = $cache[14];
    506. 

  506. 	  $peak_all_min_time = $cache[15];
    507. 

  507. 	}
    508. 

  508. 	$peak_all_hour{ $cache[17] } = 0
    509. 

  509. 	  unless defined $peak_all_hour{ $cache[17] };
    510. 

  510. 	$peak_all_hour{ $cache[17] } += $cache[16];
    511. 

  511.       } elsif ( $x eq 'B' and $#cache == 23 ) {
    512. 

  512. 	unless ( $peak_udp_sec == 0 ) {
    513. 

  513. 	  warn("multiple cache files.\n") if $opt_v;
    514. 

  514. 	  $peak_warn = 'Peak values are possibly wrong!';
    515. 

  515. 	}
    516. 

  516. 	if ( $peak_udp_sec < $cache[0] ) {
    517. 

  517. 	  $peak_udp_sec = $cache[0];
    518. 

  518. 	  $peak_udp_sec_time = $cache[1];
    519. 

  519. 	}
    520. 

  520. 	if ( $peak_udp_min < $cache[2] ) {
    521. 

  521. 	  $peak_udp_min = $cache[2];
    522. 

  522. 	  $peak_udp_min_time = $cache[3];
    523. 

  523. 	}
    524. 

  524. 	$peak_udp_hour{ $cache[5] } = 0
    525. 

  525. 	  unless defined $peak_udp_hour{ $cache[5] };
    526. 

  526. 	$peak_udp_hour{ $cache[5] } += $cache[4];
    527. 

  527. 	$peak_udp_hour_size{ $cache[7] } = 0
    528. 

  528. 	  unless defined $peak_udp_hour_size{ $cache[7] };
    529. 

  529. 	$peak_udp_hour_size{ $cache[7] } += $cache[6];
    530. 

  530. 	if ( $peak_tcp_sec < $cache[8] ) {
    531. 

  531. 	  $peak_tcp_sec = $cache[8];
    532. 

  532. 	  $peak_tcp_sec_time = $cache[9];
    533. 

  533. 	}
    534. 

  534. 	if ( $peak_tcp_min < $cache[10] ) {
    535. 

  535. 	  $peak_tcp_min = $cache[10];
    536. 

  536. 	  $peak_tcp_min_time = $cache[11];
    537. 

  537. 	}
    538. 

  538. 	$peak_tcp_hour{ $cache[13] } = 0
    539. 

  539. 	  unless defined $peak_tcp_hour{ $cache[13] };
    540. 

  540. 	$peak_tcp_hour{ $cache[13] } += $cache[12];
    541. 

  541. 	$peak_tcp_hour_size{ $cache[15] } = 0
    542. 

  542. 	  unless defined $peak_tcp_hour_size{ $cache[15] };
    543. 

  543. 	$peak_tcp_hour_size{ $cache[15] } += $cache[14];
    544. 

  544. 	if ( $peak_all_sec < $cache[16] ) {
    545. 

  545. 	  $peak_all_sec = $cache[16];
    546. 

  546. 	  $peak_all_sec_time = $cache[17];
    547. 

  547. 	}
    548. 

  548. 	if ( $peak_all_min < $cache[18] ) {
    549. 

  549. 	  $peak_all_min = $cache[18];
    550. 

  550. 	  $peak_all_min_time = $cache[19];
    551. 

  551. 	}
    552. 

  552. 	$peak_all_hour{ $cache[21] } = 0
    553. 

  553. 	  unless defined $peak_all_hour{ $cache[21] };
    554. 

  554. 	$peak_all_hour{ $cache[21] } += $cache[20];
    555. 

  555. 	$peak_all_hour_size{ $cache[23] } = 0
    556. 

  556. 	  unless defined $peak_all_hour_size{ $cache[23] };
    557. 

  557. 	$peak_all_hour_size{ $cache[23] } += $cache[22];
    558. 

  558.       } elsif ( $x eq 'C' and $#cache == 3 ) {
    559. 

  559. 	$y = shift (@cache);
    560. 

  560. 	$method{$y} = $method_size{$y} = $method_time{$y} = 0
    561. 

  561. 	  unless defined $method{$y};
    562. 

  562. 	$method{$y} += $cache[0];
    563. 

  563. 	$method_size{$y} += $cache[1];
    564. 

  564. 	$method_time{$y} += $cache[2];
    565. 

  565.       } elsif ( $x eq 'D' and $#cache == 3 ) {
    566. 

  566. 	$y = shift (@cache);
    567. 

  567. 	$udp_hit{$y} = $udp_hit_size{$y} = $udp_hit_time{$y} = 0
    568. 

  568. 	  unless defined $udp_hit{$y};
    569. 

  569. 	$udp_hit{$y} += $cache[0];
    570. 

  570. 	$udp_hit_size{$y} += $cache[1];
    571. 

  571. 	$udp_hit_time{$y} += $cache[2];
    572. 

  572.       } elsif ( $x eq 'E' and $#cache == 3 ) {
    573. 

  573. 	$y = shift (@cache);
    574. 

  574. 	$udp_miss{$y} = $udp_miss_size{$y} = $udp_miss_time{$y} = 0
    575. 

  575. 	  unless defined $udp_miss{$y};
    576. 

  576. 	$udp_miss{$y} += $cache[0];
    577. 

  577. 	$udp_miss_size{$y} += $cache[1];
    578. 

  578. 	$udp_miss_time{$y} += $cache[2];
    579. 

  579.       } elsif ( $x eq 'F' and $#cache == 3 ) {
    580. 

  580. 	$y = shift (@cache);
    581. 

  581. 	$tcp_hit{$y} = $tcp_hit_size{$y} = $tcp_hit_time{$y} = 0
    582. 

  582. 	  unless defined $tcp_hit{$y};
    583. 

  583. 	$tcp_hit{$y} += $cache[0];
    584. 

  584. 	$tcp_hit_size{$y} += $cache[1];
    585. 

  585. 	$tcp_hit_time{$y} += $cache[2];
    586. 

  586.       } elsif ( $x eq 'G' and $#cache == 3 ) {
    587. 

  587. 	$y = shift (@cache);
    588. 

  588. 	$tcp_miss{$y} = $tcp_miss_size{$y} = $tcp_miss_time{$y} = 0
    589. 

  589. 	  unless defined $tcp_miss{$y};
    590. 

  590. 	$tcp_miss{$y} += $cache[0];
    591. 

  591. 	$tcp_miss_size{$y} += $cache[1];
    592. 

  592. 	$tcp_miss_time{$y} += $cache[2];
    593. 

  593.       } elsif ( $x eq 'H' and $#cache == 3 ) {
    594. 

  594. 	$y = shift (@cache);
    595. 

  595. 	$tcp_miss_none{$y} = $tcp_miss_none_size{$y} =
    596. 

  596. 	  $tcp_miss_none_time{$y} = 0
    597. 

  597. 	  unless defined $tcp_miss_none{$y};
    598. 

  598. 	$tcp_miss_none{$y} += $cache[0];
    599. 

  599. 	$tcp_miss_none_size{$y} += $cache[1];
    600. 

  600. 	$tcp_miss_none_time{$y} += $cache[2];
    601. 

  601.       } elsif ( $x eq 'I' and $#cache == 3 ) {
    602. 

  602. 	$y = shift (@cache);
    603. 

  603. 	$hier_direct{$y} = $hier_direct_size{$y} = $hier_direct_time{$y} = 0
    604. 

  604. 	  unless defined $hier_direct{$y};
    605. 

  605. 	$hier_direct{$y} += $cache[0];
    606. 

  606. 	$hier_direct_size{$y} += $cache[1];
    607. 

  607. 	$hier_direct_time{$y} += $cache[2];
    608. 

  608.       } elsif ( $x eq 'J' and $#cache == 3 ) {
    609. 

  609. 	$y = shift (@cache);
    610. 

  610. 	$hier_sibling{$y} = $hier_sibling_size{$y} = $hier_sibling_time{$y} =
    611. 

  611. 	  0
    612. 

  612. 	  unless defined $hier_sibling{$y};
    613. 

  613. 	$hier_sibling{$y} += $cache[0];
    614. 

  614. 	$hier_sibling_size{$y} += $cache[1];
    615. 

  615. 	$hier_sibling_time{$y} += $cache[2];
    616. 

  616.       } elsif ( $x eq 'K' and $#cache == 3 ) {
    617. 

  617. 	$y = shift (@cache);
    618. 

  618. 	$hier_parent{$y} = $hier_parent_size{$y} = $hier_parent_time{$y} = 0
    619. 

  619. 	  unless defined $hier_parent{$y};
    620. 

  620. 	$hier_parent{$y} += $cache[0];
    621. 

  621. 	$hier_parent_size{$y} += $cache[1];
    622. 

  622. 	$hier_parent_time{$y} += $cache[2];
    623. 

  623.       } elsif ( $x eq 'L' and $#cache == 3 ) {
    624. 

  624. 	$y = shift (@cache);
    625. 

  625. 	$hier_neighbor{$y} = $hier_neighbor_size{$y} =
    626. 

  626. 	  $hier_neighbor_time{$y} = 0
    627. 

  627. 	  unless defined $hier_neighbor{$y};
    628. 

  628. 	$hier_neighbor{$y} += $cache[0];
    629. 

  629. 	$hier_neighbor_size{$y} += $cache[1];
    630. 

  630. 	$hier_neighbor_time{$y} += $cache[2];
    631. 

  631.       } elsif ( $x eq 'M' and $#cache == 4 ) {
    632. 

  632. 	$y = shift (@cache);
    633. 

  633. 	$z = shift (@cache);
    634. 

  634. 	$hier_neighbor_status{$y}{$z} = $hier_neighbor_status_size{$y}{$z} =
    635. 

  635. 	  $hier_neighbor_status_time{$y}{$z} = 0
    636. 

  636. 	  unless defined $hier_neighbor_status{$y}{$z};
    637. 

  637. 	$hier_neighbor_status{$y}{$z} += $cache[0];
    638. 

  638. 	$hier_neighbor_status_size{$y}{$z} += $cache[1];
    639. 

  639. 	$hier_neighbor_status_time{$y}{$z} += $cache[2];
    640. 

  640.       } elsif ( $x eq 'N' and $#cache == 3 ) {
    641. 

  641. 	$y = shift (@cache);
    642. 

  642. 	$tcp_urlhost{$y} = $tcp_urlhost_size{$y} = $tcp_hit_urlhost{$y} = 0
    643. 

  643. 	  unless defined $tcp_urlhost{$y};
    644. 

  644. 	$tcp_urlhost{$y} += $cache[0];
    645. 

  645. 	$tcp_urlhost_size{$y} += $cache[1];
    646. 

  646. 	$tcp_hit_urlhost{$y} += $cache[2];
    647. 

  647.       } elsif ( $x eq 'O' and $#cache == 3 ) {
    648. 

  648. 	$y = shift (@cache);
    649. 

  649. 	$tcp_urltld{$y} = $tcp_urltld_size{$y} = $tcp_hit_urltld{$y} = 0
    650. 

  650. 	  unless defined $tcp_urltld{$y};
    651. 

  651. 	$tcp_urltld{$y} += $cache[0];
    652. 

  652. 	$tcp_urltld_size{$y} += $cache[1];
    653. 

  653. 	$tcp_hit_urltld{$y} += $cache[2];
    654. 

  654.       } elsif ( $x eq 'P' and $#cache == 3 ) {
    655. 

  655. 	$y = shift (@cache);
    656. 

  656. 	$tcp_urlprot{$y} = $tcp_urlprot_size{$y} = $tcp_hit_urlprot{$y} = 0
    657. 

  657. 	  unless defined $tcp_urlprot{$y};
    658. 

  658. 	$tcp_urlprot{$y} += $cache[0];
    659. 

  659. 	$tcp_urlprot_size{$y} += $cache[1];
    660. 

  660. 	$tcp_hit_urlprot{$y} += $cache[2];
    661. 

  661.       } elsif ( $x eq 'Q' and $#cache == 3 ) {
    662. 

  662. 	$y = shift (@cache);
    663. 

  663. 	$tcp_content{$y} = $tcp_content_size{$y} = $tcp_hit_content{$y} = 0
    664. 

  664. 	  unless defined $tcp_content{$y};
    665. 

  665. 	$tcp_content{$y} += $cache[0];
    666. 

  666. 	$tcp_content_size{$y} += $cache[1];
    667. 

  667. 	$tcp_hit_content{$y} += $cache[2];
    668. 

  668.       } elsif ( $x eq 'R' and $#cache == 3 ) {
    669. 

  669. 	$y = shift (@cache);
    670. 

  670. 	$tcp_urlext{$y} = $tcp_urlext_size{$y} = $tcp_hit_urlext{$y} = 0
    671. 

  671. 	  unless defined $tcp_urlext{$y};
    672. 

  672. 	$tcp_urlext{$y} += $cache[0];
    673. 

  673. 	$tcp_urlext_size{$y} += $cache[1];
    674. 

  674. 	$tcp_hit_urlext{$y} += $cache[2];
    675. 

  675.       } elsif ( $x eq 'S' and $#cache == 5 ) {
    676. 

  676. 	$y = shift (@cache);
    677. 

  677. 	$udp_requester{$y} = $udp_requester_size{$y} =
    678. 

  678. 	  $udp_requester_time{$y} = $udp_hit_requester{$y} =
    679. 

  679. 	  $udp_hit_requester_size{$y} = 0
    680. 

  680. 	  unless defined $udp_requester{$y};
    681. 

  681. 	$udp_requester{$y} += $cache[0];
    682. 

  682. 	$udp_requester_size{$y} += $cache[1];
    683. 

  683. 	$udp_requester_time{$y} += $cache[2];
    684. 

  684. 	$udp_hit_requester{$y} += $cache[3];
    685. 

  685. 	$udp_hit_requester_size{$y} += $cache[4];
    686. 

  686.       } elsif ( $x eq 'T' and $#cache == 5 ) {
    687. 

  687. 	$y = shift (@cache);
    688. 

  688. 	$tcp_requester{$y} = $tcp_requester_size{$y} =
    689. 

  689. 	  $tcp_requester_time{$y} = $tcp_hit_requester{$y} =
    690. 

  690. 	  $tcp_hit_requester_size{$y} = 0
    691. 

  691. 	  unless defined $tcp_requester{$y};
    692. 

  692. 	$tcp_requester{$y} += $cache[0];
    693. 

  693. 	$tcp_requester_size{$y} += $cache[1];
    694. 

  694. 	$tcp_requester_time{$y} += $cache[2];
    695. 

  695. 	$tcp_hit_requester{$y} += $cache[3];
    696. 

  696. 	$tcp_hit_requester_size{$y} += $cache[4];
    697. 

  697.       } elsif ( $x eq 'U' and $#cache == 13 ) {
    698. 

  698. 	$y = shift (@cache);
    699. 

  699. 	( $perf_counter{$y}, $perf_size{$y}, $perf_time{$y},
    700. 

  700. 	 $perf_tcp_hit_size{$y}, $perf_tcp_hit_time{$y},
    701. 

  701. 	 $perf_tcp_miss_size{$y}, $perf_tcp_miss_time{$y},
    702. 

  702. 	 $perf_hier_direct_size{$y}, $perf_hier_direct_time{$y},
    703. 

  703. 	 $perf_hier_sibling_size{$y}, $perf_hier_sibling_time{$y},
    704. 

  704. 	 $perf_hier_parent_size{$y}, $perf_hier_parent_time{$y} )
    705. 

  705. 	  = @cache;
    706. 

  706. # This is for a stupid bug I brought in... it should save older Cache-Files,
    707. 

  707. # and put them in so that we can work with them.. remove at end of 2003
    708. 

  708.       } elsif ( $x eq 'U' and $#cache == 12 ) {
    709. 

  709. 	$cache_warn1 = 'The Performance data misses the Cache-Hits-value';
    710. 

  710. 	$y = shift (@cache);
    711. 

  711. 	( $perf_counter{$y}, $perf_size{$y}, $perf_time{$y},
    712. 

  712. 	 $perf_tcp_hit_size{$y}, $perf_tcp_miss_size{$y},
    713. 

  713. 	 $perf_tcp_miss_time{$y}, $perf_hier_direct_size{$y},
    714. 

  714. 	 $perf_hier_direct_time{$y}, $perf_hier_sibling_size{$y},
    715. 

  715. 	 $perf_hier_sibling_time{$y}, $perf_hier_parent_size{$y},
    716. 

  716. 	 $perf_hier_parent_time{$y} )
    717. 

  717. 	  = @cache;
    718. 

  718. # stupid, yes...
    719. 

  719. # I set this to 0/.000001 so removezerotime prints a - in the report.
    720. 

  720. 	$perf_tcp_hit_size{$y} = 0;
    721. 

  721. 	$perf_tcp_hit_time{$y} = .000001;
    722. 

  722. # End of stupid bug-workaround
    723. 

  723.       } elsif ( $x eq 'V' and $#cache == 6 ) {
    724. 

  724. 	$y = shift (@cache);
    725. 

  725. 	$z = shift (@cache);
    726. 

  726. 	$udp_requester_urlhost{$y}{$z} = $udp_requester_urlhost_size{$y}{$z} =
    727. 

  727. 	  $udp_requester_urlhost_time{$y}{$z} =
    728. 

  728. 	  $udp_hit_requester_urlhost{$y}{$z} =
    729. 

  729. 	  $udp_hit_requester_urlhost_size{$y}{$z} = 0
    730. 

  730. 	  unless defined $udp_requester_urlhost{$y}{$z};
    731. 

  731. 	$udp_requester_urlhost{$y}{$z} += $cache[0];
    732. 

  732. 	$udp_requester_urlhost_size{$y}{$z} += $cache[1];
    733. 

  733. 	$udp_requester_urlhost_time{$y}{$z} += $cache[2];
    734. 

  734. 	$udp_hit_requester_urlhost{$y}{$z} += $cache[3];
    735. 

  735. 	$udp_hit_requester_urlhost_size{$y}{$z} += $cache[4];
    736. 

  736. # Start of Bug-fix - remove this at end of 2003
    737. 

  737.       } elsif ( $x eq 'V' and $#cache == 5 ) {
    738. 

  738. 	$cache_warn2 = 'The UDP-Requester-Report misses the other-value';
    739. 

  739. 	$y = '<other>' unless ($y);
    740. 

  740. 	$z = shift (@cache);
    741. 

  741. 	$udp_requester_urlhost{$y}{$z} = $udp_requester_urlhost_size{$y}{$z} =
    742. 

  742. 	  $udp_requester_urlhost_time{$y}{$z} =
    743. 

  743. 	  $udp_hit_requester_urlhost{$y}{$z} =
    744. 

  744. 	  $udp_hit_requester_urlhost_size{$y}{$z} = 0
    745. 

  745. 	  unless defined $udp_requester_urlhost{$y}{$z};
    746. 

  746. 	$udp_requester_urlhost{$y}{$z} += $cache[0];
    747. 

  747. 	$udp_requester_urlhost_size{$y}{$z} += $cache[1];
    748. 

  748. 	$udp_requester_urlhost_time{$y}{$z} += $cache[2];
    749. 

  749. 	$udp_hit_requester_urlhost{$y}{$z} += $cache[3];
    750. 

  750. 	$udp_hit_requester_urlhost_size{$y}{$z} += $cache[4];
    751. 

  751. # End of Bug-fix
    752. 

  752.       } elsif ( $x eq 'W' and $#cache == 6 ) {
    753. 

  753. 	$y = shift (@cache);
    754. 

  754. 	$z = shift (@cache);
    755. 

  755. 	$tcp_requester_urlhost{$y}{$z} = $tcp_requester_urlhost_size{$y}{$z} =
    756. 

  756. 	  $tcp_requester_urlhost_time{$y}{$z} =
    757. 

  757. 	  $tcp_hit_requester_urlhost{$y}{$z} =
    758. 

  758. 	  $tcp_hit_requester_urlhost_size{$y}{$z} = 0
    759. 

  759. 	  unless defined $tcp_requester_urlhost{$y}{$z};
    760. 

  760. 	$tcp_requester_urlhost{$y}{$z} += $cache[0];
    761. 

  761. 	$tcp_requester_urlhost_size{$y}{$z} += $cache[1];
    762. 

  762. 	$tcp_requester_urlhost_time{$y}{$z} += $cache[2];
    763. 

  763. 	$tcp_hit_requester_urlhost{$y}{$z} += $cache[3];
    764. 

  764. 	$tcp_hit_requester_urlhost_size{$y}{$z} += $cache[4];
    765. 

  765. # Start of Bugfix - remove at end of 2003
    766. 

  766.       } elsif ( $x eq 'W' and $#cache == 5 ) {
    767. 

  767. 	$cache_warn3 = 'The TCP-Requester-Report misses the other-value';
    768. 

  768. 	$y = '<other>' unless ($y);
    769. 

  769. 	$z = shift (@cache);
    770. 

  770. 	$tcp_requester_urlhost{$y}{$z} = $tcp_requester_urlhost_size{$y}{$z} =
    771. 

  771. 	  $tcp_requester_urlhost_time{$y}{$z} =
    772. 

  772. 	  $tcp_hit_requester_urlhost{$y}{$z} =
    773. 

  773. 	  $tcp_hit_requester_urlhost_size{$y}{$z} = 0
    774. 

  774. 	  unless defined $tcp_requester_urlhost{$y}{$z};
    775. 

  775. 	$tcp_requester_urlhost{$y}{$z} += $cache[0];
    776. 

  776. 	$tcp_requester_urlhost_size{$y}{$z} += $cache[1];
    777. 

  777. 	$tcp_requester_urlhost_time{$y}{$z} += $cache[2];
    778. 

  778. 	$tcp_hit_requester_urlhost{$y}{$z} += $cache[3];
    779. 

  779. 	$tcp_hit_requester_urlhost_size{$y}{$z} += $cache[4];
    780. 

  780. # End of Bugfix
    781. 

  781.       } elsif ( $x eq 'X' and $#cache == 5 ) {
    782. 

  782. 	$y = shift (@cache);
    783. 

  783. 	$tcp_distribution{$y} = $tcp_distribution_size{$y} =
    784. 

  784. 	  $tcp_distribution_time{$y} = $tcp_hit_distribution{$y} =
    785. 

  785. 	  $tcp_hit_distribution_size{$y} = 0
    786. 

  786. 	  unless defined $tcp_distribution{$y};
    787. 

  787. 	$tcp_distribution{$y} += $cache[0];
    788. 

  788. 	$tcp_distribution_size{$y} += $cache[1];
    789. 

  789. 	$tcp_distribution_time{$y} += $cache[2];
    790. 

  790. 	$tcp_hit_distribution{$y} += $cache[3];
    791. 

  791. 	$tcp_hit_distribution_size{$y} += $cache[4];
    792. 

  792.       } else {
    793. 

  793. 	print STDERR "can't parse cache-line: \"$x @cache\"\n";
    794. 

  794.       }
    795. 

  795.     }
    796. 

  796.     close(CACHE);
    797. 

  797.   }
    798. 

  798. }
    799. 

  799. 

  800. unless ($opt_z) {
    801. 

  801.   while ( defined( $line = <> ) ) {
    802. 

  802.     if ( not defined $opt_f or $opt_f eq 'auto' ) {
    803. 

  803.       if ( $line =~
    804. 

  804. 	  m#^\d+\.\d+\s+\d+\s+[\w\-\.:]+\s+\w+/\d+\s+\d+\s+\w+\s+\S+\s+\S+\s+\w+/\S+\s+\S+$#
    805. 

  805. 	  )
    806. 

  806.       {
    807. 

  807. 	$opt_f = 'squid';
    808. 

  808. 	print STDERR "guessing... using '-f squid'\n" if ($opt_v);
    809. 

  809. 	last;
    810. 

  810.       } elsif ( $line =~
    811. 

  811. 	       m#^\d+\s+\d+\s+[\w\-\.:]+\s+\w+/\d+\s+\d+\s+\w+\s+\S+\s+\S+\s+\w+/\S+\s+\S+$#
    812. 

  812. 	       )
    813. 

  813.       {
    814. 

  814. 	$opt_f = 'its';
    815. 

  815. 	print STDERR "guessing... using '-f its'\n" if ($opt_v);
    816. 

  816. 	last;
    817. 

  817.       } elsif ( $line =~
    818. 

  818. 	       m#^\d+\.\d+\s+\d+\s+[\w\-\.:]+\s+\w+/\d+\s+\d+\s+\w+\s+\S+\s+\S+\s+\w+/\S+$#
    819. 

  819. 	       )
    820. 

  820.       {
    821. 

  821. 	$opt_f = 'squid-old';
    822. 

  822. 	print STDERR "guessing... using '-f squid-old'\n" if ($opt_v);
    823. 

  823. 	last;
    824. 

  824.       } elsif ( $line =~
    825. 

  825. 	       m#^\d+\.\d+\s+\d+\s+[\w\-\.:]+\s+\w+/\d+\s+\d+\s+\w+\s+\S+\s+\S+\s+\w+/\S+\s+(\S|; c)+\s+\S+$#
    826. 

  826. 	       )
    827. 

  827.       {
    828. 

  828. 	$opt_f = 'nc';
    829. 

  829. 	print STDERR "guessing... using '-f nc'\n" if ($opt_v);
    830. 

  830. 	last;
    831. 

  831.       } elsif ( $line =~ s/^\s*#\s*Fields:\s*// ) {
    832. 

  832. 	$opt_f = 'elff';
    833. 

  833. 	print STDERR "guessing... using '-f elff'\n" if ($opt_v);
    834. 

  834. 	last;
    835. 

  835.       } elsif ( $line =~ s/^\s*format=\s*// ) {
    836. 

  836. 	$opt_f = 'nse';
    837. 

  837. 	print STDERR "guessing... using '-f nse'\n" if ($opt_v);
    838. 

  838. 	last;
    839. 

  839.       } elsif ( $line =~
    840. 

  840. 	       m#^\d+\.\d+\s+\d+\s+[\w\-\.:]+\s+\w+/\-?\d+\s+\d+\s+\w+\s+\S+\s+\S+\s+\w+/\S+\s+\S+\s+#
    841. 

  841. 	       )
    842. 

  842.       {
    843. 

  843. 	$opt_f = 'squid-extended';
    844. 

  844. 	print STDERR "guessing... using '-f squid-extended'\n" if ($opt_v);
    845. 

  845. 	last;
    846. 

  846.       } elsif ( $line =~
    847. 

  847. 	       m#^[\w\-\.:]+\s+\S+\s+\S+\s+\[.+\]\s+\"\w+\s+\S+\s+\S+\"\s+\d+\s+\d+\s+\S+(\s+\[.*\]\s+\[.*\])?$#
    848. 

  848. 	       )
    849. 

  849.       {
    850. 

  850. 	print STDERR "$0: The first line of the input looks to me as if you
    851. 

  851. switched 'emulate_httpd_log' to on. I can't parse that format. Please read
    852. 

  852. the README on this.\n\n";
    853. 

  853. 	exit(1);
    854. 

  854.       } elsif ( $line =~ m/^\s*(#|$)/ ) {
    855. 

  855. 	print STDERR "skipping: $line\n" if ($opt_v);
    856. 

  856. 	next;
    857. 

  857.       } else {
    858. 

  858. 	print STDERR "$0: I don't know this input format. Please check the
    859. 

  859. input. If you\'re sure that the following line is NOT corrupt and the error
    860. 

  860. also occurs with the recent version of Calamaris (see the README for pointers
    861. 

  861. and known bugs) then report it with the following line to
    862. 

  862. <Calamaris-bug\@Cord.de>. Thank You.\n\n$line\n\n";
    863. 

  863. 	exit(1);
    864. 

  864.       }
    865. 

  865.     } else {
    866. 

  866.       last;
    867. 

  867.     }
    868. 

  868.   }
    869. 

  869.   if ( not defined $opt_f or $opt_f eq 'auto' ) {
    870. 

  870.     print "\nno requests found\n";
    871. 

  871.     exit(0);
    872. 

  872.   }
    873. 

  873.   print STDERR "print a hash-sign for each $opt_b lines:\n" if ($opt_b);
    874. 

  874.   $loop = '
    875. 

  875. for ( ; $line ; $line = <> ) {';
    876. 

  876.   if ( $opt_f eq 'squid' ) {
    877. 

  877.     $loop .= '
    878. 

  878.   ( $log_date, $log_reqtime, $log_requester, $log_status, $log_size,
    879. 

  879.    $log_method, $log_url, $log_ident, $log_hier, $log_content, $foo )
    880. 

  880.     = split ( /\s+/, $line );
    881. 

  881.   if ( not defined $foo
    882. 

  882.       or not defined $log_content
    883. 

  883.       or $foo ne \'\'
    884. 

  884.       or $log_content eq \'\'
    885. 

  885.       or $log_reqtime < 0
    886. 

  886.       or $log_date !~ m#^\d+\.\d{3}$# )
    887. 

  887.   {';
    888. 

  888.   } elsif ( $opt_f eq 'squid-extended' ) {
    889. 

  889.     $loop .= '
    890. 

  890.   $line =~ s/ \[[^\[\]]*\]//g;
    891. 

  891.   ( $log_date, $log_reqtime, $log_requester, $log_status, $log_size,
    892. 

  892.    $log_method, $log_url, $log_ident, $log_hier, $log_content)
    893. 

  893.     = split ( /\s+/, $line, 10 );
    894. 

  894.   chomp($log_content);
    895. 

  895.   if ( not defined $log_content
    896. 

  896.       or $log_content eq \'\'
    897. 

  897.       or $log_reqtime < 0
    898. 

  898.       or $log_date !~ m#^\d+\.\d{3}$# )
    899. 

  899.   {';
    900. 

  900.   } elsif ( $opt_f eq 'its' ) {
    901. 

  901.     $loop .= '
    902. 

  902.   ( $log_date, $log_reqtime, $log_requester, $log_status, $log_size,
    903. 

  903.    $log_method, $log_url, $log_ident, $log_hier, $log_content, $foo ) =
    904. 

  904.     split ( /\s+/, $line );
    905. 

  905.   if ( not defined $foo
    906. 

  906.       or not defined $log_content
    907. 

  907.       or $foo ne \'\'
    908. 

  908.       or $log_content eq \'\'
    909. 

  909.       or $log_reqtime < 0
    910. 

  910.       or $log_date !~ m#^\d+$# )
    911. 

  911. 	{';
    912. 

  912.   } elsif ( $opt_f eq 'squid-old' ) {
    913. 

  913.     $loop .= '
    914. 

  914.   ( $log_date, $log_reqtime, $log_requester, $log_status, $log_size,
    915. 

  915.    $log_method, $log_url, $log_ident, $log_hier, $foo )
    916. 

  916.     = split ( /\s+/, $line );
    917. 

  917.   unless ( not defined $foo
    918. 

  918. 	  or not defined $log_hier
    919. 

  919. 	  or $foo ne \'\'
    920. 

  920. 	  or $log_hier eq \'\'
    921. 

  921. 	  or $log_reqtime < 0
    922. 

  922. 	  or $log_date !~ m#^\d+\.\d{3}$# )
    923. 

  923. 	  {';
    924. 

  924.   } elsif ( $opt_f eq 'nc' ) {
    925. 

  925.     $loop .= '
    926. 

  926.   $line =~ s#\; c#\;_c#og; # Hack to handle buggy logfiles of NetCache V3.2.x
    927. 

  927.   ( $log_date, $log_reqtime, $log_requester, $log_status, $log_size,
    928. 

  928.    $log_method, $log_url, $log_ident, $log_hier, $log_content, $log_abort,
    929. 

  929.    $foo )
    930. 

  930.     = split ( /\s+/, $line );
    931. 

  931.   if ( not defined $foo or not defined $log_abort or $foo ne \'\' or
    932. 

  932.       $log_abort eq \'\' or $log_reqtime < 0 or
    933. 

  933.       $log_date !~ m#^\d+\.\d{3}$# )
    934. 

  934. 	    {';
    935. 

  935.   } elsif ( $opt_f eq 'elff' ) {
    936. 

  936.     @fields = split ( /\s+/, $line );
    937. 

  937.     $loop .= '
    938. 

  938.   use Time::Local;
    939. 

  939.   if ( $line =~
    940. 

  940.       m#^';
    941. 

  941.     foreach (@fields) {
    942. 

  942.       $tmpline1 .= '\s+' if ($tmpline1);
    943. 

  943.       if ( $_ eq 'date' ) {
    944. 

  944. 	$tmpline1 .= '(\d+)-(\d+)-(\d+)';
    945. 

  945. 	$tmpline2 .= '
    946. 

  946.     $log_year = $' . ++$offset . ';
    947. 

  947.     $log_month = $' . ++$offset . ';
    948. 

  948.     $log_day = $' . ++$offset . ';';
    949. 

  949.       } elsif ( $_ eq 'time' ) {
    950. 

  950. 	$tmpline1 .= '(\d+):(\d+):(\d+)';
    951. 

  951. 	$tmpline2 .= '
    952. 

  952.     $log_hour = $' . ++$offset . ';
    953. 

  953.     $log_min = $' . ++$offset . ';
    954. 

  954.     $log_sec = $' . ++$offset . ';';
    955. 

  955.       } elsif ( $_ eq 'x-timestamp' ) {
    956. 

  956. 	$tmpline1 .= '(\d+\.\d+)';
    957. 

  957. 	$tmpline2 .= '
    958. 

  958.     $log_date = $' . ++$offset . ';';
    959. 

  959. 	$log_date = 0;
    960. 

  960.       } elsif ( $_ eq 'c-ip' ) {
    961. 

  961. 	$tmpline1 .= '([\w\-\.:]+)';
    962. 

  962. 	$tmpline2 .= '
    963. 

  963.     $log_requester = $' . ++$offset . ';';
    964. 

  964.       } elsif ( $_ eq 'cs-authname'
    965. 

  965. 	       or $_ eq 'x-remote-id'
    966. 

  966. 	       or $_ eq 'x-username'
    967. 

  967. 	       or $_ eq 'cs-username' )
    968. 

  968.       {
    969. 

  969. 	$tmpline1 .= '(\S+)';
    970. 

  970. 	$tmpline2 .= '
    971. 

  971.     $log_ident = $' . ++$offset . ';';
    972. 

  972.       } elsif ( $_ eq 's-ip' or $_ eq 's-sitename' ) {
    973. 

  973. 	$tmpline1 .= '[\w\-\.]+';
    974. 

  974.       } elsif ( $_ eq 'cs-method' ) {
    975. 

  975. 	$tmpline1 .= '([\w\-]+)';
    976. 

  976. 	$tmpline2 .= '
    977. 

  977.     $log_method = $' . ++$offset . ';';
    978. 

  978.       } elsif ( $_ eq 'cs-uri' ) {
    979. 

  979. 	$tmpline1 .= '(\S+)';
    980. 

  980. 	$tmpline2 .= '
    981. 

  981.     $log_url = $' . ++$offset . ';';
    982. 

  982.       } elsif ( $_ eq 'cs-uri-stem'
    983. 

  983. 	       or $_ eq 'cs-uri-query'
    984. 

  984. 	       or $_ eq 'x-note' )
    985. 

  985.       {
    986. 

  986. 	$tmpline1 .= '\S+';
    987. 

  987.       } elsif ( $_ eq 'c-version' ) {
    988. 

  988. 	$tmpline1 .= '\w+/[\d\.]+';
    989. 

  989.       } elsif ( $_ eq 'sc-status' ) {
    990. 

  990. 	$tmpline1 .= '(\d+)';
    991. 

  991. 	$tmpline2 .= '
    992. 

  992.     $log_code = $' . ++$offset . ';';
    993. 

  993.       } elsif ( $_ eq 'sc-bytes' or $_ eq 'bytes' ) {
    994. 

  994. 	$tmpline1 .= '(\d+)';
    995. 

  995. 	$tmpline2 .= '
    996. 

  996.     $log_size = $' . ++$offset . ';';
    997. 

  997.       } elsif ( $_ eq 'cs-bytes' ) {
    998. 

  998. 	$tmpline1 .= '\d+';
    999. 

  999.       } elsif ( $_ eq 'x-elapsed-milliseconds' ) {
    1000. 

  1000. 	$tmpline1 .= '(\d+)';
    1001. 

  1001. 	$tmpline2 .= '
    1002. 

  1002.     $log_reqtime = $' . ++$offset . ';';
    1003. 

  1003.       } elsif ( $_ eq 'time-taken' ) {
    1004. 

  1004. 	$tmpline1 .= '([\d\.]+)';
    1005. 

  1005. 	$tmpline2 .= '
    1006. 

  1006.     $log_reqtime = $' . ++$offset . ' * 1000;';
    1007. 

  1007.       } elsif ( $_ eq 'cs(User-Agent)'
    1008. 

  1008. 	       or $_ eq 'cs(Cookie)'
    1009. 

  1009. 	       or $_ eq 'cs(Referer)'
    1010. 

  1010. 	       or $_ eq 'sc(Referer)'
    1011. 

  1011. 	       or $_ eq 'cs(X-Forwarded-For)'
    1012. 

  1012. 	       or $_ eq 'x-hiername' )
    1013. 

  1013.       {
    1014. 

  1014. 	$tmpline1 .= '(\"[^\"]*\"|-)';
    1015. 

  1015. 	$tmpline2 .= '
    1016. 

  1016.     ++$offset;';
    1017. 

  1017.       } elsif ( $_ eq 'cached' ) {
    1018. 

  1018. 	$tmpline1 .= '(\d+)';
    1019. 

  1019. 	$tmpline2 .= '
    1020. 

  1020.     $log_cached = $' . ++$offset . ';';
    1021. 

  1021.       } elsif ( $_ eq 'x-transaction' ) {
    1022. 

  1022. 	$tmpline1 .= '(\w+\/[\d\-]+)';
    1023. 

  1023. 	$tmpline2 .= '
    1024. 

  1024.     $log_status = $' . ++$offset . ';';
    1025. 

  1025. 	$log_status = 0;
    1026. 

  1026.       } elsif ( $_ eq 'x-fill-proxy-ip' ) {
    1027. 

  1027. 	$tmpline1 .= '([\w\-\.]+)';
    1028. 

  1028. 	$tmpline2 .= '
    1029. 

  1029.     $log_proxy_ip = $' . ++$offset . ';';
    1030. 

  1030.       } elsif ( $_ eq 'x-origin-ip' ) {
    1031. 

  1031. 	$tmpline1 .= '([\w\-\.]+)';
    1032. 

  1032. 	$tmpline2 .= '
    1033. 

  1033.     $log_origin_ip = $' . ++$offset . ';';
    1034. 

  1034.       } elsif ( $_ eq 'x-hiercode' ) {
    1035. 

  1035. 	$tmpline1 .= '([\w\-\.\/]+)';
    1036. 

  1036. 	$tmpline2 .= '
    1037. 

  1037.     $log_hier = $' . ++$offset . ';';
    1038. 

  1038. 	$log_hier = 0;
    1039. 

  1039.       } elsif ( $_ eq 'rs(Content-Type)' ) {
    1040. 

  1040. 	$tmpline1 .= '\"[^\"]*\"';
    1041. 

  1041.       } else {
    1042. 

  1042. 	print STDERR "$0: I don't know this input format. Please check the
    1043. 

  1043. input. If you\'re sure that the following is NOT corrupt and the error also
    1044. 

  1044. occurs with the recent version of Calamaris (see the README for pointers and
    1045. 

  1045. known bugs) then report it with the following line to <Calamaris-bug\@Cord.de>.
    1046. 

  1046. Thank You.\n\n$_\n\n";
    1047. 

  1047. 	exit(1);
    1048. 

  1048.       }
    1049. 

  1049.     }
    1050. 

  1050.     foreach $pattern ( qw(date time c-ip cs-method cs-uri sc-status sc-bytes
    1051. 

  1051. 			  time-taken cached x-fill-proxy-ip x-origin-ip)
    1052. 

  1052. 		      )
    1053. 

  1053.     {
    1054. 

  1054.       unless ( grep $pattern, @fields ) {
    1055. 

  1055. 	print STDERR "$0: Your input file format is missing at least the field
    1056. 

  1056. \'$pattern\'. I can\'t parse it. Sorry. If you think that this field isn't
    1057. 

  1057. important to you, please report this error to <Calamaris-bug\@Cord.de>.
    1058. 

  1058. Thank You.\n\n";
    1059. 

  1059. 	exit(1);
    1060. 

  1060.       }
    1061. 

  1061.     }
    1062. 

  1062.     foreach $pattern (qw(cs-authname)) {
    1063. 

  1063.       unless ( grep $pattern, @fields ) {
    1064. 

  1064. 	if ( $pattern eq 'cs-authname' ) {
    1065. 

  1065. 	  $tmpline2 .= '
    1066. 

  1066.   $log_ident = "-";';
    1067. 

  1067. 	}
    1068. 

  1068.       }
    1069. 

  1069.     }
    1070. 

  1070.     $loop .= $tmpline1 . '.?$#
    1071. 

  1071.     )
    1072. 

  1072.   {' . $tmpline2;
    1073. 

  1073.     $loop .= '
    1074. 

  1074.     $log_date = timegm(
    1075. 

  1075. 		     $log_sec, $log_min, $log_hour, $log_day, $log_month - 1,
    1076. 

  1076. 		     $log_year - 1900
    1077. 

  1077. 		     );' unless defined $log_date;
    1078. 

  1078.     $loop .= '
    1079. 

  1079.     $log_status = "$log_cached/$log_code";' unless defined $log_status;
    1080. 

  1080.     $loop .= '
    1081. 

  1081.     if ( $log_origin_ip ne \'-\' ) {
    1082. 

  1082.       $log_hier = "DIRECT/$log_origin_ip";
    1083. 

  1083.     } elsif ( $log_proxy_ip ne \'-\' ) {
    1084. 

  1084.       if ( $log_cached eq \'0\' ) {
    1085. 

  1085. 	$log_hier = "PARENT_MISS/$log_proxy_ip";
    1086. 

  1086.       } else {
    1087. 

  1087. 	$log_hier = "PARENT_HIT/$log_proxy_ip";
    1088. 

  1088.       }
    1089. 

  1089.     } else {
    1090. 

  1090.       $log_hier = "NONE/-";
    1091. 

  1091.     }' unless defined $log_hier;
    1092. 

  1092.     $loop .= '
    1093. 

  1093.   } else {';
    1094. 

  1094.     while ( defined( $line = <> ) ) {
    1095. 

  1095.       last unless $line =~ /^\s*#/;
    1096. 

  1096.     }
    1097. 

  1097.   } elsif ( $opt_f eq 'nse' ) {
    1098. 

  1098.     $line =~ s#^format=##og;
    1099. 

  1099.     @fields = split ( /\s+/, $line );
    1100. 

  1100.     $loop .= '
    1101. 

  1101.   use Time::Local;
    1102. 

  1102.   if ( $line =~
    1103. 

  1103.     m#^';
    1104. 

  1104.     foreach (@fields) {
    1105. 

  1105.       $tmpline1 .= '\s+' if ($tmpline1);
    1106. 

  1106.       if ( $_ eq '[%SYSDATE%]' ) {
    1107. 

  1107. 	$tmpline1 .= '\[(\d+)/(\w+)/(\d+):(\d+):(\d+):(\d+)\s+\S+\]';
    1108. 

  1108. 	$tmpline2 .= '
    1109. 

  1109.     $log_day = $' . ++$offset . ';
    1110. 

  1110.     $log_month = $' . ++$offset . ';
    1111. 

  1111.     $log_year = $' . ++$offset . ';
    1112. 

  1112.     $log_hour = $' . ++$offset . ';
    1113. 

  1113.     $log_min = $' . ++$offset . ';
    1114. 

  1114.     $log_sec = $' . ++$offset . ';';
    1115. 

  1115.       } elsif ( $_ eq '%Ses->client.ip%' ) {
    1116. 

  1116. 	$tmpline1 .= '([\w\-\.:]+)';
    1117. 

  1117. 	$tmpline2 .= '
    1118. 

  1118.     $log_requester = $' . ++$offset . ';';
    1119. 

  1119.       } elsif ( $_ eq '%Req->vars.pauth-user%' ) {
    1120. 

  1120. 	$tmpline1 .= '(\S+)';
    1121. 

  1121. 	$tmpline2 .= '
    1122. 

  1122.     $log_ident = $' . ++$offset . ';';
    1123. 

  1123.       } elsif ( $_ eq '%Req->vars.remote-status%'
    1124. 

  1124. 	       or $_ eq '%Req->vars.r2p-cl%'
    1125. 

  1125. 	       or $_ eq '%Req->vars.cli-status%'
    1126. 

  1126. 	       or $_ eq '%Req->vars.svr-status%'
    1127. 

  1127. 	       or $_ eq '%Req->vars.cch-status%' )
    1128. 

  1128.       {
    1129. 

  1129. 	$tmpline1 .= '[\w\-\.]+';
    1130. 

  1130.       } elsif ( $_ eq '"%Req->reqpb.proxy-request%"' ) {
    1131. 

  1131. 	$tmpline1 .= '\"(\w+)\s+([^\"]+)\s+\S+\"';
    1132. 

  1132. 	$tmpline2 .= '
    1133. 

  1133.     $log_method = $' . ++$offset . ';
    1134. 

  1134.     $log_url = $' . ++$offset . ';';
    1135. 

  1135.       } elsif ( $_ eq '%Req->srvhdrs.clf-status%' ) {
    1136. 

  1136. 	$tmpline1 .= '([\d\-]+)';
    1137. 

  1137. 	$tmpline2 .= '
    1138. 

  1138.     $log_code = $' . ++$offset . ';';
    1139. 

  1139.       } elsif ( $_ eq '%Req->vars.p2c-cl%' ) {
    1140. 

  1140. 	$tmpline1 .= '([\d\-]+)';
    1141. 

  1141. 	$tmpline2 .= '
    1142. 

  1142.     $log_size = $' . ++$offset . ';';
    1143. 

  1143.       } elsif ( $_ eq '%Req->headers.content-length%'
    1144. 

  1144. 	       or $_ eq '%Req->vars.p2r-cl%'
    1145. 

  1145. 	       or $_ eq '%Req->vars.c2p-hl%'
    1146. 

  1146. 	       or $_ eq '%Req->vars.p2c-hl%'
    1147. 

  1147. 	       or $_ eq '%Req->vars.p2r-hl%'
    1148. 

  1148. 	       or $_ eq '%Req->vars.r2p-hl%' )
    1149. 

  1149.       {
    1150. 

  1150. 	$tmpline1 .= '[\d\-]+';
    1151. 

  1151.       } elsif ( $_ eq '%Req->vars.xfer-time%' ) {
    1152. 

  1152. 	$tmpline1 .= '([\d\.]+)';
    1153. 

  1153. 	$tmpline2 .= '
    1154. 

  1154.     $log_reqtime = $' . ++$offset . ' * 1000;';
    1155. 

  1155.       } elsif ( $_ eq '%route%' ) {
    1156. 

  1156. 	$tmpline1 .= '(\d+)';
    1157. 

  1157. 	$tmpline2 .= '
    1158. 

  1158.     $log_cached = $' . ++$offset . ';';
    1159. 

  1159.       } elsif ( $_ eq '%Req->vars.actual-route%' ) {
    1160. 

  1160. 	$tmpline1 .= '(\S+)';
    1161. 

  1161. 	$tmpline2 .= '
    1162. 

  1162.     $log_hier = $' . ++$offset . ';
    1163. 

  1163.     if ( $log_hier =~ m#[\(\)]# ) {
    1164. 

  1164.       $log_hier =~ s#^(\w+)(\((\S+)\))?$#$1/$3#;
    1165. 

  1165.       $log_status = \'TCP_MISS/-\';
    1166. 

  1166.     } elsif ( $log_hier =~ m#-# ) {
    1167. 

  1167.       $log_hier = $log_hier . \'/-\';
    1168. 

  1168.       $log_status = \'TCP_HIT/-\';
    1169. 

  1169.     } else {
    1170. 

  1170.       $log_hier = $log_hier . \'/-\';
    1171. 

  1171.       $log_status = \'TCP_MISS/-\';
    1172. 

  1172.     }';
    1173. 

  1173.       } elsif ( $_ eq '-' ) {
    1174. 

  1174. 	$tmpline1 .= '-';
    1175. 

  1175.       } else {
    1176. 

  1176. 	print STDERR "$0: I don't know this input format. Please check the
    1177. 

  1177. input. If you\'re sure that the following is NOT corrupt and the error also
    1178. 

  1178. occurs with the recent version of Calamaris (see the README for pointers and
    1179. 

  1179. known bugs) then report it with the following line to <Calamaris-bug\@Cord.de>.
    1180. 

  1180. Thank You.\n\n$_\n\n";
    1181. 

  1181. 	exit(1);
    1182. 

  1182.       }
    1183. 

  1183.     }
    1184. 

  1184.     foreach $pattern ( qw(%Ses->client.ip% [%SYSDATE%]
    1185. 

  1185. 			  %Req->reqpb.proxy-request% %Req->srvhdrs.clf-status%
    1186. 

  1186. 			  %Req->vars.p2c-cl% %Req->vars.xfer-time%)
    1187. 

  1187. 		      )
    1188. 

  1188.     {
    1189. 

  1189.       unless ( grep $pattern, @fields ) {
    1190. 

  1190. 	print STDERR "$0: Your input file format is missing at least the field
    1191. 

  1191. \'$pattern\'. I can\'t parse it. Sorry. If you think that this field isn't
    1192. 

  1192. important to you, please report this error to <Calamaris-bug\@Cord.de>.
    1193. 

  1193. Thank You.\n\n";
    1194. 

  1194. 	exit(1);
    1195. 

  1195.       }
    1196. 

  1196.     }
    1197. 

  1197.     foreach $pattern (qw(%Req->vars.pauth-user% %Req->vars.actual-route%)) {
    1198. 

  1198.       unless ( grep /$pattern/, @fields ) {
    1199. 

  1199. 	if ( $pattern eq '%Req->vars.pauth-user%' ) {
    1200. 

  1200. 	  $tmpline2 .= '
    1201. 

  1201.   $log_ident = "-";';
    1202. 

  1202. 	} elsif ( $pattern eq '%Req->vars.actual-route%' ) {
    1203. 

  1203. 	  $tmpline2 .= '
    1204. 

  1204.     $log_hier = \'-/-\';
    1205. 

  1205.     $log_status = \'-/-\';';
    1206. 

  1206. 	}
    1207. 

  1207.       }
    1208. 

  1208.     }
    1209. 

  1209.     $loop .= $tmpline1 . '.?$#
    1210. 

  1210.     )
    1211. 

  1211.   {' . $tmpline2 . '
    1212. 

  1212.     $monthcount = -1;
    1213. 

  1213.     foreach $month (@months) {
    1214. 

  1214.       $monthcount++;
    1215. 

  1215.       last if ( $month eq $log_month );
    1216. 

  1216.     }
    1217. 

  1217.     $log_date = timegm(
    1218. 

  1218. 		       $log_sec, $log_min, $log_hour, $log_day, $monthcount,
    1219. 

  1219. 		       $log_year - 1900
    1220. 

  1220. 		       );
    1221. 

  1221.   } else {';
    1222. 

  1222.     while ( defined( $line = <> ) ) {
    1223. 

  1223.       last unless $line =~ /^\s*#/;
    1224. 

  1224.     }
    1225. 

  1225.   } else {
    1226. 

  1226.     print STDERR "$0: unknown value at -f -option: \"$opt_f\"\n\n$USAGE\n\n";
    1227. 

  1227.     exit 1;
    1228. 

  1228.   }
    1229. 

  1229.   $loop .= '
    1230. 

  1230.     chomp($line);';
    1231. 

  1231.   $loop .= '
    1232. 

  1232.     warn(\'invalid line: "\' . $line . "\"\n");' if $opt_v;
    1233. 

  1233.   $loop .= '
    1234. 

  1234.     $invalid++;
    1235. 

  1235.     next;
    1236. 

  1236.   }';
    1237. 

  1237.   $loop .= '
    1238. 

  1238.     if (($log_date < $interval_begin) or ($log_date > $interval_end)) {
    1239. 

  1239.       $skipped++;
    1240. 

  1240.       next;
    1241. 

  1241.     }
    1242. 

  1242.   ' if $opt_I;
    1243. 

  1243.   $loop .= '
    1244. 

  1244.   $log_reqtime = .1 if $log_reqtime == 0;
    1245. 

  1245.   ( $log_hitfail, $log_code ) = split \'/\', $log_status;
    1246. 

  1246.   $log_size = 0 if ( $log_size eq \'-\' );
    1247. 

  1247.   $log_url =~ s/\?.*$/?/;
    1248. 

  1248.   @url = split m#[/\\\]#o, $log_url;
    1249. 

  1249.   ( $urlprot, $urlhost, $urlext ) = (@url)[ 0, 2, $#url ];
    1250. 

  1250.   $urlext = \'.<none>\' if $#url <= 2;
    1251. 

  1251.   if ( $#url <= -1 ) {
    1252. 

  1252.     $urlext = \'.<error>\';
    1253. 

  1253.     $urlprot = $urlhost = \'<error>\';
    1254. 

  1254.   }
    1255. 

  1255.   $urlext = \'.<dynamic>\'
    1256. 

  1256.     if ( $urlext =~ m#[\?;&\$,!@=|%]#o or $log_method eq \'POST\' );
    1257. 

  1257.   unless ( defined $urlhost ) {
    1258. 

  1258.     $urlhost = $urlprot;';
    1259. 

  1259.   $loop .= '
    1260. 

  1260.     $log_content = '
    1261. 

  1261.     unless $opt_f eq 'squid-old'
    1262. 

  1262.       or $opt_f eq 'elff'
    1263. 

  1263.       or $opt_f eq 'nse';
    1264. 

  1264.   $loop .= '
    1265. 

  1265.     $urlprot = \'<secure>\';
    1266. 

  1266.     $urlext = \'.<secure>\';
    1267. 

  1267.   }
    1268. 

  1268.   $urlhost =~ s#^.*@##o;
    1269. 

  1269.   $urlhost =~ s#[:\?].*$##o;
    1270. 

  1270.   $urlhost =~ tr/A-Z/a-z/;
    1271. 

  1271.   @urlext = split \'\.\', $urlext;
    1272. 

  1272.   $urlext = (@urlext)[$#urlext];
    1273. 

  1273.   $urlext = \'<none>\' if $#urlext <= 0;';
    1274. 

  1274.   $loop .= '
    1275. 

  1275.   $urlext =~ tr/A-Z/a-z/;' if $opt_c;
    1276. 

  1276.   $loop .= '
    1277. 

  1277.   if ( $urlhost =~ m#^(([0-9][0-9]{0,2}\.){3})[0-9][0-9]{0,2}$#o ) {';
    1278. 

  1278.   $loop .= '
    1279. 

  1279.     $urlhost = $1 . \'*\';' unless $opt_N == -1;
    1280. 

  1280.   $loop .= '
    1281. 

  1281.     $urltld = \'<unresolved>\';
    1282. 

  1282.   } elsif ( $urlhost =~ m#^(.*\.([^\.]+\.)?)?([^\.]+\.([^\.]+))\.?$#o ) {
    1283. 

  1283.     @list = split \'\.\', $urlhost;
    1284. 

  1284.     $urltld = pop @list;';
    1285. 

  1285.   if ( $opt_N != -1 ) {
    1286. 

  1286.     $loop .= '
    1287. 

  1287.     $urlhost = $urltld;';
    1288. 

  1288.     for ( $i = $opt_N ; $i != 1 ; $i-- ) {
    1289. 

  1289.       $loop .= '
    1290. 

  1290.     $urlhost = pop (@list) . \'.\' . $urlhost if $#list >= 0;';
    1291. 

  1291.     }
    1292. 

  1292.     $loop .= '
    1293. 

  1293.     $urlhost = pop (@list) . \'.\' . $urlhost
    1294. 

  1294.       if ( $urltld =~
    1295. 

  1295. 	  m#^(a[rtu]|br|c[no]|hk|i[dlm]|jp|kr|l[by]|m[oxy]|nz|p[elnry]|sg|t[hrw]|u[aks]|ve|yu|za)$#o
    1296. 

  1296. 	  and $#list >= 0 );
    1297. 

  1297.     $urlhost = \'*.\' . $urlhost if $#list >= 0;
    1298. 

  1298.     $urltld = \'*.\' . $urltld;';
    1299. 

  1299.   }
    1300. 

  1300.   $loop .= '
    1301. 

  1301.   } elsif ( $urlhost =~ m#([!a-z0-9\.\-]|\.\.)#o ) {
    1302. 

  1302.     $urlhost = $urltld = $urlext = $urlprot = \'<error>\';
    1303. 

  1303.   } else {
    1304. 

  1304.     $urltld = $urlhost;
    1305. 

  1305.   }';
    1306. 

  1306.   if ($opt_n) {
    1307. 

  1307.     $loop .= '
    1308. 

  1308.   $requester = $log_requester;';
    1309. 

  1309.   } else {
    1310. 

  1310.     $loop .= '
    1311. 

  1311.   $requester = getfqdn($log_requester);';
    1312. 

  1312.   }
    1313. 

  1313.   $loop .= '
    1314. 

  1314.   $requester = $log_ident . \'@\' . $requester if $log_ident ne \'-\';'
    1315. 

  1315.     if $opt_u;
    1316. 

  1316.   $loop .= '
    1317. 

  1317.   ( $log_hier_method, $log_hier_host ) = ( split \'/\', $log_hier )[ 0, 1 ];';
    1318. 

  1318.   $loop .= '
    1319. 

  1319.   $log_content = \'<unknown>\' if $log_content eq \'-\';
    1320. 

  1320.   $log_content =~ tr/A-Z/a-z/;
    1321. 

  1321.   $log_content = '
    1322. 

  1322.     unless $opt_f eq 'squid-old'
    1323. 

  1323.     or $opt_f eq 'elff'
    1324. 

  1324.     or $opt_f eq 'nse';
    1325. 

  1325.   $loop .= '
    1326. 

  1326.   $urlhost = $urltld = $urlext = $urlprot = \'<error>\'
    1327. 

  1327.     if ( $log_code =~ m#^[45]#o );';
    1328. 

  1328.   $loop .= "
    1329. 

  1329.   print STDERR '#' if (0 == (\$counter % $opt_b));" if $opt_b;
    1330. 

  1330.   $loop .= '
    1331. 

  1331.   $counter++;
    1332. 

  1332.   $size += $log_size;
    1333. 

  1333.   $time += $log_reqtime;
    1334. 

  1334.   $method{$log_method} = $method_size{$log_method} =
    1335. 

  1335.     $method_time{$log_method} = 0
    1336. 

  1336.     unless defined $method{$log_method};
    1337. 

  1337.   $method{$log_method}++;
    1338. 

  1338.   $method_size{$log_method} += $log_size;
    1339. 

  1339.   $method_time{$log_method} += $log_reqtime;
    1340. 

  1340.   $time_begin = $log_date if $log_date < $time_begin;
    1341. 

  1341.   $time_end = $log_date if $log_date > $time_end;';
    1342. 

  1342.   if ( defined $opt_p ) {
    1343. 

  1343.     $loop .= '
    1344. 

  1344.   if ( defined(@peak_all) ) {
    1345. 

  1345.     if ( $log_date < $peak_all[$#peak_all] ) {
    1346. 

  1346.       $peak_warn =
    1347. 

  1347. 	\'Peak values are most likely wrong due to unsorted input!\';
    1348. 

  1348.       undef(@peak_all);
    1349. 

  1349.       undef(@peak_udp);
    1350. 

  1350.       undef(@peak_tcp);
    1351. 

  1351.       $peak_all_min_pointer = $peak_all_sec_pointer = $peak_tcp_min_pointer =
    1352. 

  1352. 	$peak_tcp_sec_pointer = $peak_udp_min_pointer =
    1353. 

  1353. 	$peak_udp_sec_pointer = 0;
    1354. 

  1354.       chomp($line);
    1355. 

  1355.       warn( \'unsorted input: "\' . $line . "\"\n" ) if $opt_v;
    1356. 

  1356.     }
    1357. 

  1357.   }';
    1358. 

  1358.     if ( $opt_p eq 'old' ) {
    1359. 

  1359.       $loop .= '
    1360. 

  1360.   $peak_all_sec_pointer++;
    1361. 

  1361.   $peak_all_min_pointer++;
    1362. 

  1362.   unshift ( @peak_all, $log_date );
    1363. 

  1363.   $peak_all_sec_pointer--
    1364. 

  1364.     while $peak_all[ $peak_all_sec_pointer - 1 ] < ( $log_date - 1 );
    1365. 

  1365.   $peak_all_min_pointer--
    1366. 

  1366.     while $peak_all[ $peak_all_min_pointer - 1 ] < ( $log_date - 60 );
    1367. 

  1367.   pop (@peak_all) while $peak_all[$#peak_all] < ( $log_date - 3600 );
    1368. 

  1368.   if ( $peak_all_hour < @peak_all ) {
    1369. 

  1369.     $peak_all_hour = @peak_all;
    1370. 

  1370.     $peak_all_hour_time = $log_date - 3600;
    1371. 

  1371.   }
    1372. 

  1372.   if ( $peak_all_min < $peak_all_min_pointer ) {
    1373. 

  1373.     $peak_all_min = $peak_all_min_pointer;
    1374. 

  1374.     $peak_all_min_time = $log_date - 60;
    1375. 

  1375.   }
    1376. 

  1376.   if ( $peak_all_sec < $peak_all_sec_pointer ) {
    1377. 

  1377.     $peak_all_sec = $peak_all_sec_pointer;
    1378. 

  1378.     $peak_all_sec_time = $log_date - 1;
    1379. 

  1379.   }';
    1380. 

  1380.     } elsif ( $opt_p eq 'new' ) {
    1381. 

  1381.       $loop .= '
    1382. 

  1382.   $date_hour = int( ( $log_date - ( $log_reqtime / 1000 ) ) / 3600 ) * 3600;
    1383. 

  1383.   foreach $i ( ( $date_hour / 3600 ) .. int( $log_date / 3600 ) ) {
    1384. 

  1384.     $peak_all_hour{ $i * 3600 } = $peak_all_hour_size{ $i * 3600 } = 0
    1385. 

  1385.       unless defined $peak_all_hour{ $i * 3600 };
    1386. 

  1386.     $peak_all_hour{ $i * 3600 }++;
    1387. 

  1387.     $peak_all_hour_size{ $i * 3600 } +=
    1388. 

  1388.       $log_size / int( $log_reqtime / 3600000 + 1 );
    1389. 

  1389.   }
    1390. 

  1390.   $peak_all_sec_pointer++;
    1391. 

  1391.   unshift ( @peak_all, $log_date );
    1392. 

  1392.   $peak_all_sec_pointer--
    1393. 

  1393.     while $peak_all[ $peak_all_sec_pointer - 1 ] < ( $log_date - 1 );
    1394. 

  1394.   pop (@peak_all) while $peak_all[$#peak_all] < ( $log_date - 60 );
    1395. 

  1395.   if ( $peak_all_min < @peak_all ) {
    1396. 

  1396.     $peak_all_min = @peak_all;
    1397. 

  1397.     $peak_all_min_time = $log_date - 60;
    1398. 

  1398.   }
    1399. 

  1399.   if ( $peak_all_sec < $peak_all_sec_pointer ) {
    1400. 

  1400.     $peak_all_sec = $peak_all_sec_pointer;
    1401. 

  1401.     $peak_all_sec_time = $log_date - 1;
    1402. 

  1402.   }';
    1403. 

  1403.     } else {
    1404. 

  1404.       print STDERR
    1405. 

  1405. 	"$0: unknown value at -p -option: \"$opt_p\"\n\n$USAGE\n\n";
    1406. 

  1406.       exit 1;
    1407. 

  1407.     }
    1408. 

  1408.   }
    1409. 

  1409.   $loop .= '
    1410. 

  1410.   if ( ( $log_method =~ m#^ICP_#o ) or ( $log_status =~ m#^ICP#o ) ) {
    1411. 

  1411.     $udp++;
    1412. 

  1412.     $udp_size += $log_size;
    1413. 

  1413.     $udp_time += $log_reqtime;';
    1414. 

  1414.   $loop .= '
    1415. 

  1415.     $udp_requester{$requester} = $udp_requester_size{$requester} =
    1416. 

  1416.       $udp_requester_time{$requester} = $udp_hit_requester{$requester} =
    1417. 

  1417.       $udp_hit_requester_size{$requester} = 0
    1418. 

  1418.       unless defined $udp_requester{$requester};
    1419. 

  1419.     $udp_requester{$requester}++;
    1420. 

  1420.     $udp_requester_size{$requester} += $log_size;
    1421. 

  1421.     $udp_requester_time{$requester} += $log_reqtime;' if ($opt_r);
    1422. 

  1422.   $loop .= '
    1423. 

  1423.     $udp_requester_urlhost{$requester}{$urlhost} =
    1424. 

  1424.       $udp_requester_urlhost_size{$requester}{$urlhost} =
    1425. 

  1425.       $udp_requester_urlhost_time{$requester}{$urlhost} =
    1426. 

  1426.       $udp_hit_requester_urlhost{$requester}{$urlhost} =
    1427. 

  1427.       $udp_hit_requester_urlhost_size{$requester}{$urlhost} = 0
    1428. 

  1428.       unless defined $udp_requester_urlhost{$requester}{$urlhost};
    1429. 

  1429.     $udp_requester_urlhost{$requester}{$urlhost}++;
    1430. 

  1430.     $udp_requester_urlhost_size{$requester}{$urlhost} += $log_size;
    1431. 

  1431.     $udp_requester_urlhost_time{$requester}{$urlhost} += $log_reqtime;'
    1432. 

  1432.     if ($opt_R);
    1433. 

  1433.   if ( not defined $opt_p ) {
    1434. 

  1434.   } elsif ( $opt_p eq 'old' ) {
    1435. 

  1435.     $loop .= '
    1436. 

  1436.     $peak_udp_sec_pointer++;
    1437. 

  1437.     $peak_udp_min_pointer++;
    1438. 

  1438.     unshift ( @peak_udp, $log_date );
    1439. 

  1439.     $peak_udp_sec_pointer--
    1440. 

  1440.       while $peak_udp[ $peak_udp_sec_pointer - 1 ] < ( $log_date - 1 );
    1441. 

  1441.     $peak_udp_min_pointer--
    1442. 

  1442.       while $peak_udp[ $peak_udp_min_pointer - 1 ] < ( $log_date - 60 );
    1443. 

  1443.     pop @peak_udp while $peak_udp[$#peak_udp] < ( $log_date - 3600 );
    1444. 

  1444.     if ( $peak_udp_hour < @peak_udp ) {
    1445. 

  1445.       $peak_udp_hour = @peak_udp;
    1446. 

  1446.       $peak_udp_hour_time = $log_date - 3600;
    1447. 

  1447.     }
    1448. 

  1448.     if ( $peak_udp_min < $peak_udp_min_pointer ) {
    1449. 

  1449.       $peak_udp_min = $peak_udp_min_pointer;
    1450. 

  1450.       $peak_udp_min_time = $log_date - 60;
    1451. 

  1451.     }
    1452. 

  1452.     if ( $peak_udp_sec < $peak_udp_sec_pointer ) {
    1453. 

  1453.       $peak_udp_sec = $peak_udp_sec_pointer;
    1454. 

  1454.       $peak_udp_sec_time = $log_date - 1;
    1455. 

  1455.     }';
    1456. 

  1456.   } elsif ( $opt_p eq 'new' ) {
    1457. 

  1457.     $loop .= '
    1458. 

  1458.     foreach $i ( ( $date_hour / 3600 ) .. int( $log_date / 3600 ) ) {
    1459. 

  1459.       $peak_udp_hour{ $i * 3600 } = $peak_udp_hour_size{ $i * 3600 } = 0
    1460. 

  1460. 	unless defined $peak_udp_hour{ $i * 3600 };
    1461. 

  1461.       $peak_udp_hour{ $i * 3600 }++;
    1462. 

  1462.       $peak_udp_hour_size{ $i * 3600 } +=
    1463. 

  1463. 	$log_size / int( $log_reqtime / 3600000 + 1 );
    1464. 

  1464.     }
    1465. 

  1465.     $peak_udp_sec_pointer++;
    1466. 

  1466.     unshift ( @peak_udp, $log_date );
    1467. 

  1467.     $peak_udp_sec_pointer--
    1468. 

  1468.       while $peak_udp[ $peak_udp_sec_pointer - 1 ] < ( $log_date - 1 );
    1469. 

  1469.     pop @peak_udp while $peak_udp[$#peak_udp] < ( $log_date - 60 );
    1470. 

  1470.     if ( $peak_udp_min < @peak_udp ) {
    1471. 

  1471.       $peak_udp_min = @peak_udp;
    1472. 

  1472.       $peak_udp_min_time = $log_date - 60;
    1473. 

  1473.     }
    1474. 

  1474.     if ( $peak_udp_sec < $peak_udp_sec_pointer ) {
    1475. 

  1475.       $peak_udp_sec = $peak_udp_sec_pointer;
    1476. 

  1476.       $peak_udp_sec_time = $log_date - 1;
    1477. 

  1477.     }';
    1478. 

  1478.   }
    1479. 

  1479.   $loop .= '
    1480. 

  1480.     if ( $log_hitfail =~ m#^(UDP|ICP)_HIT#o ) {
    1481. 

  1481.       $udp_hit++;
    1482. 

  1482.       $udp_hit_size += $log_size;
    1483. 

  1483.       $udp_hit_time += $log_reqtime;';
    1484. 

  1484.   $loop .= '
    1485. 

  1485.       $udp_hit_requester{$requester}++;
    1486. 

  1486.       $udp_hit_requester_size{$requester} += $log_size;' if ($opt_r);
    1487. 

  1487.   $loop .= '
    1488. 

  1488.       $udp_hit_requester_urlhost{$requester}{$urlhost}++;
    1489. 

  1489.       $udp_hit_requester_urlhost_size{$requester}{$urlhost} += $log_size;'
    1490. 

  1490.     if ($opt_R);
    1491. 

  1491.   $loop .= '
    1492. 

  1492.       $udp_hit{$log_hitfail} = $udp_hit_size{$log_hitfail} =
    1493. 

  1493. 	$udp_hit_time{$log_hitfail} = 0
    1494. 

  1494. 	unless defined $udp_hit{$log_hitfail};
    1495. 

  1495.       $udp_hit{$log_hitfail}++;
    1496. 

  1496.       $udp_hit_size{$log_hitfail} += $log_size;
    1497. 

  1497.       $udp_hit_time{$log_hitfail} += $log_reqtime;' if ($opt_s);
    1498. 

  1498.   $loop .= '
    1499. 

  1499.     } else {
    1500. 

  1500.       $udp_miss++;
    1501. 

  1501.       $udp_miss_size += $log_size;
    1502. 

  1502.       $udp_miss_time += $log_reqtime;';
    1503. 

  1503.   $loop .= '
    1504. 

  1504.       $udp_miss{$log_hitfail} = $udp_miss_size{$log_hitfail} =
    1505. 

  1505. 	$udp_miss_time{$log_hitfail} = 0
    1506. 

  1506. 	unless defined $udp_miss{$log_hitfail};
    1507. 

  1507.       $udp_miss{$log_hitfail}++;
    1508. 

  1508.       $udp_miss_size{$log_hitfail} += $log_size;
    1509. 

  1509.       $udp_miss_time{$log_hitfail} += $log_reqtime;' if ($opt_s);
    1510. 

  1510.   $loop .= '
    1511. 

  1511.     }
    1512. 

  1512.   } else {
    1513. 

  1513.     $tcp++;
    1514. 

  1514.     $tcp_size += $log_size;
    1515. 

  1515.     $tcp_time += $log_reqtime;';
    1516. 

  1516.   $loop .= '
    1517. 

  1517.     $perf_date =
    1518. 

  1518.       ( int( ( $log_date + '
    1519. 

  1519. 	. "( $opt_T * 60 ) ) / ( 60 * $opt_P ) ) * 60 * $opt_P ) -
    1520. 

  1520. 	 ( $opt_T * 60 );" . '
    1521. 

  1521.     unless ( defined $perf_counter{$perf_date} ) {
    1522. 

  1522.       $perf_counter{$perf_date} = $perf_size{$perf_date} =
    1523. 

  1523. 	$perf_tcp_hit_size{$perf_date} = $perf_tcp_miss_size{$perf_date} =
    1524. 

  1524. 	$perf_hier_direct_size{$perf_date} =
    1525. 

  1525. 	$perf_hier_sibling_size{$perf_date} =
    1526. 

  1526. 	$perf_hier_parent_size{$perf_date} = 0;
    1527. 

  1527.       $perf_time{$perf_date} = $perf_tcp_hit_time{$perf_date} =
    1528. 

  1528. 	$perf_tcp_miss_time{$perf_date} = $perf_hier_direct_time{$perf_date} =
    1529. 

  1529. 	$perf_hier_sibling_time{$perf_date} =
    1530. 

  1530. 	$perf_hier_parent_time{$perf_date} = .0000000001;
    1531. 

  1531.     }
    1532. 

  1532.     $perf_counter{$perf_date}++;
    1533. 

  1533.     $perf_size{$perf_date} += $log_size;
    1534. 

  1534.     $perf_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1535. 

  1535.   $loop .= '
    1536. 

  1536.     $tcp_requester{$requester} = $tcp_requester_size{$requester} =
    1537. 

  1537.       $tcp_requester_time{$requester} = $tcp_hit_requester{$requester} =
    1538. 

  1538.       $tcp_hit_requester_size{$requester} = 0
    1539. 

  1539.       unless defined $tcp_requester{$requester};
    1540. 

  1540.     $tcp_requester{$requester}++;
    1541. 

  1541.     $tcp_requester_size{$requester} += $log_size;
    1542. 

  1542.     $tcp_requester_time{$requester} += $log_reqtime;' if ($opt_r);
    1543. 

  1543.   $loop .= '
    1544. 

  1544.     $distribution = $log_size ? int( log($log_size) / log($opt_D) ) : -1;
    1545. 

  1545.     $tcp_distribution{$distribution} = $tcp_distribution_size{$distribution} =
    1546. 

  1546.       $tcp_distribution_time{$distribution} =
    1547. 

  1547.       $tcp_hit_distribution{$distribution} =
    1548. 

  1548.       $tcp_hit_distribution_size{$distribution} = 0
    1549. 

  1549.       unless defined $tcp_distribution{$distribution};
    1550. 

  1550.     $tcp_distribution{$distribution}++;
    1551. 

  1551.     $tcp_distribution_size{$distribution} += $log_size;
    1552. 

  1552.     $tcp_distribution_time{$distribution} += $log_reqtime;' if ($opt_D);
    1553. 

  1553.   $loop .= '
    1554. 

  1554.     $tcp_requester_urlhost{$requester}{$urlhost} =
    1555. 

  1555.       $tcp_requester_urlhost_size{$requester}{$urlhost} =
    1556. 

  1556.       $tcp_requester_urlhost_time{$requester}{$urlhost} =
    1557. 

  1557.       $tcp_hit_requester_urlhost{$requester}{$urlhost} =
    1558. 

  1558.       $tcp_hit_requester_urlhost_size{$requester}{$urlhost} = 0
    1559. 

  1559.       unless defined $tcp_requester_urlhost{$requester}{$urlhost};
    1560. 

  1560.     $tcp_requester_urlhost{$requester}{$urlhost}++;
    1561. 

  1561.     $tcp_requester_urlhost_size{$requester}{$urlhost} += $log_size;
    1562. 

  1562.     $tcp_requester_urlhost_time{$requester}{$urlhost} += $log_reqtime;'
    1563. 

  1563.     if ($opt_R);
    1564. 

  1564.   $loop .= '
    1565. 

  1565.     $tcp_urlhost{$urlhost} = $tcp_urlhost_size{$urlhost} =
    1566. 

  1566.       $tcp_hit_urlhost{$urlhost} = 0
    1567. 

  1567.       unless defined $tcp_urlhost{$urlhost};
    1568. 

  1568.     $tcp_urlhost{$urlhost}++;
    1569. 

  1569.     $tcp_urlhost_size{$urlhost} += $log_size;
    1570. 

  1570.     $tcp_urltld{$urltld} = $tcp_urltld_size{$urltld} =
    1571. 

  1571.       $tcp_hit_urltld{$urltld} = 0
    1572. 

  1572.       unless defined $tcp_urltld{$urltld};
    1573. 

  1573.     $tcp_urltld{$urltld}++;
    1574. 

  1574.     $tcp_urltld_size{$urltld} += $log_size;' if ($opt_d);
    1575. 

  1575.   $loop .= '
    1576. 

  1576.     $tcp_urlprot{$urlprot} = $tcp_urlprot_size{$urlprot} =
    1577. 

  1577.       $tcp_hit_urlprot{$urlprot} = 0
    1578. 

  1578.       unless defined $tcp_urlprot{$urlprot};
    1579. 

  1579.     $tcp_urlprot{$urlprot}++;
    1580. 

  1580.     $tcp_urlprot_size{$urlprot} += $log_size;' if ($opt_t);
    1581. 

  1581.   if ( not defined $opt_p ) {
    1582. 

  1582.   } elsif ( $opt_p eq 'old' ) {
    1583. 

  1583.     $loop .= '
    1584. 

  1584.     $peak_tcp_sec_pointer++;
    1585. 

  1585.     $peak_tcp_min_pointer++;
    1586. 

  1586.     unshift ( @peak_tcp, $log_date );
    1587. 

  1587.     $peak_tcp_sec_pointer--
    1588. 

  1588.       while $peak_tcp[ $peak_tcp_sec_pointer - 1 ] < ( $log_date - 1 );
    1589. 

  1589.     $peak_tcp_min_pointer--
    1590. 

  1590.       while $peak_tcp[ $peak_tcp_min_pointer - 1 ] < ( $log_date - 60 );
    1591. 

  1591.     pop (@peak_tcp) while $peak_tcp[$#peak_tcp] < ( $log_date - 3600 );
    1592. 

  1592.     if ( $peak_tcp_hour < @peak_tcp ) {
    1593. 

  1593.       $peak_tcp_hour = @peak_tcp;
    1594. 

  1594.       $peak_tcp_hour_time = $log_date - 3600;
    1595. 

  1595.     }
    1596. 

  1596.     if ( $peak_tcp_min < $peak_tcp_min_pointer ) {
    1597. 

  1597.       $peak_tcp_min = $peak_tcp_min_pointer;
    1598. 

  1598.       $peak_tcp_min_time = $log_date - 60;
    1599. 

  1599.     }
    1600. 

  1600.     if ( $peak_tcp_sec < $peak_tcp_sec_pointer ) {
    1601. 

  1601.       $peak_tcp_sec = $peak_tcp_sec_pointer;
    1602. 

  1602.       $peak_tcp_sec_time = $log_date - 1;
    1603. 

  1603.     }';
    1604. 

  1604.   } elsif ( $opt_p eq 'new' ) {
    1605. 

  1605.     $loop .= '
    1606. 

  1606.     foreach $i ( $date_hour / 3600 .. int( $log_date / 3600 ) ) {
    1607. 

  1607.       $peak_tcp_hour{ $i * 3600 } = $peak_tcp_hour_size{ $i * 3600 } = 0
    1608. 

  1608. 	unless defined $peak_tcp_hour{ $i * 3600 };
    1609. 

  1609.       $peak_tcp_hour{ $i * 3600 }++;
    1610. 

  1610.       $peak_tcp_hour_size{ $i * 3600 } +=
    1611. 

  1611. 	$log_size / int( $log_reqtime / 3600000	+ 1 );
    1612. 

  1612.     }
    1613. 

  1613.     $peak_tcp_sec_pointer++;
    1614. 

  1614.     unshift ( @peak_tcp, $log_date );
    1615. 

  1615.     $peak_tcp_sec_pointer--
    1616. 

  1616.       while $peak_tcp[ $peak_tcp_sec_pointer - 1 ] < ( $log_date - 1 );
    1617. 

  1617.     pop (@peak_tcp) while $peak_tcp[$#peak_tcp] < ( $log_date - 60 );
    1618. 

  1618.     if ( $peak_tcp_min < @peak_tcp ) {
    1619. 

  1619.       $peak_tcp_min = @peak_tcp;
    1620. 

  1620.       $peak_tcp_min_time = $log_date - 60;
    1621. 

  1621.     }
    1622. 

  1622.     if ( $peak_tcp_sec < $peak_tcp_sec_pointer ) {
    1623. 

  1623.       $peak_tcp_sec = $peak_tcp_sec_pointer;
    1624. 

  1624.       $peak_tcp_sec_time = $log_date - 1;
    1625. 

  1625.     }';
    1626. 

  1626.   }
    1627. 

  1627.   $loop .= '
    1628. 

  1628.     $tcp_content{$log_content} = $tcp_content_size{$log_content} =
    1629. 

  1629.       $tcp_hit_content{$log_content} = 0
    1630. 

  1630.       unless defined $tcp_content{$log_content};
    1631. 

  1631.     $tcp_content{$log_content}++;
    1632. 

  1632.     $tcp_content_size{$log_content} += $log_size;'
    1633. 

  1633.     unless $opt_f eq 'squid-old'
    1634. 

  1634.     or $opt_f eq 'elff'
    1635. 

  1635.     or $opt_f eq 'nse';
    1636. 

  1636.   $loop .= '
    1637. 

  1637.     $tcp_urlext{$urlext} = $tcp_urlext_size{$urlext} =
    1638. 

  1638.       $tcp_hit_urlext{$urlext} = 0
    1639. 

  1639.       unless defined $tcp_urlext{$urlext};
    1640. 

  1640.     $tcp_urlext{$urlext}++;
    1641. 

  1641.     $tcp_urlext_size{$urlext} += $log_size;' if ($opt_t);
    1642. 

  1642.   if ( $opt_f eq 'elff' ) {
    1643. 

  1643.     $loop .= '
    1644. 

  1644.     if ( $log_hitfail eq \'1\' or $log_hitfail =~ m#^(TCP_HIT|HIT_)#o ) {';
    1645. 

  1645.   } else {
    1646. 

  1646.     $loop .= '
    1647. 

  1647.     if ( $log_hitfail =~ m#^TCP_\w*HIT#o ) {';
    1648. 

  1648.   }
    1649. 

  1649.   $loop .= '
    1650. 

  1650.       $tcp_hit++;
    1651. 

  1651.       $tcp_hit_size += $log_size;
    1652. 

  1652.       $tcp_hit_time += $log_reqtime;';
    1653. 

  1653.   $loop .= '
    1654. 

  1654.       $perf_tcp_hit_size{$perf_date} += $log_size;
    1655. 

  1655.       $perf_tcp_hit_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1656. 

  1656.   $loop .= '
    1657. 

  1657.       $tcp_hit{$log_hitfail} = $tcp_hit_size{$log_hitfail} =
    1658. 

  1658. 	$tcp_hit_time{$log_hitfail} = 0
    1659. 

  1659. 	unless defined $tcp_hit{$log_hitfail};
    1660. 

  1660.       $tcp_hit{$log_hitfail}++;
    1661. 

  1661.       $tcp_hit_size{$log_hitfail} += $log_size;
    1662. 

  1662.       $tcp_hit_time{$log_hitfail} += $log_reqtime;'
    1663. 

  1663.     if ($opt_s)
    1664. 

  1664.     and $opt_f ne 'elff';
    1665. 

  1665.   $loop .= '
    1666. 

  1666.       $tcp_hit_requester{$requester}++;
    1667. 

  1667.       $tcp_hit_requester_size{$requester} += $log_size;' if ($opt_r);
    1668. 

  1668.   $loop .= '
    1669. 

  1669.       $tcp_hit_requester_urlhost{$requester}{$urlhost}++;
    1670. 

  1670.       $tcp_hit_requester_urlhost_size{$requester}{$urlhost} += $log_size;'
    1671. 

  1671.     if ($opt_R);
    1672. 

  1672.   $loop .= '
    1673. 

  1673.       $tcp_hit_distribution{$distribution}++;
    1674. 

  1674.       $tcp_hit_distribution_size{$distribution} += $log_size;' if ($opt_D);
    1675. 

  1675.   $loop .= '
    1676. 

  1676.       $tcp_hit_urlhost{$urlhost}++;
    1677. 

  1677.       $tcp_hit_urltld{$urltld}++;' if ($opt_d);
    1678. 

  1678.   $loop .= '
    1679. 

  1679.       $tcp_hit_content{$log_content}++;'
    1680. 

  1680.     unless $opt_f eq 'squid-old'
    1681. 

  1681.       or $opt_f eq 'elff'
    1682. 

  1682.       or $opt_f eq 'nse';
    1683. 

  1683.   $loop .= '
    1684. 

  1684.       $tcp_hit_urlext{$urlext}++;
    1685. 

  1685.       $tcp_hit_urlprot{$urlprot}++;' if ($opt_t);
    1686. 

  1686.   $loop .= '
    1687. 

  1687.     } elsif ( $log_hier_method =~ m#EMPTY|NONE|NULL|^\-$#o
    1688. 

  1688. 	     or $log_hitfail =~ m#^ERR_#o )
    1689. 

  1689.     {
    1690. 

  1690.       $tcp_miss_none++;
    1691. 

  1691.       $tcp_miss_none_size += $log_size;
    1692. 

  1692.       $tcp_miss_none_time += $log_reqtime;' if $opt_f ne 'elff';
    1693. 

  1693.   $loop .= '
    1694. 

  1694.       $tcp_miss_none{$log_hitfail} = $tcp_miss_none_size{$log_hitfail} =
    1695. 

  1695. 	$tcp_miss_none_time{$log_hitfail} = 0
    1696. 

  1696. 	unless defined $tcp_miss_none{$log_hitfail};
    1697. 

  1697.       $tcp_miss_none{$log_hitfail}++;
    1698. 

  1698.       $tcp_miss_none_size{$log_hitfail} += $log_size;
    1699. 

  1699.       $tcp_miss_none_time{$log_hitfail} += $log_reqtime;'
    1700. 

  1700.     if ($opt_s)
    1701. 

  1701.     and $opt_f ne 'elff';
    1702. 

  1702.   $loop .= '
    1703. 

  1703.     } else {
    1704. 

  1704.       $tcp_miss++;
    1705. 

  1705.       $tcp_miss_size += $log_size;
    1706. 

  1706.       $tcp_miss_time += $log_reqtime;';
    1707. 

  1707.   $loop .= '
    1708. 

  1708.       $perf_tcp_miss_size{$perf_date} += $log_size;
    1709. 

  1709.       $perf_tcp_miss_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1710. 

  1710.   $loop .= '
    1711. 

  1711.       $tcp_miss{$log_hitfail} = $tcp_miss_size{$log_hitfail} =
    1712. 

  1712. 	$tcp_miss_time{$log_hitfail} = 0
    1713. 

  1713. 	unless defined $tcp_miss{$log_hitfail};
    1714. 

  1714.       $tcp_miss{$log_hitfail}++;
    1715. 

  1715.       $tcp_miss_size{$log_hitfail} += $log_size;
    1716. 

  1716.       $tcp_miss_time{$log_hitfail} += $log_reqtime;'
    1717. 

  1717.     if ($opt_s)
    1718. 

  1718.     and $opt_f ne 'elff';
    1719. 

  1719.   $loop .= '
    1720. 

  1720.       $tcp_miss_requester{$requester} = $tcp_miss_requester_size{$requester} =
    1721. 

  1721. 	0
    1722. 

  1722. 	unless defined $tcp_miss_requester{$requester};
    1723. 

  1723.       $tcp_miss_requester{$requester}++;
    1724. 

  1724.       $tcp_miss_requester_size{$requester} += $log_size;' if ($opt_r);
    1725. 

  1725.   $loop .= '
    1726. 

  1726.     }
    1727. 

  1727.     if ( $log_hier_method !~ m#EMPTY|NONE|NULL|^\-$#o ) {
    1728. 

  1728.       $hier++;
    1729. 

  1729.       $hier_size += $log_size;
    1730. 

  1730.       $hier_time += $log_reqtime;
    1731. 

  1731.       if ( $log_hier_method =~ m#DIRECT|SOURCE_FASTEST#o ) {
    1732. 

  1732. 	$hier_direct++;
    1733. 

  1733. 	$hier_direct_size += $log_size;
    1734. 

  1734. 	$hier_direct_time += $log_reqtime;';
    1735. 

  1735.   $loop .= '
    1736. 

  1736. 	$perf_hier_direct_size{$perf_date} += $log_size;
    1737. 

  1737. 	$perf_hier_direct_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1738. 

  1738.   $loop .= '
    1739. 

  1739. 	$hier_direct{$log_hier_method} = $hier_direct_size{$log_hier_method} =
    1740. 

  1740. 	  $hier_direct_time{$log_hier_method} = 0
    1741. 

  1741. 	  unless defined $hier_direct{$log_hier_method};
    1742. 

  1742. 	$hier_direct{$log_hier_method}++;
    1743. 

  1743. 	$hier_direct_size{$log_hier_method} += $log_size;
    1744. 

  1744. 	$hier_direct_time{$log_hier_method} += $log_reqtime;'
    1745. 

  1745.     if ($opt_s)
    1746. 

  1746.       and $opt_f ne 'elff';
    1747. 

  1747.   $loop .= '
    1748. 

  1748.       } elsif ( $log_hier_method =~
    1749. 

  1749. 	       m#(CACHE_DIGEST|NEIGHBOR|PARENT|SIBLING)_\w*HIT|SIBLING#o )
    1750. 

  1750.       {
    1751. 

  1751. 	$hier_sibling++;
    1752. 

  1752. 	$hier_sibling_size += $log_size;
    1753. 

  1753. 	$hier_sibling_time += $log_reqtime;';
    1754. 

  1754.   $loop .= '
    1755. 

  1755. 	$perf_hier_sibling_size{$perf_date} += $log_size;
    1756. 

  1756. 	$perf_hier_sibling_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1757. 

  1757.   $loop .= '
    1758. 

  1758. 	$hier_sibling{$log_hier_method} = $hier_sibling_size{$log_hier_method}
    1759. 

  1759. 	  = $hier_sibling_time{$log_hier_method} = 0
    1760. 

  1760. 	  unless defined $hier_sibling{$log_hier_method};
    1761. 

  1761. 	$hier_sibling{$log_hier_method}++;
    1762. 

  1762. 	$hier_sibling_size{$log_hier_method} += $log_size;
    1763. 

  1763. 	$hier_sibling_time{$log_hier_method} += $log_reqtime;'
    1764. 

  1764.     if ($opt_s)
    1765. 

  1765.       and $opt_f ne 'elff';
    1766. 

  1766.   $loop .= '
    1767. 

  1767. 	$hier_neighbor{$log_hier_host} = $hier_neighbor_size{$log_hier_host} =
    1768. 

  1768. 	  $hier_neighbor_time{$log_hier_host} = 0
    1769. 

  1769. 	  unless defined $hier_neighbor{$log_hier_host};
    1770. 

  1770. 	$hier_neighbor{$log_hier_host}++;
    1771. 

  1771. 	$hier_neighbor_size{$log_hier_host} += $log_size;
    1772. 

  1772. 	$hier_neighbor_time{$log_hier_host} += $log_reqtime;';
    1773. 

  1773.   $loop .= '
    1774. 

  1774. 	$hier_neighbor_status{$log_hier_host}{$log_hier_method} =
    1775. 

  1775. 	  $hier_neighbor_status_size{$log_hier_host}{$log_hier_method} =
    1776. 

  1776. 	  $hier_neighbor_status_time{$log_hier_host}{$log_hier_method} = 0
    1777. 

  1777. 	  unless
    1778. 

  1778. 	  defined $hier_neighbor_status{$log_hier_host}{$log_hier_method};
    1779. 

  1779. 	$hier_neighbor_status{$log_hier_host}{$log_hier_method}++;
    1780. 

  1780. 	$hier_neighbor_status_size{$log_hier_host}{$log_hier_method} +=
    1781. 

  1781. 	  $log_size;
    1782. 

  1782. 	$hier_neighbor_status_time{$log_hier_host}{$log_hier_method} +=
    1783. 

  1783. 	  $log_reqtime;' if ($opt_s);
    1784. 

  1784.   $loop .= '
    1785. 

  1785.       } elsif ( $log_hier_method =~
    1786. 

  1786. 	       m#(ANY|CLOSEST|DEFAULT|FIRST_UP|PASSTHROUGH|ROUNDROBIN|SINGLE)_PARENT|CARP|PARENT_MISS|PARENT|PROXY#o
    1787. 

  1787. 	       )
    1788. 

  1788.       {
    1789. 

  1789. 	$hier_parent++;
    1790. 

  1790. 	$hier_parent_size += $log_size;
    1791. 

  1791. 	$hier_parent_time += $log_reqtime;';
    1792. 

  1792.   $loop .= '
    1793. 

  1793. 	$perf_hier_parent_size{$perf_date} += $log_size;
    1794. 

  1794. 	$perf_hier_parent_time{$perf_date} += $log_reqtime;' if ($opt_P);
    1795. 

  1795.   $loop .= '
    1796. 

  1796. 	$hier_parent{$log_hier_method} = $hier_parent_size{$log_hier_method} =
    1797. 

  1797. 	  $hier_parent_time{$log_hier_method} = 0
    1798. 

  1798. 	  unless defined $hier_parent{$log_hier_method};
    1799. 

  1799. 	$hier_parent{$log_hier_method}++;
    1800. 

  1800. 	$hier_parent_size{$log_hier_method} += $log_size;
    1801. 

  1801. 	$hier_parent_time{$log_hier_method} += $log_reqtime;'
    1802. 

  1802.     if ($opt_s)
    1803. 

  1803.       and $opt_f ne 'elff';
    1804. 

  1804.   $loop .= '
    1805. 

  1805. 	$hier_neighbor{$log_hier_host} = $hier_neighbor_size{$log_hier_host} =
    1806. 

  1806. 	  $hier_neighbor_time{$log_hier_host} = 0
    1807. 

  1807. 	  unless defined $hier_neighbor{$log_hier_host};
    1808. 

  1808. 	$hier_neighbor{$log_hier_host}++;
    1809. 

  1809. 	$hier_neighbor_size{$log_hier_host} += $log_size;
    1810. 

  1810. 	$hier_neighbor_time{$log_hier_host} += $log_reqtime;';
    1811. 

  1811.   $loop .= '
    1812. 

  1812. 	$hier_neighbor_status{$log_hier_host}{$log_hier_method} =
    1813. 

  1813. 	  $hier_neighbor_status_size{$log_hier_host}{$log_hier_method} =
    1814. 

  1814. 	  $hier_neighbor_status_time{$log_hier_host}{$log_hier_method} = 0
    1815. 

  1815. 	  unless
    1816. 

  1816. 	  defined $hier_neighbor_status{$log_hier_host}{$log_hier_method};
    1817. 

  1817. 	$hier_neighbor_status{$log_hier_host}{$log_hier_method}++;
    1818. 

  1818. 	$hier_neighbor_status_size{$log_hier_host}{$log_hier_method} +=
    1819. 

  1819. 	  $log_size;
    1820. 

  1820. 	$hier_neighbor_status_time{$log_hier_host}{$log_hier_method} +=
    1821. 

  1821. 	  $log_reqtime;' if ($opt_s);
    1822. 

  1822.   $loop .= '
    1823. 

  1823.       } else {
    1824. 

  1824. 	chomp($log_hier_method);
    1825. 

  1825. 	unless ( defined $errormsg ) {
    1826. 

  1826. 	  print STDERR "
    1827. 

  1827. Please check the following error(s). If you\'re sure that the offending
    1828. 

  1828. line(s) are NOT corrupt and the error also occurs with the recent version of
    1829. 

  1829. Calamaris (see the README for pointers and known bugs) then report them.
    1830. 

  1830. Don\'t send me thousands of similar errors. use <Calamaris-bug\@Cord.de>.
    1831. 

  1831. Thank You.
    1832. 

  1832. " unless $errormsg;
    1833. 

  1833. 	  $errormsg = 1;
    1834. 

  1834. 	}
    1835. 

  1835. 	warn( "
    1836. 

  1836. unknown log_hier_method: \"$log_hier_method\" found in line $counter of input:
    1837. 

  1837.  $line"
    1838. 

  1838. 	     );
    1839. 

  1839.       }
    1840. 

  1840.     }
    1841. 

  1841.   }
    1842. 

  1842. }';
    1843. 

  1843.   $time_run = time - $time_run;
    1844. 

  1844.   print STDERR "$loop\n" if $opt_L;
    1845. 

  1845.   eval $loop;
    1846. 

  1846.   die $@ if $@;
    1847. 

  1847.   $time_run = time - $time_run;
    1848. 

  1848. }
    1849. 

  1849. 

  1850. ### Yea! File read. Now for something completely different ;-)
    1851. 

  1851. 

  1852. if ( $counter == 0 ) {
    1853. 

  1853.   print "\nno requests found\n";
    1854. 

  1854.   exit(0);
    1855. 

  1855. }
    1856. 

  1856. open( CACHE, ">$opt_o" ) or die ("$0: can't open $opt_o for writing: $!\n")
    1857. 

  1857.   if ($opt_o);
    1858. 

  1858. writecache(
    1859. 

  1859. 	   'A', $time_begin, $time_end, $counter, $size, $time, $invalid,
    1860. 

  1860. 	   $time_run, $udp, $udp_size, $udp_time, $udp_hit, $udp_hit_size,
    1861. 

  1861. 	   $udp_hit_time, $udp_miss, $udp_miss_size, $udp_miss_time, $tcp,
    1862. 

  1862. 	   $tcp_size, $tcp_time, $tcp_hit, $tcp_hit_size, $tcp_hit_time,
    1863. 

  1863. 	   $tcp_miss, $tcp_miss_size, $tcp_miss_time, $tcp_miss_none,
    1864. 

  1864. 	   $tcp_miss_none_size, $tcp_miss_none_time, $hier, $hier_size,
    1865. 

  1865. 	   $hier_time, $hier_direct, $hier_direct_size, $hier_direct_time,
    1866. 

  1866. 	   $hier_sibling, $hier_sibling_size, $hier_sibling_time,
    1867. 

  1867. 	   $hier_parent, $hier_parent_size, $hier_parent_time
    1868. 

  1868. 	   );
    1869. 

  1869. $date_start = convertdate($time_begin);
    1870. 

  1870. $date_stop = convertdate($time_end);
    1871. 

  1871. $generated = convertdate(time);
    1872. 

  1872. 

  1873. $out_head = '';
    1874. 

  1874. $out_head .= 'MIME-Version: 1.0
    1875. 

  1875. Content-Type: text/html; charset=us-ascii
    1876. 

  1876. Content-Transfer-Encoding: 7bit
    1877. 

  1877. ' if ( $outtype_mail and $outtype_html );
    1878. 

  1878. $out_head .=
    1879. 

  1879.   "Subject: ${host_name}Proxy Report ($date_start - $date_stop)\n\n"
    1880. 

  1880.   if ($outtype_mail);
    1881. 

  1881. if ( $outtype_html or $outtype_htmlembed ) {
    1882. 

  1882.   $out_head .=
    1883. 

  1883.     "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"
    1884. 

  1884. 	\"http://www.w3.org/TR/REC-html40/loose.dtd\">
    1885. 

  1885. <html>
    1886. 

  1886.  <head>
    1887. 

  1887.   <title>${host_name}Proxy Report ($date_start - $date_stop)</title>
    1888. 

  1888.   <meta name=\"generator\" content=\"Calamaris/" . '$Revision: 2.59 $' . "\">
    1889. 

  1889. " . ( $opt_M ? '  ' . $opt_M . "\n" : '' ) .
    1890. 

  1890. " </head>
    1891. 

  1891.  <body bgcolor=\"#FFFFFF\">
    1892. 

  1892.   <table border=\"0\">
    1893. 

  1893.    <tr>\n" if ($outtype_html);
    1894. 

  1894.   $out_head .= "    <td>$opt_l</td>\n" if ( $opt_l and $outtype_html );
    1895. 

  1895.   $out_head .= "    <td>
    1896. 

  1896.      <h1><a name=\"top\">${host_name}Proxy Report</a></h1>
    1897. 

  1897.      <p>$date_start - $date_stop</p>
    1898. 

  1898.     </td>
    1899. 

  1899.    </tr>
    1900. 

  1900.   </table>
    1901. 

  1901.   <hr>
    1902. 

  1902.   <ul>\n" if ($outtype_html);
    1903. 

  1903.   $out_head .= "<p>$date_start - $date_stop</p>
    1904. 

  1904.   <ul>\n" if ($outtype_htmlembed);
    1905. 

    1906. 

  1906.   if ($opt_S) {
    1907. 

  1907.     foreach ( split ( ",", $opt_S ) ) {
    1908. 

  1908.       outref($_);
    1909. 

  1909.     }
    1910. 

  1910.   } else {
    1911. 

  1911.     outref(0);
    1912. 

  1912.     outref(1) if ($opt_p);
    1913. 

  1913.     outref(2) if ( $opt_p and $opt_p eq 'new' );
    1914. 

  1914.     outref(3);
    1915. 

  1915.     outref(4);
    1916. 

  1916.     outref(5);
    1917. 

  1917.     outref(6);
    1918. 

  1918.     outref(7);
    1919. 

  1919.     if ($opt_d) {
    1920. 

  1920.       outref(8);
    1921. 

  1921.       outref(9);
    1922. 

  1922.     }
    1923. 

  1923.     if ($opt_t) {
    1924. 

  1924.       outref(10);
    1925. 

  1925.       outref(11);
    1926. 

  1926.       outref(12);
    1927. 

  1927.     }
    1928. 

  1928.     if ($opt_r) {
    1929. 

  1929.       outref(13);
    1930. 

  1930.       outref(14);
    1931. 

  1931.     }
    1932. 

  1932.     outref(15) if ($opt_D);
    1933. 

  1933.     outref(16) if ($opt_P);
    1934. 

  1934.   }
    1935. 

  1935.   $out_head .= "  </ul>\n";
    1936. 

  1936. } else {
    1937. 

  1937.   $out_head .= "
    1938. 

  1938. ${host_name}Proxy-Report\n
    1939. 

  1939. Report period: $date_start - $date_stop
    1940. 

  1940. Generated at:  $generated\n";
    1941. 

  1941. }
    1942. 

  1942. 

  1943. if ( ( $invalid / $counter ) > .05 and $counter > 1000 ) {
    1944. 

  1944.   @format = (60);
    1945. 

  1945.   outstart('E');
    1946. 

  1946.   outline( 'E', '' );
    1947. 

  1947.   outline( 'E', 'More than 5% discarded logfile-lines.' );
    1948. 

  1948.   outline( 'E', 'Please check your logfile with calamaris -v' )
    1949. 

  1949.     unless ($opt_v);
    1950. 

  1950.   outstop('E');
    1951. 

  1951. }
    1952. 

  1952. 

  1953. if ( defined($output_warn) ) {
    1954. 

  1954.   @format = (60);
    1955. 

  1955.   outstart('E');
    1956. 

  1956.   outline( 'E', '' );
    1957. 

  1957.   outline( 'E', 'Output Options have been changed' );
    1958. 

  1958.   outline( 'E',
    1959. 

  1959. 	  'You shouldn\'t use -w, -W and -m anymore and use -F instead' );
    1960. 

  1960.   outline( 'E', '' );
    1961. 

  1961.   outline( 'E', 'For now Calamaris maps the old switch to the new, but' );
    1962. 

  1962.   outline( 'E', 'the workaround will be removed at end of 2003' );
    1963. 

  1963.   outstop('E');
    1964. 

  1964. }
    1965. 

  1965. 

  1966. if ( defined($peak_warn) ) {
    1967. 

  1967.   @format = (60);
    1968. 

  1968.   outstart('E');
    1969. 

  1969.   outline( 'E', '' );
    1970. 

  1970.   outline( 'E', "$peak_warn" );
    1971. 

  1971.   outline( 'E', 'Please read the README on unsorted input' );
    1972. 

  1972.   outline( 'E', 'To find out which line caused this, try calamaris -v' )
    1973. 

  1973.     unless ($opt_v);
    1974. 

  1974.   outstop('E');
    1975. 

  1975. }
    1976. 

  1976. 

  1977. if ( $cache_warn1 or $cache_warn2 or $cache_warn3 ) {
    1978. 

  1978.   @format = (60);
    1979. 

  1979.   outstart('E');
    1980. 

  1980.   outline( 'E', '' );
    1981. 

  1981.   outline( 'E',
    1982. 

  1982. 	  'Caused by bugs, there were some changes in Cache-File-Format' );
    1983. 

  1983.   outline( 'E',
    1984. 

  1984. 	  'in the lifetime of Calamaris. Your Cachefiles still contain' );
    1985. 

  1985.   outline( 'E', 'some buggy lines, which causes the following problems:' );
    1986. 

  1986.   outline( 'E', '' );
    1987. 

  1987.   outline( 'E', "$cache_warn1" ) if $cache_warn1;
    1988. 

  1988.   outline( 'E', "$cache_warn2" ) if $cache_warn2;
    1989. 

  1989.   outline( 'E', "$cache_warn3" ) if $cache_warn3;
    1990. 

  1990.   outline( 'E', '' );
    1991. 

  1991.   outline( 'E', 'To correct the problem you should run Calamaris with' );
    1992. 

  1992.   outline( 'E',
    1993. 

  1993. 	  'calamaris -i buggy.cache -o buggy.cache -z [usual_options]' );
    1994. 

  1994.   outline( 'E',
    1995. 

  1995. 	  'the workarounds are scheduled to be removed at end of 2003' );
    1996. 

  1996.   outstop('E');
    1997. 

  1997. }
    1998. 

  1998. 

  1999. if ( $opt_I and $opt_i ) {
    2000. 

  2000.   @format = (60);
    2001. 

  2001.   outstart('E');
    2002. 

  2002.   outline( 'E', '' );
    2003. 

  2003.   outline( 'E', 'You have run Calamaris with the -I (Interval) and the -i' );
    2004. 

  2004.   outline( 'E', '(input cache) option. This is normally not useful,' );
    2005. 

  2005.   outline( 'E', 'because the time-interval cannot be applied to' );
    2006. 

  2006.   outline( 'E', 'cache-files.' );
    2007. 

  2007.   outstop('E');
    2008. 

  2008. }
    2009. 

  2009. 

  2010. @format = ( 19, 8 );
    2011. 

  2011. outstart(0);
    2012. 

  2012. outline( 0, 'lines parsed:', $counter );
    2013. 

  2013. outline( 0, 'invalid lines:', $invalid );
    2014. 

  2014. outline( 0, 'skipped lines:', $skipped ) if $opt_I;
    2015. 

  2015. outline( 0, 'unique hosts/users:', scalar keys %tcp_requester ) if $opt_r;
    2016. 

  2016. outline( 0, 'parse time (sec):', $time_run );
    2017. 

  2017. outstop(0);
    2018. 

  2018. 

  2019. if ( not defined $opt_p ) {
    2020. 

  2020. } elsif ( $opt_p eq 'old' ) {
    2021. 

  2021.   @format = ( 3, 4, 18, 5, 18, 7, 18 );
    2022. 

  2022.   writecache(
    2023. 

  2023. 	     'B', $peak_udp_sec, $peak_udp_sec_time, $peak_udp_min,
    2024. 

  2024. 	     $peak_udp_min_time, $peak_udp_hour, $peak_udp_hour_time,
    2025. 

  2025. 	     $peak_tcp_sec, $peak_tcp_sec_time, $peak_tcp_min,
    2026. 

  2026. 	     $peak_tcp_min_time, $peak_tcp_hour, $peak_tcp_hour_time,
    2027. 

  2027. 	     $peak_all_sec, $peak_all_sec_time, $peak_all_min,
    2028. 

  2028. 	     $peak_all_min_time, $peak_all_hour, $peak_all_hour_time
    2029. 

  2029. 	     );
    2030. 

  2030.   outstart(1);
    2031. 

  2031.   outheader(
    2032. 

  2032. 	    1, 'prt', ' sec', 'peak begins at', ' min', 'peak begins at',
    2033. 

  2033. 	    ' hour', 'peak begins at'
    2034. 

  2034. 	    );
    2035. 

  2035.   outseperator(1);
    2036. 

  2036.   outline(
    2037. 

  2037. 	  1, 'UDP', $peak_udp_sec, convertdate($peak_udp_sec_time),
    2038. 

  2038. 	  $peak_udp_min, convertdate($peak_udp_min_time), $peak_udp_hour,
    2039. 

  2039. 	  convertdate($peak_udp_hour_time)
    2040. 

  2040. 	  );
    2041. 

  2041.   outline(
    2042. 

  2042. 	  1, 'TCP', $peak_tcp_sec, convertdate($peak_tcp_sec_time),
    2043. 

  2043. 	  $peak_tcp_min, convertdate($peak_tcp_min_time), $peak_tcp_hour,
    2044. 

  2044. 	  convertdate($peak_tcp_hour_time)
    2045. 

  2045. 	  );
    2046. 

  2046.   outseperator(1);
    2047. 

  2047.   outline(
    2048. 

  2048. 	  1, 'ALL', $peak_all_sec, convertdate($peak_all_sec_time),
    2049. 

  2049. 	  $peak_all_min, convertdate($peak_all_min_time), $peak_all_hour,
    2050. 

  2050. 	  convertdate($peak_all_hour_time)
    2051. 

  2051. 	  );
    2052. 

  2052.   outstop(1);
    2053. 

  2053. } elsif ( $opt_p eq 'new' ) {
    2054. 

  2054.   @format = ( 3, 4, 18, 5, 18, 7, 18 );
    2055. 

  2055.   $peak_udp_hour_time =
    2056. 

  2056.     ( sort { $peak_udp_hour{$b} <=> $peak_udp_hour{$a} }
    2057. 

  2057.      keys(%peak_udp_hour) )[0]
    2058. 

  2058.      or $peak_udp_hour_time = $peak_udp_hour{0} = 0;
    2059. 

  2059.   $peak_udp_hour_size_time =
    2060. 

  2060.     ( sort { $peak_udp_hour_size{$b} <=> $peak_udp_hour_size{$a} }
    2061. 

  2061.      keys(%peak_udp_hour_size) )[0]
    2062. 

  2062.      or $peak_udp_hour_size_time = $peak_udp_hour_size{0} = 0;
    2063. 

  2063.   $peak_tcp_hour_time =
    2064. 

  2064.     ( sort { $peak_tcp_hour{$b} <=> $peak_tcp_hour{$a} }
    2065. 

  2065.      keys(%peak_tcp_hour) )[0]
    2066. 

  2066.     or $peak_tcp_hour_time = $peak_tcp_hour{0} = 0;
    2067. 

  2067.   $peak_tcp_hour_size_time =
    2068. 

  2068.     ( sort { $peak_tcp_hour_size{$b} <=> $peak_tcp_hour_size{$a} }
    2069. 

  2069.      keys(%peak_tcp_hour_size) )[0]
    2070. 

  2070.     or $peak_tcp_hour_size_time = $peak_tcp_hour_size{0} = 0;
    2071. 

  2071.   $peak_all_hour_time =
    2072. 

  2072.     ( sort { $peak_all_hour{$b} <=> $peak_all_hour{$a} }
    2073. 

  2073.      keys(%peak_all_hour) )[0]
    2074. 

  2074.     or $peak_all_hour_time = $peak_all_hour{0} = 0;
    2075. 

  2075.   $peak_all_hour_size_time =
    2076. 

  2076.     ( sort { $peak_all_hour_size{$b} <=> $peak_all_hour_size{$a} }
    2077. 

  2077.      keys(%peak_all_hour_size) )[0]
    2078. 

  2078.     or $peak_all_hour_size_time = $peak_all_hour_size{0} = 0;
    2079. 

  2079.   writecache(
    2080. 

  2080. 	     'B', $peak_udp_sec, $peak_udp_sec_time, $peak_udp_min,
    2081. 

  2081. 	     $peak_udp_min_time, $peak_udp_hour{$peak_udp_hour_time},
    2082. 

  2082. 	     $peak_udp_hour_time,
    2083. 

  2083. 	     $peak_udp_hour_size{$peak_udp_hour_size_time},
    2084. 

  2084. 	     $peak_udp_hour_size_time, $peak_tcp_sec, $peak_tcp_sec_time,
    2085. 

  2085. 	     $peak_tcp_min, $peak_tcp_min_time,
    2086. 

  2086. 	     $peak_tcp_hour{$peak_tcp_hour_time}, $peak_tcp_hour_time,
    2087. 

  2087. 	     $peak_tcp_hour_size{$peak_tcp_hour_size_time},
    2088. 

  2088. 	     $peak_tcp_hour_size_time, $peak_all_sec, $peak_all_sec_time,
    2089. 

  2089. 	     $peak_all_min, $peak_all_min_time,
    2090. 

  2090. 	     $peak_all_hour{$peak_all_hour_time}, $peak_all_hour_time,
    2091. 

  2091. 	     $peak_all_hour_size{$peak_all_hour_size_time},
    2092. 

  2092. 	     $peak_all_hour_size_time
    2093. 

  2093. 	     );
    2094. 

  2094.   outstart(1);
    2095. 

  2095.   outheader(
    2096. 

  2096. 	    1, 'prt', ' sec', 'peak begins at', ' min', 'peak begins at',
    2097. 

  2097. 	    ' hour', 'peak begins at'
    2098. 

  2098. 	    );
    2099. 

  2099.   outseperator(1);
    2100. 

  2100.   outline(
    2101. 

  2101. 	  1, 'UDP', $peak_udp_sec, convertdate($peak_udp_sec_time),
    2102. 

  2102. 	  $peak_udp_min, convertdate($peak_udp_min_time),
    2103. 

  2103. 	  $peak_udp_hour{$peak_udp_hour_time},
    2104. 

  2104. 	  convertdate($peak_udp_hour_time)
    2105. 

  2105. 	  );
    2106. 

  2106.   outline(
    2107. 

  2107. 	  1, 'TCP', $peak_tcp_sec, convertdate($peak_tcp_sec_time),
    2108. 

  2108. 	  $peak_tcp_min, convertdate($peak_tcp_min_time),
    2109. 

  2109. 	  $peak_tcp_hour{$peak_tcp_hour_time},
    2110. 

  2110. 	  convertdate($peak_tcp_hour_time)
    2111. 

  2111. 	  );
    2112. 

  2112.   outseperator(1);
    2113. 

  2113.   outline(
    2114. 

  2114. 	  1, 'ALL', $peak_all_sec, convertdate($peak_all_sec_time),
    2115. 

  2115. 	  $peak_all_min, convertdate($peak_all_min_time),
    2116. 

  2116. 	  $peak_all_hour{$peak_all_hour_time},
    2117. 

  2117. 	  convertdate($peak_all_hour_time)
    2118. 

  2118. 	  );
    2119. 

  2119.   outstop(1);
    2120. 

  2120.   @format = ( 5, 8, 18 );
    2121. 

  2121.   outstart(2);
    2122. 

  2122.   outheader( 2, 'proto', ' kB/hour', 'peak begins at' );
    2123. 

  2123.   outseperator(2);
    2124. 

  2124.   outline( 2, 'UDP', $peak_udp_hour_size{$peak_udp_hour_size_time} / 1024,
    2125. 

  2125. 	  convertdate($peak_udp_hour_size_time) );
    2126. 

  2126.   outline( 2, 'TCP', $peak_tcp_hour_size{$peak_tcp_hour_size_time} / 1024,
    2127. 

  2127. 	  convertdate($peak_tcp_hour_size_time) );
    2128. 

  2128.   outseperator(2);
    2129. 

  2129.   outline( 2, 'ALL', $peak_all_hour_size{$peak_all_hour_size_time} / 1024,
    2130. 

  2130. 	  convertdate($peak_all_hour_size_time) );
    2131. 

  2131.   outstop(2);
    2132. 

  2132. }
    2133. 

  2133. 

  2134. @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2135. 

  2135. outstart(3);
    2136. 

  2136. if ( $counter == 0 ) {
    2137. 

  2137.   outline( 3, 'no matching requests' );
    2138. 

  2138. } else {
    2139. 

  2139.   outheader( 3, 'method', ' request', '% ',
    2140. 

  2140. 	    $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', ' sec',
    2141. 

  2141. 	    ' kB/sec' );
    2142. 

  2142.   outseperator(3);
    2143. 

  2143.   foreach $method (
    2144. 

  2144. 		   sort { ${"method$sortorder"}{$b} <=>
    2145. 

  2145. 			  ${"method$sortorder"}{$a} }
    2146. 

  2146. 		   keys(%method) )
    2147. 

  2147.   {
    2148. 

  2148.     writecache(
    2149. 

  2149. 	       'C', $method, $method{$method}, $method_size{$method},
    2150. 

  2150. 	       $method_time{$method}
    2151. 

  2151. 	       );
    2152. 

  2152.     outline( 3, $method, $method{$method}, 100 * $method{$method} / $counter,
    2153. 

  2153. 	    kilomegagigatera( $method_size{$method}, $format[3] ),
    2154. 

  2154. 	    $size ? 100 * $method_size{$method} / $size : 0,
    2155. 

  2155. 	    $method_time{$method} / ( 1000 * $method{$method} ),
    2156. 

  2156. 	    $method_size{$method} / ( 1.024 * $method_time{$method} ) );
    2157. 

  2157.   }
    2158. 

  2158.   outseperator(3);
    2159. 

  2159.   outline( 3, 'Sum', $counter, 100, kilomegagigatera( $size, $format[3] ),
    2160. 

  2160. 	  100, $time / ( $counter * 1000 ), $size / ( 1.024 * $time ) );
    2161. 

  2161. }
    2162. 

  2162. outstop(3);
    2163. 

  2163. 

  2164. @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2165. 

  2165. outstart(4);
    2166. 

  2166. if ( $udp == 0 ) {
    2167. 

  2167.   outline( 4, 'no matching requests' );
    2168. 

  2168. } else {
    2169. 

  2169.   outheader( 4, 'status', ' request', '% ',
    2170. 

  2170. 	    $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', 'msec',
    2171. 

  2171. 	    ' kB/sec' );
    2172. 

  2172.   outseperator(4);
    2173. 

  2173.   if ( $udp_hit == 0 ) {
    2174. 

  2174.     outline( 4, 'HIT', 0, 0, 0, 0, 0, 0 );
    2175. 

  2175.   } else {
    2176. 

  2176.     outline( 4, 'HIT', $udp_hit, 100 * $udp_hit / $udp,
    2177. 

  2177. 	    kilomegagigatera( $udp_hit_size, $format[3] ),
    2178. 

  2178. 	    $udp_size ? 100 * $udp_hit_size / $udp_size : 0,
    2179. 

  2179. 	    $udp_hit_time / $udp_hit,
    2180. 

  2180. 	    $udp_hit_size / ( 1.024 * $udp_hit_time ) );
    2181. 

  2181.     foreach $hitfail (
    2182. 

  2182. 		      sort { ${"udp_hit$sortorder"}{$b} <=>
    2183. 

  2183. 			    ${"udp_hit$sortorder"}{$a} } keys(%udp_hit) )
    2184. 

  2184.     {
    2185. 

  2185.       writecache(
    2186. 

  2186. 		 'D', $hitfail, $udp_hit{$hitfail}, $udp_hit_size{$hitfail},
    2187. 

  2187. 		 $udp_hit_time{$hitfail}
    2188. 

  2188. 		 );
    2189. 

  2189.       outline( 4, ' ' . $hitfail, $udp_hit{$hitfail},
    2190. 

  2190. 	      100 * $udp_hit{$hitfail} / $udp,
    2191. 

  2191. 	      kilomegagigatera( $udp_hit_size{$hitfail}, $format[3] ),
    2192. 

  2192. 	      $udp_size ? 100 * $udp_hit_size{$hitfail} / $udp_size : 0,
    2193. 

  2193. 	      $udp_hit_time{$hitfail} / $udp_hit{$hitfail},
    2194. 

  2194. 	      $udp_hit_size{$hitfail} / ( 1.024 * $udp_hit_time{$hitfail} ) );
    2195. 

  2195.     }
    2196. 

  2196.   }
    2197. 

  2197.   if ( $udp_miss == 0 ) {
    2198. 

  2198.     outline( 4, 'MISS', 0, 0, 0, 0, 0, 0 );
    2199. 

  2199.   } else {
    2200. 

  2200.     outline( 4, 'MISS', $udp_miss, 100 * $udp_miss / $udp,
    2201. 

  2201. 	    kilomegagigatera( $udp_miss_size, $format[3] ),
    2202. 

  2202. 	    $udp_size ? 100 * $udp_miss_size / $udp_size : 0,
    2203. 

  2203. 	    $udp_miss_time / $udp_miss,
    2204. 

  2204. 	    $udp_miss_size / ( 1.024 * $udp_miss_time ) );
    2205. 

  2205.     foreach $hitfail (
    2206. 

  2206. 		      sort { ${"udp_miss$sortorder"}{$b} <=>
    2207. 

  2207. 			    ${"udp_miss$sortorder"}{$a} } keys(%udp_miss) )
    2208. 

  2208.     {
    2209. 

  2209.       writecache(
    2210. 

  2210. 		 'E', $hitfail, $udp_miss{$hitfail}, $udp_miss_size{$hitfail},
    2211. 

  2211. 		 $udp_miss_time{$hitfail}
    2212. 

  2212. 		 );
    2213. 

  2213.       outline( 4, ' ' . $hitfail, $udp_miss{$hitfail},
    2214. 

  2214. 	      100 * $udp_miss{$hitfail} / $udp,
    2215. 

  2215. 	      kilomegagigatera( $udp_miss_size{$hitfail}, $format[3] ),
    2216. 

  2216. 	      $udp_size ? 100 * $udp_miss_size{$hitfail} / $udp_size : 0,
    2217. 

  2217. 	      $udp_miss_time{$hitfail} / $udp_miss{$hitfail},
    2218. 

  2218. 	      $udp_miss_size{$hitfail} / ( 1.024 * $udp_miss_time{$hitfail} ) );
    2219. 

  2219.     }
    2220. 

  2220.   }
    2221. 

  2221.   outseperator(4);
    2222. 

  2222.   outline( 4, 'Sum', $udp, 100, kilomegagigatera( $udp_size, $format[3] ),
    2223. 

  2223. 	  100, $udp_time / $udp, $udp_size / ( 1.024 * $udp_time ) );
    2224. 

  2224. }
    2225. 

  2225. outstop(4);
    2226. 

  2226. 

  2227. @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2228. 

  2228. outstart(5);
    2229. 

  2229. if ( $tcp_hit + $tcp_miss + $tcp_miss_none == 0 ) {
    2230. 

  2230.   outline( 5, 'no matching requests' );
    2231. 

  2231. } else {
    2232. 

  2232.   outheader( 5, 'status', ' request', '% ',
    2233. 

  2233. 	    $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', ' sec',
    2234. 

  2234. 	    ' kB/sec' );
    2235. 

  2235.   outseperator(5);
    2236. 

  2236.   if ( $tcp_hit == 0 ) {
    2237. 

  2237.     outline( 5, 'HIT', 0, 0, 0, 0, 0, 0 );
    2238. 

  2238.   } else {
    2239. 

  2239.     outline( 5, 'HIT', $tcp_hit, 100 * $tcp_hit / $tcp,
    2240. 

  2240. 	    kilomegagigatera( $tcp_hit_size, $format[3] ),
    2241. 

  2241. 	    $tcp_size ? 100 * $tcp_hit_size / $tcp_size : 0,
    2242. 

  2242. 	    $tcp_hit_time / ( 1000 * $tcp_hit ),
    2243. 

  2243. 	    $tcp_hit_size / ( 1.024 * $tcp_hit_time ) );
    2244. 

  2244.     foreach $hitfail (
    2245. 

  2245. 		      sort { ${"tcp_hit$sortorder"}{$b} <=>
    2246. 

  2246. 			    ${"tcp_hit$sortorder"}{$a} } keys(%tcp_hit) )
    2247. 

  2247.     {
    2248. 

  2248.       writecache(
    2249. 

  2249. 		 'F', $hitfail, $tcp_hit{$hitfail}, $tcp_hit_size{$hitfail},
    2250. 

  2250. 		 $tcp_hit_time{$hitfail}
    2251. 

  2251. 		 );
    2252. 

  2252.       outline( 5, ' ' . $hitfail, $tcp_hit{$hitfail},
    2253. 

  2253. 	      100 * $tcp_hit{$hitfail} / $tcp,
    2254. 

  2254. 	      kilomegagigatera( $tcp_hit_size{$hitfail}, $format[3] ),
    2255. 

  2255. 	      $tcp_size ? 100 * $tcp_hit_size{$hitfail} / $tcp_size : 0,
    2256. 

  2256. 	      $tcp_hit_time{$hitfail} / ( 1000 * $tcp_hit{$hitfail} ),
    2257. 

  2257. 	      $tcp_hit_size{$hitfail} / ( 1.024 * $tcp_hit_time{$hitfail} ) );
    2258. 

  2258.     }
    2259. 

  2259.   }
    2260. 

  2260.   if ( $tcp_miss == 0 ) {
    2261. 

  2261.     outline( 5, 'MISS', 0, 0, 0, 0, 0, 0 );
    2262. 

  2262.   } else {
    2263. 

  2263.     outline( 5, 'MISS', $tcp_miss, 100 * $tcp_miss / $tcp,
    2264. 

  2264. 	    kilomegagigatera( $tcp_miss_size, $format[3] ),
    2265. 

  2265. 	    $tcp_size ? 100 * $tcp_miss_size / $tcp_size : 0,
    2266. 

  2266. 	    $tcp_miss_time / ( 1000 * $tcp_miss ),
    2267. 

  2267. 	    $tcp_miss_size / ( 1.024 * $tcp_miss_time ) );
    2268. 

  2268.     foreach $hitfail (
    2269. 

  2269. 		      sort { ${"tcp_miss$sortorder"}{$b} <=>
    2270. 

  2270. 			    ${"tcp_miss$sortorder"}{$a} }
    2271. 

  2271. 		      keys(%tcp_miss) )
    2272. 

  2272.     {
    2273. 

  2273.       writecache(
    2274. 

  2274. 		 'G', $hitfail, $tcp_miss{$hitfail}, $tcp_miss_size{$hitfail},
    2275. 

  2275. 		 $tcp_miss_time{$hitfail}
    2276. 

  2276. 		 );
    2277. 

  2277.       outline( 5, ' ' . $hitfail, $tcp_miss{$hitfail},
    2278. 

  2278. 	      100 * $tcp_miss{$hitfail} / $tcp,
    2279. 

  2279. 	      kilomegagigatera( $tcp_miss_size{$hitfail}, $format[3] ),
    2280. 

  2280. 	      $tcp_size ? 100 * $tcp_miss_size{$hitfail} / $tcp_size : 0,
    2281. 

  2281. 	      $tcp_miss_time{$hitfail} / ( 1000 * $tcp_miss{$hitfail} ),
    2282. 

  2282. 	      $tcp_miss_size{$hitfail} / ( 1.024 * $tcp_miss_time{$hitfail} )
    2283. 

  2283. 	      );
    2284. 

  2284.     }
    2285. 

  2285.   }
    2286. 

  2286.   if ( $tcp_miss_none == 0 ) {
    2287. 

  2287.     outline( 5, 'ERROR', 0, 0, 0, 0, 0, 0 );
    2288. 

  2288.   } else {
    2289. 

  2289.     outline( 5, 'ERROR', $tcp_miss_none, 100 * $tcp_miss_none / $tcp,
    2290. 

  2290. 	    kilomegagigatera( $tcp_miss_none_size, $format[3] ),
    2291. 

  2291. 	    $tcp_size ? 100 * $tcp_miss_none_size / $tcp_size : 0,
    2292. 

  2292. 	    $tcp_miss_none_time / ( 1000 * $tcp_miss_none ),
    2293. 

  2293. 	    $tcp_miss_none_size / ( 1.024 * $tcp_miss_none_time ) );
    2294. 

  2294.     foreach $hitfail ( sort {
    2295. 

  2295.       ${"tcp_miss_none$sortorder"}{$b} <=> ${"tcp_miss_none$sortorder"}{$a}
    2296. 

  2296. 	} keys(%tcp_miss_none)
    2297. 

  2297. 		      )
    2298. 

  2298.     {
    2299. 

  2299.       writecache(
    2300. 

  2300. 		 'H', $hitfail, $tcp_miss_none{$hitfail},
    2301. 

  2301. 		 $tcp_miss_none_size{$hitfail},
    2302. 

  2302. 		 $tcp_miss_none_time{$hitfail}
    2303. 

  2303. 		 );
    2304. 

  2304.       outline( 5, ' ' .  $hitfail, $tcp_miss_none{$hitfail},
    2305. 

  2305. 	      100 * $tcp_miss_none{$hitfail} / $tcp,
    2306. 

  2306. 	      kilomegagigatera( $tcp_miss_none_size{$hitfail}, $format[3] ),
    2307. 

  2307. 	      $tcp_size ? 100 * $tcp_miss_none_size{$hitfail} / $tcp_size : 0,
    2308. 

  2308. 	      $tcp_miss_none_time{$hitfail} /
    2309. 

  2309. 		( 1000 * $tcp_miss_none{$hitfail} ),
    2310. 

  2310. 	      $tcp_miss_none_size{$hitfail} /
    2311. 

  2311. 		( 1.024 * $tcp_miss_none_time{$hitfail} ) );
    2312. 

  2312.     }
    2313. 

  2313.   }
    2314. 

  2314.   outseperator(5);
    2315. 

  2315.   outline( 5, 'Sum', $tcp, 100, kilomegagigatera( $tcp_size, $format[3] ),
    2316. 

  2316. 	  100, $tcp_time / ( 1000 * $tcp ), $tcp_size / ( 1.024 * $tcp_time )
    2317. 

  2317. 	  );
    2318. 

  2318. }
    2319. 

  2319. outstop(5);
    2320. 

  2320. 

  2321. @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2322. 

  2322. outstart(6);
    2323. 

  2323. if ( $hier == 0 ) {
    2324. 

  2324.   outline( 6, 'no matching requests' );
    2325. 

  2325. } else {
    2326. 

  2326.   outheader( 6, 'status', ' request', '% ',
    2327. 

  2327. 	    $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', ' sec',
    2328. 

  2328. 	    ' kB/sec' );
    2329. 

  2329.   outseperator(6);
    2330. 

  2330.   if ( $hier_direct == 0 ) {
    2331. 

  2331.     outline( 6, 'DIRECT', 0, 0, 0, 0, 0, 0 );
    2332. 

  2332.   } else {
    2333. 

  2333.     outline( 6, 'DIRECT Fetch from Source', $hier_direct,
    2334. 

  2334. 	    100 * $hier_direct / $hier,
    2335. 

  2335. 	    kilomegagigatera( $hier_direct_size, $format[3] ),
    2336. 

  2336. 	    $hier_size ? 100 * $hier_direct_size / $hier_size : 0,
    2337. 

  2337. 	    $hier_direct_time / ( 1000 * $hier_direct ),
    2338. 

  2338. 	    $hier_direct_size / ( 1.024 * $hier_direct_time ) );
    2339. 

  2339.     foreach $hitfail ( sort {
    2340. 

  2340.       ${"hier_direct$sortorder"}{$b} <=> ${"hier_direct$sortorder"}{$a}
    2341. 

  2341. 	} keys(%hier_direct)
    2342. 

  2342. 		      )
    2343. 

  2343.     {
    2344. 

  2344.       writecache(
    2345. 

  2345. 		 'I', $hitfail, $hier_direct{$hitfail},
    2346. 

  2346. 		 $hier_direct_size{$hitfail}, $hier_direct_time{$hitfail}
    2347. 

  2347. 		 );
    2348. 

  2348.       outline( 6, ' ' . $hitfail, $hier_direct{$hitfail},
    2349. 

  2349. 	      100 * $hier_direct{$hitfail} / $hier,
    2350. 

  2350. 	      kilomegagigatera( $hier_direct_size{$hitfail}, $format[3] ),
    2351. 

  2351. 	      $hier_size ? 100 * $hier_direct_size{$hitfail} / $hier_size : 0,
    2352. 

  2352. 	      $hier_direct_time{$hitfail} / ( 1000 * $hier_direct{$hitfail} ),
    2353. 

  2353. 	      $hier_direct_size{$hitfail} /
    2354. 

  2354. 		( 1.024 * $hier_direct_time{$hitfail} ) );
    2355. 

  2355.     }
    2356. 

  2356.   }
    2357. 

  2357.   if ( $hier_sibling == 0 ) {
    2358. 

  2358.     outline( 6, 'SIBLING', 0, 0, 0, 0, 0, 0 );
    2359. 

  2359.   } else {
    2360. 

  2360.     outline( 6, 'HIT on Sibling or Parent Cache', $hier_sibling,
    2361. 

  2361. 	    100 * $hier_sibling / $hier,
    2362. 

  2362. 	    kilomegagigatera( $hier_sibling_size, $format[3] ),
    2363. 

  2363. 	    $hier_size ? 100 * $hier_sibling_size / $hier_size : 0,
    2364. 

  2364. 	    $hier_sibling_time / ( 1000 * $hier_sibling ),
    2365. 

  2365. 	    $hier_sibling_size / ( 1.024 * $hier_sibling_time ) );
    2366. 

  2366.     foreach $hitfail ( sort {
    2367. 

  2367.       ${"hier_sibling$sortorder"}{$b} <=> ${"hier_sibling$sortorder"}{$a}
    2368. 

  2368. 	} keys(%hier_sibling)
    2369. 

  2369. 		      )
    2370. 

  2370.     {
    2371. 

  2371.       writecache(
    2372. 

  2372. 		 'J', $hitfail, $hier_sibling{$hitfail},
    2373. 

  2373. 		 $hier_sibling_size{$hitfail}, $hier_sibling_time{$hitfail}
    2374. 

  2374. 		 );
    2375. 

  2375.       outline( 6, ' ' . $hitfail, $hier_sibling{$hitfail},
    2376. 

  2376. 	      100 * $hier_sibling{$hitfail} / $hier,
    2377. 

  2377. 	      kilomegagigatera( $hier_sibling_size{$hitfail}, $format[3] ),
    2378. 

  2378. 	      $hier_size ? 100 * $hier_sibling_size{$hitfail} / $hier_size : 0,
    2379. 

  2379. 	      $hier_sibling_time{$hitfail} /
    2380. 

  2380. 		( 1000 * $hier_sibling{$hitfail} ),
    2381. 

  2381. 	      $hier_sibling_size{$hitfail} /
    2382. 

  2382. 		( 1.024 * $hier_sibling_time{$hitfail} ) );
    2383. 

  2383.     }
    2384. 

  2384.   }
    2385. 

  2385.   if ( $hier_parent == 0 ) {
    2386. 

  2386.     outline( 6, 'PARENT', 0, 0, 0, 0, 0, 0 );
    2387. 

  2387.   } else {
    2388. 

  2388.     outline( 6, 'FETCH from Parent Cache', $hier_parent,
    2389. 

  2389. 	    100 * $hier_parent / $hier,
    2390. 

  2390. 	    kilomegagigatera( $hier_parent_size, $format[3] ),
    2391. 

  2391. 	    $hier_size ? 100 * $hier_parent_size / $hier_size : 0,
    2392. 

  2392. 	    $hier_parent_time / ( 1000 * $hier_parent ),
    2393. 

  2393. 	    $hier_parent_size / ( 1.024 * $hier_parent_time ) );
    2394. 

  2394.     foreach $hitfail ( sort {
    2395. 

  2395.       ${"hier_parent$sortorder"}{$b} <=> ${"hier_parent$sortorder"}{$a}
    2396. 

  2396. 	} keys(%hier_parent)
    2397. 

  2397. 		      )
    2398. 

  2398.     {
    2399. 

  2399.       writecache(
    2400. 

  2400. 		 'K', $hitfail, $hier_parent{$hitfail},
    2401. 

  2401. 		 $hier_parent_size{$hitfail}, $hier_parent_time{$hitfail}
    2402. 

  2402. 		 );
    2403. 

  2403.       outline( 6, ' ' . $hitfail, $hier_parent{$hitfail},
    2404. 

  2404. 	      100 * $hier_parent{$hitfail} / $hier,
    2405. 

  2405. 	      kilomegagigatera( $hier_parent_size{$hitfail}, $format[3] ),
    2406. 

  2406. 	      $hier_size ? 100 * $hier_parent_size{$hitfail} / $hier_size : 0,
    2407. 

  2407. 	      $hier_parent_time{$hitfail} / ( 1000 * $hier_parent{$hitfail} ),
    2408. 

  2408. 	      $hier_parent_size{$hitfail} /
    2409. 

  2409. 		( 1.024 * $hier_parent_time{$hitfail} ) );
    2410. 

  2410.     }
    2411. 

  2411.   }
    2412. 

  2412.   outseperator(6);
    2413. 

  2413.   outline( 6, 'Sum', $hier, 100, kilomegagigatera( $hier_size, $format[3] ),
    2414. 

  2414. 	  100, $hier_time / ( 1000 * $hier ),
    2415. 

  2415. 	  $hier_size / ( 1.024 * $hier_time ) );
    2416. 

  2416. }
    2417. 

  2417. outstop(6);
    2418. 

  2418. 

  2419. @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2420. 

  2420. outstart(7);
    2421. 

  2421. if ( $hier == 0 ) {
    2422. 

  2422.   outline( 7, 'no matching requests' );
    2423. 

  2423. } else {
    2424. 

  2424.   outheader( 7, 'neighbor type', ' request', '% ',
    2425. 

  2425. 	    $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', ' sec',
    2426. 

  2426. 	    ' kB/sec' );
    2427. 

  2427.   outseperator(7);
    2428. 

  2428.   outline( 7, 'DIRECT', $hier_direct, 100 * $hier_direct / $hier,
    2429. 

  2429. 	  kilomegagigatera( $hier_direct_size, $format[3] ),
    2430. 

  2430. 	  $hier_size ? 100 * $hier_direct_size / $hier_size : 0,
    2431. 

  2431. 	  $hier_direct_time / ( 1000 * $hier_direct ),
    2432. 

  2432. 	  $hier_direct_size / ( 1.024 * $hier_direct_time ) )
    2433. 

  2433.     unless $hier_direct == 0;
    2434. 

  2434.   foreach $neighbor ( sort {
    2435. 

  2435.     ${"hier_neighbor$sortorder"}{$b} <=> ${"hier_neighbor$sortorder"}{$a}
    2436. 

  2436.     } keys(%hier_neighbor)
    2437. 

  2437. 		     )
    2438. 

  2438.   {
    2439. 

  2439.     writecache(
    2440. 

  2440. 	       'L', $neighbor, $hier_neighbor{$neighbor},
    2441. 

  2441. 	       $hier_neighbor_size{$neighbor},
    2442. 

  2442. 	       $hier_neighbor_time{$neighbor}
    2443. 

  2443. 	       );
    2444. 

  2444.     outline( 7, $neighbor, $hier_neighbor{$neighbor},
    2445. 

  2445. 	    100 * $hier_neighbor{$neighbor} / $hier,
    2446. 

  2446. 	    kilomegagigatera( $hier_neighbor_size{$neighbor}, $format[3] ),
    2447. 

  2447. 	    $hier_size ? 100 * $hier_neighbor_size{$neighbor} / $hier_size : 0,
    2448. 

  2448. 	    $hier_neighbor_time{$neighbor} / ( 1000 * $hier ),
    2449. 

  2449. 	    $hier_neighbor_size{$neighbor} /
    2450. 

  2450. 	      ( 1.024 * $hier_neighbor_time{$neighbor} ) );
    2451. 

  2451.     foreach $status ( sort {
    2452. 

  2452.       ${"hier_neighbor_status$sortorder"}{$neighbor}{$b} <=>
    2453. 

  2453. 	${"hier_neighbor_status$sortorder"}{$neighbor}{$a}
    2454. 

  2454. 	  } keys(%{$hier_neighbor_status{$neighbor} } )
    2455. 

  2455. 		     )
    2456. 

  2456.     {
    2457. 

  2457.       writecache(
    2458. 

  2458. 		 'M', $neighbor, $status,
    2459. 

  2459. 		 $hier_neighbor_status{$neighbor}{$status},
    2460. 

  2460. 		 $hier_neighbor_status_size{$neighbor}{$status},
    2461. 

  2461. 		 $hier_neighbor_status_time{$neighbor}{$status}
    2462. 

  2462. 		 );
    2463. 

  2463.       outline( 7, ' ' . $status, $hier_neighbor_status{$neighbor}{$status},
    2464. 

  2464. 	      100 * $hier_neighbor_status{$neighbor}{$status} / $hier,
    2465. 

  2465. 	      kilomegagigatera( $hier_neighbor_status_size{$neighbor}{$status},
    2466. 

  2466. 			       $format[3] ),
    2467. 

  2467. 	      $hier_size ? 
    2468. 

  2468. 		100 * $hier_neighbor_status_size{$neighbor}{$status} /
    2469. 

  2469. 		  $hier_size : 0,
    2470. 

  2470. 	      $hier_neighbor_status_time{$neighbor}{$status} /
    2471. 

  2471. 	      ( 1000 * $hier_neighbor_status{$neighbor}{$status} ),
    2472. 

  2472. 	      $hier_neighbor_status_size{$neighbor}{$status} /
    2473. 

  2473. 	      ( 1.024 * $hier_neighbor_status_time{$neighbor}{$status} ) );
    2474. 

  2474.     }
    2475. 

  2475.   }
    2476. 

  2476.   outseperator(7);
    2477. 

  2477.   outline( 7, 'Sum', $hier, 100, kilomegagigatera( $hier_size, $format[3] ),
    2478. 

  2478. 	  100, $hier_time / ( 1000 * $hier ),
    2479. 

  2479. 	  $hier_size / ( 1.024 * $hier_time ) );
    2480. 

  2480. }
    2481. 

  2481. outstop(7);
    2482. 

  2482. 

  2483. if ($opt_d) {
    2484. 

  2484.   @format = ( 39, 9, '%', 8, '%', '%' );
    2485. 

  2485.   outstart(8);
    2486. 

  2486.   if ( $tcp == 0 ) {
    2487. 

  2487.     outline( 8, 'no matching requests' );
    2488. 

  2488.     outstop(8);
    2489. 

  2489.   } else {
    2490. 

  2490.     outheader( 8, 'destination', ' request', '% ',
    2491. 

  2491. 	      $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', 'hit-%'
    2492. 

  2492. 	      );
    2493. 

  2493.     outseperator(8);
    2494. 

  2494.     @counter = keys %tcp_urlhost;
    2495. 

  2495.     $other_urlhost = $#counter + 1;
    2496. 

  2496.     $other = $tcp;
    2497. 

  2497.     $other_size = $tcp_size;
    2498. 

  2498.     $other_hit = $tcp_hit;
    2499. 

  2499.     $other_count = $opt_d;
    2500. 

  2500.     foreach $urlhost ( sort {
    2501. 

  2501.       ${"tcp_urlhost$sortorder"}{$b} <=> ${"tcp_urlhost$sortorder"}{$a}
    2502. 

  2502.       } keys(%tcp_urlhost)
    2503. 

  2503. 		      )
    2504. 

  2504.     {
    2505. 

  2505.       next if $urlhost eq '<other>';
    2506. 

  2506.       $other_urlhost--;
    2507. 

  2507.       $other -= $tcp_urlhost{$urlhost};
    2508. 

  2508.       $other_size -= $tcp_urlhost_size{$urlhost};
    2509. 

  2509.       $other_hit -= $tcp_hit_urlhost{$urlhost};
    2510. 

  2510.       writecache(
    2511. 

  2511. 		 'N', $urlhost, $tcp_urlhost{$urlhost},
    2512. 

  2512. 		 $tcp_urlhost_size{$urlhost}, $tcp_hit_urlhost{$urlhost}
    2513. 

  2513. 		 );
    2514. 

  2514.       outline( 8, $urlhost, $tcp_urlhost{$urlhost},
    2515. 

  2515. 	      100 * $tcp_urlhost{$urlhost} / $tcp,
    2516. 

  2516. 	      kilomegagigatera( $tcp_urlhost_size{$urlhost}, $format[3] ),
    2517. 

  2517. 	      $tcp_size ? 100 * $tcp_urlhost_size{$urlhost} / $tcp_size : 0,
    2518. 

  2518. 	      100 * $tcp_hit_urlhost{$urlhost} / $tcp_urlhost{$urlhost} );
    2519. 

  2519.       last if ( --$other_count == 0 and $other != 1 );
    2520. 

  2520.     }
    2521. 

  2521.     if ($other) {
    2522. 

  2522.       writecache( 'N', '<other>', $other, $other_size, $other_hit );
    2523. 

  2523.       outline( 8, 'other: ' . $other_urlhost . " $N-level-domains", $other,
    2524. 

  2524. 	      100 * $other / $tcp, kilomegagigatera( $other_size, $format[3] ),
    2525. 

  2525. 	      $tcp_size ? 100 * $other_size / $tcp_size : 0,
    2526. 

  2526. 	      100 * $other_hit / $other );
    2527. 

  2527.     }
    2528. 

  2528.     outseperator(8);
    2529. 

  2529.     outline( 8, 'Sum', $tcp, 100, kilomegagigatera( $tcp_size, $format[3] ),
    2530. 

  2530. 	    100, 100 * $tcp_hit / $tcp );
    2531. 

  2531.     outstop(8);
    2532. 

  2532. 

  2533.     outstart(9);
    2534. 

  2534.     outheader( 9, 'destination', ' request', '% ',
    2535. 

  2535. 	      $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', 'hit-%'
    2536. 

  2536. 	      );
    2537. 

  2537.     outseperator(9);
    2538. 

  2538.     @counter = keys %tcp_urltld;
    2539. 

  2539.     $other_tld = $#counter + 1;
    2540. 

  2540.     $other = $tcp;
    2541. 

  2541.     $other_size = $tcp_size;
    2542. 

  2542.     $other_hit = $tcp_hit;
    2543. 

  2543.     $other_count = $opt_d;
    2544. 

  2544.     foreach $urltld (
    2545. 

  2545. 		     sort { ${"tcp_urltld$sortorder"}{$b} <=>
    2546. 

  2546. 			   ${"tcp_urltld$sortorder"}{$a} }
    2547. 

  2547. 		     keys(%tcp_urltld) )
    2548. 

  2548.     {
    2549. 

  2549.       next if $urltld eq '<other>';
    2550. 

  2550.       $other_tld--;
    2551. 

  2551.       $other -= $tcp_urltld{$urltld};
    2552. 

  2552.       $other_size -= $tcp_urltld_size{$urltld};
    2553. 

  2553.       $other_hit -= $tcp_hit_urltld{$urltld};
    2554. 

  2554.       writecache(
    2555. 

  2555. 		 'O', $urltld, $tcp_urltld{$urltld},
    2556. 

  2556. 		 $tcp_urltld_size{$urltld}, $tcp_hit_urltld{$urltld}
    2557. 

  2557. 		 );
    2558. 

  2558.       outline( 9, $urltld, $tcp_urltld{$urltld},
    2559. 

  2559. 	      100 * $tcp_urltld{$urltld} / $tcp,
    2560. 

  2560. 	      kilomegagigatera( $tcp_urltld_size{$urltld}, $format[3] ),
    2561. 

  2561. 	      $tcp_size ? 100 * $tcp_urltld_size{$urltld} / $tcp_size : 0,
    2562. 

  2562. 	      100 * $tcp_hit_urltld{$urltld} / $tcp_urltld{$urltld} );
    2563. 

  2563.       last if ( --$other_count == 0 and $other != 1 );
    2564. 

  2564.     }
    2565. 

  2565.     if ($other) {
    2566. 

  2566.       writecache( 'O', '<other>', $other, $other_size, $other_hit );
    2567. 

  2567.       outline( 9, 'other: ' . $other_tld . ' top-level-domains', $other,
    2568. 

  2568. 	      100 * $other / $tcp, kilomegagigatera( $other_size, $format[3] ),
    2569. 

  2569. 	      $tcp_size ? 100 * $other_size / $tcp_size : 0,
    2570. 

  2570. 	      100 * $other_hit / $other );
    2571. 

  2571.     }
    2572. 

  2572.     outseperator(9);
    2573. 

  2573.     outline( 9, 'Sum', $tcp, 100, kilomegagigatera( $tcp_size, $format[3] ),
    2574. 

  2574. 	    100, 100 * $tcp_hit / $tcp );
    2575. 

  2575.     outstop(9);
    2576. 

  2576.   }
    2577. 

  2577. }
    2578. 

  2578. 

  2579. if ($opt_t) {
    2580. 

  2580.   @format = ( 39, 9, '%', 8, '%', '%' );
    2581. 

  2581.   outstart(10);
    2582. 

  2582.   if ( $tcp == 0 ) {
    2583. 

  2583.     outline( 10, 'no matching requests' );
    2584. 

  2584.   } else {
    2585. 

  2585.     outheader( 10, 'protocol', ' request', '% ',
    2586. 

  2586. 	      $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', 'hit-%'
    2587. 

  2587. 	      );
    2588. 

  2588.     outseperator(10);
    2589. 

  2589.     foreach $urlprot ( sort {
    2590. 

  2590.       ${"tcp_urlprot$sortorder"}{$b} <=> ${"tcp_urlprot$sortorder"}{$a}
    2591. 

  2591. 	} keys(%tcp_urlprot)
    2592. 

  2592. 		      )
    2593. 

  2593.     {
    2594. 

  2594.       writecache(
    2595. 

  2595. 		 'P', $urlprot, $tcp_urlprot{$urlprot},
    2596. 

  2596. 		 $tcp_urlprot_size{$urlprot}, $tcp_hit_urlprot{$urlprot}
    2597. 

  2597. 		 );
    2598. 

  2598.       outline( 10, $urlprot, $tcp_urlprot{$urlprot},
    2599. 

  2599. 	      100 * $tcp_urlprot{$urlprot} / $tcp,
    2600. 

  2600. 	      kilomegagigatera( $tcp_urlprot_size{$urlprot}, $format[3] ),
    2601. 

  2601. 	      $tcp_size ? 100 * $tcp_urlprot_size{$urlprot} / $tcp_size : 0,
    2602. 

  2602. 	      100 * $tcp_hit_urlprot{$urlprot} / $tcp_urlprot{$urlprot} );
    2603. 

  2603.     }
    2604. 

  2604.     outseperator(10);
    2605. 

  2605.     outline( 10, 'Sum', $tcp, 100, kilomegagigatera( $tcp_size, $format[3] ),
    2606. 

  2606. 	    100, 100 * $tcp_hit / $tcp );
    2607. 

  2607.   }
    2608. 

  2608.   outstop(10);
    2609. 

  2609.   if ( defined(%tcp_content) ) {
    2610. 

  2610.     outstart(11);
    2611. 

  2611.     if ( $tcp == 0 ) {
    2612. 

  2612.       outline( 11, 'no matching requests' );
    2613. 

  2613.     } else {
    2614. 

  2614.       outheader( 11, 'content-type', ' request', '% ',
    2615. 

  2615. 		$outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ',
    2616. 

  2616. 		'hit-%' );
    2617. 

  2617.       outseperator(11);
    2618. 

  2618.       @counter = keys %tcp_content;
    2619. 

  2619.       $other_content = $#counter + 1;
    2620. 

  2620.       $other = $tcp;
    2621. 

  2621.       $other_size = $tcp_size;
    2622. 

  2622.       $other_hit = $tcp_hit;
    2623. 

  2623.       $other_count = $opt_t;
    2624. 

  2624.       foreach $content ( sort {
    2625. 

  2625. 	${"tcp_content$sortorder"}{$b} <=> ${"tcp_content$sortorder"}{$a}
    2626. 

  2626. 	  } keys(%tcp_content)
    2627. 

  2627. 			)
    2628. 

  2628.       {
    2629. 

  2629. 	next if $content eq '<other>';
    2630. 

  2630. 	$other_content--;
    2631. 

  2631. 	$other -= $tcp_content{$content};
    2632. 

  2632. 	$other_size -= $tcp_content_size{$content};
    2633. 

  2633. 	$other_hit -= $tcp_hit_content{$content};
    2634. 

  2634. 	writecache(
    2635. 

  2635. 		   'Q', $content, $tcp_content{$content},
    2636. 

  2636. 		   $tcp_content_size{$content}, $tcp_hit_content{$content}
    2637. 

  2637. 		   );
    2638. 

  2638. 	outline( 11, $content, $tcp_content{$content},
    2639. 

  2639. 		100 * $tcp_content{$content} / $tcp,
    2640. 

  2640. 		kilomegagigatera( $tcp_content_size{$content}, $format[3] ),
    2641. 

  2641. 		$tcp_size ? 100 * $tcp_content_size{$content} / $tcp_size : 0,
    2642. 

  2642. 		100 * $tcp_hit_content{$content} / $tcp_content{$content} );
    2643. 

  2643. 	last if ( --$other_count == 0 and $other != 1 );
    2644. 

  2644.       }
    2645. 

  2645.       if ($other) {
    2646. 

  2646. 	writecache( 'Q', '<other>', $other, $other_size, $other_hit );
    2647. 

  2647. 	outline( 11, 'other: '. $other_content . ' content-types', $other,
    2648. 

  2648. 		100 * $other / $tcp,
    2649. 

  2649. 		kilomegagigatera( $other_size, $format[3] ),
    2650. 

  2650. 		$tcp_size ? 100 * $other_size / $tcp_size : 0,
    2651. 

  2651. 		100 * $other_hit / $other );
    2652. 

  2652.       }
    2653. 

  2653.       outseperator(11);
    2654. 

  2654.       outline( 11, 'Sum', $tcp, 100,
    2655. 

  2655. 	      kilomegagigatera( $tcp_size, $format[3] ), 100,
    2656. 

  2656. 	      100 * $tcp_hit / $tcp );
    2657. 

  2657.     }
    2658. 

  2658.     outstop(11);
    2659. 

  2659.   }
    2660. 

  2660.   outstart(12);
    2661. 

  2661.   if ( $tcp == 0 ) {
    2662. 

  2662.     outline( 12, 'no matching requests' );
    2663. 

  2663.   } else {
    2664. 

  2664.     outheader( 12, 'extensions', ' request', '% ',
    2665. 

  2665. 	      $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', '% ', 'hit-%'
    2666. 

  2666. 	      );
    2667. 

  2667.     outseperator(12);
    2668. 

  2668.     @counter = keys %tcp_urlext;
    2669. 

  2669.     $other_urlext = $#counter + 1;
    2670. 

  2670.     $other = $tcp;
    2671. 

  2671.     $other_size = $tcp_size;
    2672. 

  2672.     $other_hit = $tcp_hit;
    2673. 

  2673.     $other_count = $opt_t;
    2674. 

  2674.     foreach $urlext (
    2675. 

  2675. 		     sort {${"tcp_urlext$sortorder"}{$b} <=>
    2676. 

  2676. 			   ${"tcp_urlext$sortorder"}{$a} }
    2677. 

  2677. 		     keys(%tcp_urlext) )
    2678. 

  2678.     {
    2679. 

  2679.       next if $urlext eq '<other>';
    2680. 

  2680.       $other_urlext--;
    2681. 

  2681.       $other -= $tcp_urlext{$urlext};
    2682. 

  2682.       $other_size -= $tcp_urlext_size{$urlext};
    2683. 

  2683.       $other_hit -= $tcp_hit_urlext{$urlext};
    2684. 

  2684.       writecache(
    2685. 

  2685. 		 'R', $urlext, $tcp_urlext{$urlext}, $tcp_urlext_size{$urlext},
    2686. 

  2686. 		 $tcp_hit_urlext{$urlext}
    2687. 

  2687. 		 );
    2688. 

  2688.       outline( 12, $urlext, $tcp_urlext{$urlext},
    2689. 

  2689. 	      100 * $tcp_urlext{$urlext} / $tcp,
    2690. 

  2690. 	      kilomegagigatera( $tcp_urlext_size{$urlext}, $format[3] ),
    2691. 

  2691. 	      $tcp_size ? 100 * $tcp_urlext_size{$urlext} / $tcp_size : 0,
    2692. 

  2692. 	      100 * $tcp_hit_urlext{$urlext} / $tcp_urlext{$urlext} );
    2693. 

  2693.       last if ( --$other_count == 0 and $other != 1 );
    2694. 

  2694.     }
    2695. 

  2695.     if ($other) {
    2696. 

  2696.       writecache( 'R', '<other>', $other, $other_size, $other_hit );
    2697. 

  2697.       outline( 12, 'other: '. $other_urlext . ' extensions', $other,
    2698. 

  2698. 	      100 * $other / $tcp, kilomegagigatera( $other_size, $format[3] ),
    2699. 

  2699. 	      $tcp_size ? 100 * $other_size / $tcp_size : 0,
    2700. 

  2700. 	      100 * $other_hit / $other );
    2701. 

  2701.     }
    2702. 

  2702.     outseperator(12);
    2703. 

  2703.     outline( 12, 'Sum', $tcp, 100, kilomegagigatera( $tcp_size, $format[3] ),
    2704. 

  2704. 	    100, 100 * $tcp_hit / $tcp );
    2705. 

  2705.   }
    2706. 

  2706.   outstop(12);
    2707. 

  2707. }
    2708. 

  2708. 

  2709. if ($opt_r) {
    2710. 

  2710.   @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2711. 

  2711.   outstart(13);
    2712. 

  2712.   if ( $udp == 0 ) {
    2713. 

  2713.     outline( 13, 'no matching requests' );
    2714. 

  2714.   } else {
    2715. 

  2715.     if ($opt_R) {
    2716. 

  2716.       outheader( 13, 'host / target', ' request', 'hit-%',
    2717. 

  2717. 		$outtype_unformatted ? " ${opt_U}Byte" : '  Byte', 'hit-%',
    2718. 

  2718. 		'msec', ' kB/sec' );
    2719. 

  2719.     } else {
    2720. 

  2720.       outheader( 13, 'host', ' request', 'hit-%',
    2721. 

  2721. 		$outtype_unformatted ? " ${opt_U}Byte" : '  Byte', 'hit-%',
    2722. 

  2722. 		'msec', ' kB/sec' );
    2723. 

  2723.     }
    2724. 

  2724.     outseperator(13);
    2725. 

  2725.     @counter = keys %udp_requester;
    2726. 

  2726.     $other_requester = $#counter + 1;
    2727. 

  2727.     $other = $udp;
    2728. 

  2728.     $other_size = $udp_size;
    2729. 

  2729.     $other_time = $udp_time;
    2730. 

  2730.     $other_hit = $udp_hit;
    2731. 

  2731.     $other_hit_size = $udp_hit_size;
    2732. 

  2732.     $other_count = $opt_r;
    2733. 

  2733.     foreach $requester ( sort {
    2734. 

  2734.       ${"udp_requester$sortorder"}{$b} <=> ${"udp_requester$sortorder"}{$a}
    2735. 

  2735. 	} keys(%udp_requester)
    2736. 

  2736. 			)
    2737. 

  2737.     {
    2738. 

  2738.       next if $requester eq '<other>';
    2739. 

  2739.       $other_requester--;
    2740. 

  2740.       $other -= $udp_requester{$requester};
    2741. 

  2741.       $other_size -= $udp_requester_size{$requester};
    2742. 

  2742.       $other_time -= $udp_requester_time{$requester};
    2743. 

  2743.       $other_hit -= $udp_hit_requester{$requester};
    2744. 

  2744.       $other_hit_size -= $udp_hit_requester_size{$requester};
    2745. 

  2745.       writecache(
    2746. 

  2746. 		 'S', $requester, $udp_requester{$requester},
    2747. 

  2747. 		 $udp_requester_size{$requester},
    2748. 

  2748. 		 $udp_requester_time{$requester},
    2749. 

  2749. 		 $udp_hit_requester{$requester},
    2750. 

  2750. 		 $udp_hit_requester_size{$requester}
    2751. 

  2751. 		 );
    2752. 

  2752.       outline( 13, $requester, $udp_requester{$requester},
    2753. 

  2753. 	      100 * $udp_hit_requester{$requester} /
    2754. 

  2754. 		$udp_requester{$requester},
    2755. 

  2755. 	      kilomegagigatera( $udp_requester_size{$requester}, $format[3] ),
    2756. 

  2756. 	      $udp_requester_size{$requester}
    2757. 

  2757. 		? 100 * $udp_hit_requester_size{$requester} /
    2758. 

  2758. 		  $udp_requester_size{$requester} : 0,
    2759. 

  2759. 	      $udp_requester_time{$requester} / $udp_requester{$requester},
    2760. 

  2760. 	      $udp_requester_size{$requester} /
    2761. 

  2761. 		( 1.024 * $udp_requester_time{$requester} ) );
    2762. 

  2762.       if ($opt_R) {
    2763. 

  2763. 	@counter2 = keys( %{ $udp_requester_urlhost{$requester} } );
    2764. 

  2764. 	$other2_requester_urlhost = $#counter2 + 1;
    2765. 

  2765. 	$other2 = $udp_requester{$requester};
    2766. 

  2766. 	$other2_size = $udp_requester_size{$requester};
    2767. 

  2767. 	$other2_time = $udp_requester_time{$requester};
    2768. 

  2768. 	$other2_hit = $udp_hit_requester{$requester};
    2769. 

  2769. 	$other2_hit_size = $udp_hit_requester_size{$requester};
    2770. 

  2770. 	$other2_count = $opt_R;
    2771. 

  2771. 	foreach $urlhost ( sort {
    2772. 

  2772. 	  ${"udp_requester_urlhost$sortorder"}{$requester}{$b} <=>
    2773. 

  2773. 		 ${"udp_requester_urlhost$sortorder"}{$requester}{$a}
    2774. 

  2774. 	    } keys( %{ $udp_requester_urlhost{$requester} } )
    2775. 

  2775. 			  )
    2776. 

  2776. 	{
    2777. 

  2777. 	  next if $urlhost eq '<other>';
    2778. 

  2778. 	  $other2_requester_urlhost--;
    2779. 

  2779. 	  $other2 -= $udp_requester_urlhost{$requester}{$urlhost};
    2780. 

  2780. 	  $other2_size -= $udp_requester_urlhost_size{$requester}{$urlhost};
    2781. 

  2781. 	  $other2_time -= $udp_requester_urlhost_time{$requester}{$urlhost};
    2782. 

  2782. 	  $other2_hit -= $udp_hit_requester_urlhost{$requester}{$urlhost};
    2783. 

  2783. 	  $other2_hit_size -=
    2784. 

  2784. 	    $udp_hit_requester_urlhost_size{$requester}{$urlhost};
    2785. 

  2785. 	  writecache(
    2786. 

  2786. 		     'V', $requester, $urlhost,
    2787. 

  2787. 		     $udp_requester_urlhost{$requester}{$urlhost},
    2788. 

  2788. 		     $udp_requester_urlhost_size{$requester}{$urlhost},
    2789. 

  2789. 		     $udp_requester_urlhost_time{$requester}{$urlhost},
    2790. 

  2790. 		     $udp_hit_requester_urlhost{$requester}{$urlhost},
    2791. 

  2791. 		     $udp_hit_requester_urlhost_size{$requester}{$urlhost}
    2792. 

  2792. 		     );
    2793. 

  2793. 	  outline( 13, ' ' .  $urlhost,
    2794. 

  2794. 		  $udp_requester_urlhost{$requester}{$urlhost},
    2795. 

  2795. 		  100 * $udp_hit_requester_urlhost{$requester}{$urlhost} /
    2796. 

  2796. 		    $udp_requester_urlhost{$requester}{$urlhost},
    2797. 

  2797. 		  kilomegagigatera(
    2798. 

  2798. 				   $udp_requester_urlhost_size{$requester}{$urlhost},
    2799. 

  2799. 				   $format[3] ),
    2800. 

  2800. 		  $udp_requester_urlhost_size{$requester}{$urlhost} ? 100 *
    2801. 

  2801. 		    $udp_hit_requester_urlhost_size{$requester}{$urlhost} /
    2802. 

  2802. 		    $udp_requester_urlhost_size{$requester}{$urlhost} : 0,
    2803. 

  2803. 		  $udp_requester_urlhost_time{$requester}{$urlhost} /
    2804. 

  2804. 		    $udp_requester_urlhost{$requester}{$urlhost},
    2805. 

  2805. 		  $udp_requester_urlhost_size{$requester}{$urlhost} /
    2806. 

  2806. 		    ( 1.024 *
    2807. 

  2807. 		     $udp_requester_urlhost_time{$requester}{$urlhost} ) );
    2808. 

  2808. 	  last if ( --$other2_count == 0 and $other2 != 1 );
    2809. 

  2809. 	}
    2810. 

  2810. 	if ($other2) {
    2811. 

  2811. 	  writecache(
    2812. 

  2812. 		     'V', $requester, '<other>', $other2, $other2_size,
    2813. 

  2813. 		     $other2_time, $other2_hit, $other2_hit_size
    2814. 

  2814. 		     );
    2815. 

  2815. 	  outline( 13, ' other: ' . $other2_requester_urlhost .
    2816. 

  2816. 		    ' requested urlhosts', $other2,
    2817. 

  2817. 		  100 * $other2_hit / $other2,
    2818. 

  2818. 		  kilomegagigatera( $other2_size, $format[3] ),
    2819. 

  2819. 		  $other2_size ? 100 * $other2_hit_size / $other2_size : 0,
    2820. 

  2820. 		  $other2_time / ( 1000 * $other2_requester_urlhost ),
    2821. 

  2821. 		  $other2_size / ( 1.024 * $other2_time )
    2822. 

  2822. 		  );
    2823. 

  2823. 	}
    2824. 

  2824.       }
    2825. 

  2825.       last if ( --$other_count == 0 and $other != 1 );
    2826. 

  2826.     }
    2827. 

  2827.     if ($other) {
    2828. 

  2828.       writecache(
    2829. 

  2829. 		 'S', '<other>', $other, $other_size, $other_time, $other_hit,
    2830. 

  2830. 		 $other_hit_size
    2831. 

  2831. 		 );
    2832. 

  2832.       outline( 13, 'other: ' . $other_requester . ' requesting hosts', $other,
    2833. 

  2833. 	      100 * $other_hit / $other,
    2834. 

  2834. 	      kilomegagigatera( $other_size, $format[3] ),
    2835. 

  2835. 	      100 * $other_hit_size / $other_size,
    2836. 

  2836. 	      $other_time / ( 1000 * $udp ),
    2837. 

  2837. 	      $other_size / ( 1.024 * $udp_time )
    2838. 

  2838. 	      );
    2839. 

  2839.     }
    2840. 

  2840.     outseperator(13);
    2841. 

  2841.     outline( 13, 'Sum', $udp, 100 * $udp_hit / $udp,
    2842. 

  2842. 	    kilomegagigatera( $udp_size, $format[3] ),
    2843. 

  2843. 	    $udp_size ? 100 * $udp_hit_size / $udp_size : 0, $udp_time / $udp,
    2844. 

  2844. 	    $udp_size / ( 1.024 * $udp_time ) );
    2845. 

  2845.   }
    2846. 

  2846.   outstop(13);
    2847. 

  2847. 

  2848.   outstart(14);
    2849. 

  2849.   if ( $tcp == 0 ) {
    2850. 

  2850.     outline( 14, 'no matching requests' );
    2851. 

  2851.   } else {
    2852. 

  2852.     if ($opt_R) {
    2853. 

  2853.       outheader( 14, 'host / target', ' request', 'hit-%',
    2854. 

  2854. 		$outtype_unformatted ? " ${opt_U}Byte" : '  Byte', 'hit-%',
    2855. 

  2855. 		'sec', ' kB/sec' );
    2856. 

  2856.     } else {
    2857. 

  2857.       outheader( 14, 'host', ' request', 'hit-%',
    2858. 

  2858. 		$outtype_unformatted ? " ${opt_U}Byte" : '  Byte', 'hit-%',
    2859. 

  2859. 		'sec', ' kB/sec' );
    2860. 

  2860.     }
    2861. 

  2861.     outseperator(14);
    2862. 

  2862.     @counter = keys %tcp_requester;
    2863. 

  2863.     $other_requester = $#counter + 1;
    2864. 

  2864.     $other = $tcp;
    2865. 

  2865.     $other_size = $tcp_size;
    2866. 

  2866.     $other_time = $tcp_time;
    2867. 

  2867.     $other_hit = $tcp_hit;
    2868. 

  2868.     $other_hit_size = $tcp_hit_size;
    2869. 

  2869.     $other_count = $opt_r;
    2870. 

  2870.     foreach $requester ( sort {
    2871. 

  2871.       ${"tcp_requester$sortorder"}{$b} <=> ${"tcp_requester$sortorder"}{$a}
    2872. 

  2872.       } keys(%tcp_requester)
    2873. 

  2873. 			)
    2874. 

  2874.     {
    2875. 

  2875.       next if $requester eq '<other>';
    2876. 

  2876.       $other_requester--;
    2877. 

  2877.       $other -= $tcp_requester{$requester};
    2878. 

  2878.       $other_size -= $tcp_requester_size{$requester};
    2879. 

  2879.       $other_time -= $tcp_requester_time{$requester};
    2880. 

  2880.       $other_hit -= $tcp_hit_requester{$requester};
    2881. 

  2881.       $other_hit_size -= $tcp_hit_requester_size{$requester};
    2882. 

  2882.       writecache(
    2883. 

  2883. 		 'T', $requester, $tcp_requester{$requester},
    2884. 

  2884. 		 $tcp_requester_size{$requester},
    2885. 

  2885. 		 $tcp_requester_time{$requester},
    2886. 

  2886. 		 $tcp_hit_requester{$requester},
    2887. 

  2887. 		 $tcp_hit_requester_size{$requester}
    2888. 

  2888. 		 );
    2889. 

  2889.       outline( 14, $requester, $tcp_requester{$requester},
    2890. 

  2890. 	      100 * $tcp_hit_requester{$requester} /
    2891. 

  2891. 		$tcp_requester{$requester},
    2892. 

  2892. 	      kilomegagigatera( $tcp_requester_size{$requester}, $format[3] ),
    2893. 

  2893. 	      $tcp_requester_size{$requester} ?
    2894. 

  2894. 		100 * $tcp_hit_requester_size{$requester} /
    2895. 

  2895. 		  $tcp_requester_size{$requester} : 0,
    2896. 

  2896. 	      $tcp_requester_time{$requester} /
    2897. 

  2897. 		( 1000 * $tcp_requester{$requester} ),
    2898. 

  2898. 	      $tcp_requester_size{$requester} /
    2899. 

  2899. 		( 1.024 * $tcp_requester_time{$requester} ) );
    2900. 

  2900.       if ($opt_R) {
    2901. 

  2901. 	@counter2 = keys( %{ $tcp_requester_urlhost{$requester} } );
    2902. 

  2902. 	$other2_requester_urlhost = $#counter2 + 1;
    2903. 

  2903. 	$other2 = $tcp_requester{$requester};
    2904. 

  2904. 	$other2_size = $tcp_requester_size{$requester};
    2905. 

  2905. 	$other2_time = $tcp_requester_time{$requester};
    2906. 

  2906. 	$other2_hit = $tcp_hit_requester{$requester};
    2907. 

  2907. 	$other2_hit_size = $tcp_hit_requester_size{$requester};
    2908. 

  2908. 	$other2_count = $opt_R;
    2909. 

  2909. 	foreach $urlhost ( sort {
    2910. 

  2910. 	  ${"tcp_requester_urlhost$sortorder"}{$requester}{$b} <=>
    2911. 

  2911. 		 ${"tcp_requester_urlhost$sortorder"}{$requester}{$a}
    2912. 

  2912. 	  } keys( %{ $tcp_requester_urlhost{$requester} } )
    2913. 

  2913. 			  )
    2914. 

  2914. 	{
    2915. 

  2915. 	  next if $urlhost eq '<other>';
    2916. 

  2916. 	  $other2_requester_urlhost--;
    2917. 

  2917. 	  $other2 -= $tcp_requester_urlhost{$requester}{$urlhost};
    2918. 

  2918. 	  $other2_size -= $tcp_requester_urlhost_size{$requester}{$urlhost};
    2919. 

  2919. 	  $other2_time -= $tcp_requester_urlhost_time{$requester}{$urlhost};
    2920. 

  2920. 	  $other2_hit -= $tcp_hit_requester_urlhost{$requester}{$urlhost};
    2921. 

  2921. 	  $other2_hit_size -=
    2922. 

  2922. 	    $tcp_hit_requester_urlhost_size{$requester}{$urlhost};
    2923. 

  2923. 	  writecache(
    2924. 

  2924. 		     'W', $requester, $urlhost,
    2925. 

  2925. 		     $tcp_requester_urlhost{$requester}{$urlhost},
    2926. 

  2926. 		     $tcp_requester_urlhost_size{$requester}{$urlhost},
    2927. 

  2927. 		     $tcp_requester_urlhost_time{$requester}{$urlhost},
    2928. 

  2928. 		     $tcp_hit_requester_urlhost{$requester}{$urlhost},
    2929. 

  2929. 		     $tcp_hit_requester_urlhost_size{$requester}{$urlhost}
    2930. 

  2930. 		     );
    2931. 

  2931. 	  outline( 14, ' ' .  $urlhost,
    2932. 

  2932. 		  $tcp_requester_urlhost{$requester}{$urlhost},
    2933. 

  2933. 		  100 * $tcp_hit_requester_urlhost{$requester}{$urlhost} /
    2934. 

  2934. 		    $tcp_requester_urlhost{$requester}{$urlhost},
    2935. 

  2935. 		  kilomegagigatera(
    2936. 

  2936. 				   $tcp_requester_urlhost_size{$requester}{$urlhost},
    2937. 

  2937. 				   $format[3] ),
    2938. 

  2938. 		  $tcp_requester_urlhost_size{$requester}{$urlhost} ?
    2939. 

  2939. 		    100 *
    2940. 

  2940. 		      $tcp_hit_requester_urlhost_size{$requester}{$urlhost} /
    2941. 

  2941. 		      $tcp_requester_urlhost_size{$requester}{$urlhost} : 0,
    2942. 

  2942. 		  $tcp_requester_urlhost_time{$requester}{$urlhost} /
    2943. 

  2943. 		    ( 1000 * $tcp_requester_urlhost{$requester}{$urlhost} ),
    2944. 

  2944. 		  $tcp_requester_urlhost_size{$requester}{$urlhost} /
    2945. 

  2945. 		    ( 1.024 *
    2946. 

  2946. 		     $tcp_requester_urlhost_time{$requester}{$urlhost} ) );
    2947. 

  2947. 	  last if ( --$other2_count == 0 and $other2 != 1 );
    2948. 

  2948. 	}
    2949. 

  2949. 	if ($other2) {
    2950. 

  2950. 	  writecache(
    2951. 

  2951. 		     'W', $requester, '<other>', $other2, $other2_size,
    2952. 

  2952. 		     $other2_time, $other2_hit, $other2_hit_size
    2953. 

  2953. 		     );
    2954. 

  2954. 	  outline( 14, ' other: ' . $other2_requester_urlhost .
    2955. 

  2955. 		    ' requested urlhosts', $other2,
    2956. 

  2956. 		  100 * $other2_hit / $other2,
    2957. 

  2957. 		  kilomegagigatera( $other2_size, $format[3] ),
    2958. 

  2958. 		  $other2_size ? 100 * $other2_hit_size / $other2_size : 0,
    2959. 

  2959. 		  $other2_time / ( 1000 * $other2_requester_urlhost ),
    2960. 

  2960. 		  $other2_size / ( 1.024 * $other2_time )
    2961. 

  2961. 		  );
    2962. 

  2962. 	}
    2963. 

  2963.       }
    2964. 

  2964.       last if ( --$other_count == 0 and $other != 1 );
    2965. 

  2965.     }
    2966. 

  2966.     if ($other) {
    2967. 

  2967.       writecache(
    2968. 

  2968. 		 'T', '<other>', $other, $other_size, $other_time, $other_hit,
    2969. 

  2969. 		 $other_hit_size
    2970. 

  2970. 		 );
    2971. 

  2971.       outline( 14, 'other: ' . $other_requester . ' requesting hosts', $other,
    2972. 

  2972. 	      100 * $other_hit / $other,
    2973. 

  2973. 	      kilomegagigatera( $other_size, $format[3] ),
    2974. 

  2974. 	      $other_size ? 100 * $other_hit_size / $other_size : 0,
    2975. 

  2975. 	      $other_time / ( 1000 * $tcp ),
    2976. 

  2976. 	      $other_size / ( 1.024 * $tcp_time ) );
    2977. 

  2977.     }
    2978. 

  2978.     outseperator(14);
    2979. 

  2979.     outline( 14, 'Sum', $tcp, 100 * $tcp_hit / $tcp,
    2980. 

  2980. 	    kilomegagigatera( $tcp_size, $format[3] ),
    2981. 

  2981. 	    $tcp_size ? 100 * $tcp_hit_size / $tcp_size : 0,
    2982. 

  2982. 	    $tcp_time / ( 1000 * $tcp ),
    2983. 

  2983. 	    $tcp_size / ( 1.024 * $tcp_time ) );
    2984. 

  2984.   }
    2985. 

  2985.   outstop(14);
    2986. 

  2986. }
    2987. 

  2987. 

  2988. if ($opt_D) {
    2989. 

  2989.   @format = ( 33, 9, '%', 8, '%', 4, 'kbs' );
    2990. 

  2990.   outstart(15);
    2991. 

  2991.   if ( $tcp == 0 ) {
    2992. 

  2992.     outline( 15, 'no matching requests' );
    2993. 

  2993.   } else {
    2994. 

  2994.     outheader( 15, 'object-size (bytes)', ' request', 'hit-%',
    2995. 

  2995. 	      $outtype_unformatted ? " ${opt_U}Byte" : '  Byte', 'hit-%',
    2996. 

  2996. 	      'sec', ' kB/sec' );
    2997. 

  2997.     outseperator(15);
    2998. 

  2998.     foreach $distribution ( sort { $a <=> $b } keys(%tcp_distribution) ) {
    2999. 

  2999.       writecache(
    3000. 

  3000. 		 'X', $distribution, $tcp_distribution{$distribution},
    3001. 

  3001. 		 $tcp_distribution_size{$distribution},
    3002. 

  3002. 		 $tcp_distribution_time{$distribution},
    3003. 

  3003. 		 $tcp_hit_distribution{$distribution},
    3004. 

  3004. 		 $tcp_hit_distribution_size{$distribution}
    3005. 

  3005. 		 );
    3006. 

  3006.       outline( 15, int( $opt_D**$distribution ) . '-' .
    3007. 

  3007. 		int( $opt_D**( $distribution + 1 ) - 1 ),
    3008. 

  3008. 	      $tcp_distribution{$distribution},
    3009. 

  3009. 	      100 * $tcp_hit_distribution{$distribution} /
    3010. 

  3010. 		$tcp_distribution{$distribution},
    3011. 

  3011. 	      kilomegagigatera( $tcp_distribution_size{$distribution},
    3012. 

  3012. 			       $format[3] ),
    3013. 

  3013. 	      $tcp_distribution_size{$distribution} ?
    3014. 

  3014. 		100 * $tcp_hit_distribution_size{$distribution} /
    3015. 

  3015. 		  $tcp_distribution_size{$distribution} : 0,
    3016. 

  3016. 	      $tcp_distribution_time{$distribution} /
    3017. 

  3017. 		( 1000 * $tcp_distribution{$distribution} ),
    3018. 

  3018. 	      $tcp_distribution_size{$distribution} /
    3019. 

  3019. 		( 1.024 * $tcp_distribution_time{$distribution} ) );
    3020. 

  3020.     }
    3021. 

  3021.     outseperator(15);
    3022. 

  3022.     outline( 15, 'Sum', $tcp, 100 * $tcp_hit / $tcp,
    3023. 

  3023. 	    kilomegagigatera( $tcp_size, $format[3] ),
    3024. 

  3024. 	    $tcp_size ? 100 * $tcp_hit_size / $tcp_size : 0,
    3025. 

  3025. 	    $tcp_time / ( 1000 * $tcp ),
    3026. 

  3026. 	    $tcp_size / ( 1.024 * $tcp_time ) );
    3027. 

  3027.   }
    3028. 

  3028.   outstop(15);
    3029. 

  3029. }
    3030. 

  3030. 

  3031. if ($opt_P) {
    3032. 

  3032.   @format = ( 15, 9, 5, 'kbs', 'kbs', 'kbs', 'kbs', 'kbs', 'kbs' );
    3033. 

  3033.   outstart(16);
    3034. 

  3034.   if ( $tcp == 0 ) {
    3035. 

  3035.     outline( 16, 'no matching requests' );
    3036. 

  3036.   } else {
    3037. 

  3037.     outheader(
    3038. 

  3038. 	      16, '', '', '', 'incomin', '   hit', '  miss', ' direct',
    3039. 

  3039. 	      'sibling', ' fetch'
    3040. 

  3040. 	      );
    3041. 

  3041.     outheader(
    3042. 

  3042. 	      16, 'date', ' request', ' Byte', ' kB/sec', ' kB/sec', ' kB/sec',
    3043. 

  3043. 	      ' kB/sec', ' kB/sec', ' kB/sec'
    3044. 

  3044. 	      );
    3045. 

  3045.     outseperator(16);
    3046. 

  3046.     foreach $perf_date ( sort { $a <=> $b } keys(%perf_counter) ) {
    3047. 

  3047.       writecache(
    3048. 

  3048. 		 'U', $perf_date, $perf_counter{$perf_date},
    3049. 

  3049. 		 $perf_size{$perf_date}, $perf_time{$perf_date},
    3050. 

  3050. 		 $perf_tcp_hit_size{$perf_date},
    3051. 

  3051. 		 $perf_tcp_hit_time{$perf_date},
    3052. 

  3052. 		 $perf_tcp_miss_size{$perf_date},
    3053. 

  3053. 		 $perf_tcp_miss_time{$perf_date},
    3054. 

  3054. 		 $perf_hier_direct_size{$perf_date},
    3055. 

  3055. 		 $perf_hier_direct_time{$perf_date},
    3056. 

  3056. 		 $perf_hier_sibling_size{$perf_date},
    3057. 

  3057. 		 $perf_hier_sibling_time{$perf_date},
    3058. 

  3058. 		 $perf_hier_parent_size{$perf_date},
    3059. 

  3059. 		 $perf_hier_parent_time{$perf_date}
    3060. 

  3060. 		 );
    3061. 

  3061.       outline( 16, substr( convertdate($perf_date), 0, 15 ),
    3062. 

  3062. 	      $perf_counter{$perf_date},
    3063. 

  3063. 	      kilomegagigatera( $perf_size{$perf_date}, $format[2] ),
    3064. 

  3064. 	      removezerotimes( $perf_size{$perf_date}, $perf_time{$perf_date}
    3065. 

  3065. 			      ),
    3066. 

  3066. 	      removezerotimes( $perf_tcp_hit_size{$perf_date},
    3067. 

  3067. 			      $perf_tcp_hit_time{$perf_date} ),
    3068. 

  3068. 	      removezerotimes( $perf_tcp_miss_size{$perf_date},
    3069. 

  3069. 			      $perf_tcp_miss_time{$perf_date} ),
    3070. 

  3070. 	      removezerotimes( $perf_hier_direct_size{$perf_date},
    3071. 

  3071. 			      $perf_hier_direct_time{$perf_date} ),
    3072. 

  3072. 	      removezerotimes( $perf_hier_sibling_size{$perf_date},
    3073. 

  3073. 			      $perf_hier_sibling_time{$perf_date} ),
    3074. 

  3074. 	      removezerotimes( $perf_hier_parent_size{$perf_date},
    3075. 

  3075. 			      $perf_hier_parent_time{$perf_date} )
    3076. 

  3076. 	      );
    3077. 

  3077.     }
    3078. 

  3078.     outseperator(16);
    3079. 

  3079.     outline( 16, 'overall', $tcp, kilomegagigatera( $tcp_size, $format[2] ),
    3080. 

  3080. 	    removezerotimes( $tcp_size, $tcp_time ),
    3081. 

  3081. 	    removezerotimes( $tcp_hit_size, $tcp_hit_time ),
    3082. 

  3082. 	    removezerotimes( $tcp_miss_size, $tcp_miss_time ),
    3083. 

  3083. 	    removezerotimes( $hier_direct_size, $hier_direct_time ),
    3084. 

  3084. 	    removezerotimes( $hier_sibling_size, $hier_sibling_time ),
    3085. 

  3085. 	    removezerotimes( $hier_parent_size, $hier_parent_time )
    3086. 

  3086. 	    );
    3087. 

  3087.   }
    3088. 

  3088.   outstop(16);
    3089. 

  3089. }
    3090. 

  3090. 

  3091. close(CACHE);
    3092. 

  3092. 

  3093. # now print it out.
    3094. 

  3094. print $out_head;
    3095. 

  3095. if ($opt_S) {
    3096. 

  3096.   print $out_body{'E'} if defined $out_body{'E'};
    3097. 

  3097.   foreach $index ( split ( ",", $opt_S ) ) {
    3098. 

  3098.     if ( not defined( $out_body{$index} ) ) {
    3099. 

  3099.       outstart($index);
    3100. 

  3100.       outline( $index, 'no matching requests' );
    3101. 

  3101.       outstop($index);
    3102. 

  3102.     }
    3103. 

  3103.     print $out_body{$index};
    3104. 

  3104.   }
    3105. 

  3105. } else {
    3106. 

  3106.   foreach ( 'E', 0 .. $#reports ) {
    3107. 

  3107.     print $out_body{$_} if defined( $out_body{$_} );
    3108. 

  3108.   }
    3109. 

  3109. }
    3110. 

  3110. 

  3111. if ( $outtype_html or $outtype_htmlembed ) {
    3112. 

  3112.   print '  <hr>
    3113. 

  3113.   <address><a href="http://Calamaris.Cord.de/">Calamaris</a>
    3114. 

  3114.    $Revision: 2.59 $, Copyright &copy; 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
    3115. 

  3115.    <a href="http://Cord.de/">Cord Beermann</a>.
    3116. 

  3116.   </address>
    3117. 

  3117.   <p>Calamaris comes with ABSOLUTELY NO WARRANTY. It is free software, and you
    3118. 

  3118.    are welcome to redistribute it under certain conditions.  See source for
    3119. 

  3119.    details.
    3120. 

  3120.   </p>
    3121. 

  3121. ';
    3122. 

  3122.   if ($outtype_html) {
    3123. 

  3123.     print ' </body>
    3124. 

  3124. </html>', "\n";
    3125. 

  3125.   }
    3126. 

  3126. } else {
    3127. 

  3127.   print "\n\n";
    3128. 

  3128.   print "-- \n" if ($outtype_mail);
    3129. 

  3129.   print "$VERSION\n$COPYRIGHT\n";
    3130. 

  3130. }
    3131. 

  3131. 

  3132. sub kilomegagigatera {
    3133. 

  3133.   my ($value) = shift (@_);
    3134. 

  3134.   my ($length) = $outtype_unformatted ? 999 : shift (@_);
    3135. 

  3135.   if ( $value > 10**( $length + 8 ) or $opt_U eq 'T' ) {
    3136. 

  3136.     return
    3137. 

  3137.       sprintf( "%d%s", int( ( $value / 1024**4 ) + .5 ),
    3138. 

  3138. 	      $outtype_unformatted ? '' : 'T' );
    3139. 

  3139.   } elsif ( $value > 10**( $length + 5 ) or $opt_U eq 'G' ) {
    3140. 

  3140.     return
    3141. 

  3141.       sprintf( "%d%s", int( ( $value / 1024**3 ) + .5 ),
    3142. 

  3142. 	      $outtype_unformatted ? '' : 'G' );
    3143. 

  3143.   } elsif ( $value > 10**( $length + 2 ) or $opt_U eq 'M' ) {
    3144. 

  3144.     return
    3145. 

  3145.       sprintf( "%d%s", int( ( $value / 1024**2 ) + .5 ),
    3146. 

  3146. 	      $outtype_unformatted ? '' : 'M' );
    3147. 

  3147.   } elsif ( $value > 10**($length) or $opt_U eq 'K' ) {
    3148. 

  3148.     return
    3149. 

  3149.       sprintf( "%d%s", int( ( $value / 1024 ) + .5 ),
    3150. 

  3150. 	      $outtype_unformatted ? '' : 'K' );
    3151. 

  3151.   } else {
    3152. 

  3152.     return $value;
    3153. 

  3153.   }
    3154. 

  3154. }
    3155. 

  3155. 

  3156. sub removezerotimes {
    3157. 

  3157.   my ($size) = shift (@_);
    3158. 

  3158.   my ($time) = shift (@_);
    3159. 

  3159.   if ( $size == 0 ) {
    3160. 

  3160.     return '-';
    3161. 

  3161.   } else {
    3162. 

  3162.     return $size / ( 1.024 * $time );
    3163. 

  3163.   }
    3164. 

  3164. }
    3165. 

  3165. 

  3166. sub getfqdn {
    3167. 

  3167.   my ($host) = @_;
    3168. 

  3168.   if ( $host =~
    3169. 

  3169.       m#^([^@]+@)?(::ffff:)?(([0-9][0-9]{0,2}\.){3}[0-9][0-9]{0,2}$)#o ) {
    3170. 

  3170.     $hostcache{$3} = addtonam($3) unless defined $hostcache{$3};
    3171. 

  3171.     return $1 . $hostcache{$3} if defined $1;
    3172. 

  3172.     return $hostcache{$3};
    3173. 

  3173.   } else {
    3174. 

  3174.     return $host;
    3175. 

  3175.   }
    3176. 

  3176. }
    3177. 

  3177. 

  3178. sub addtonam {
    3179. 

  3179.   my ($address) = shift (@_);
    3180. 

  3180.   my (@octets);
    3181. 

  3181.   my ( $host_name, $aliases, $type, $len, $addr );
    3182. 

  3182.   my ($ip_number);
    3183. 

  3183.   @octets = split '\.', $address;
    3184. 

  3184.   if ( $#octets != 3 ) {
    3185. 

  3185.     undef;
    3186. 

  3186.   }
    3187. 

  3187.   $ip = pack( "CCCC", @octets[ 0 .. 3 ] );
    3188. 

  3188.   ( $host_name, $aliases, $type, $len, $addr ) = gethostbyaddr( $ip, 2 );
    3189. 

  3189.   if ($host_name) {
    3190. 

  3190.     $host_name;
    3191. 

  3191.   } else {
    3192. 

  3192.     $address;
    3193. 

  3193.   }
    3194. 

  3194. }
    3195. 

  3195. 

  3196. sub convertdate {
    3197. 

  3197.   my $date = shift (@_);
    3198. 

  3198.   if ($date) {
    3199. 

  3199.     my ( $sec, $min, $hour, $mday, $mon, $year ) =
    3200. 

  3200.       ( localtime($date) )[ 0, 1, 2, 3, 4, 5, 6 ];
    3201. 

  3201.     my $month = $months[$mon];
    3202. 

  3202.     $year += 1900;
    3203. 

  3203.     my $retdate =
    3204. 

  3204.       sprintf( "%02d.%s %02d %02d:%02d:%02d\n", $mday, $month,
    3205. 

  3205. 	      substr( $year, -2 ), $hour, $min, $sec );
    3206. 

  3206.     chomp($retdate);
    3207. 

  3207.     return $retdate;
    3208. 

  3208.   } else {
    3209. 

  3209.     return '                  ';
    3210. 

  3210.   }
    3211. 

  3211. }
    3212. 

  3212. 

  3213. sub outref {
    3214. 

  3214.   my $name = shift (@_);
    3215. 

  3215.   $out_head .= "   <li><a href=\"#$name\">$reports[$name]</a>\n";
    3216. 

  3216. }
    3217. 

  3217. 

  3218. sub outstart {
    3219. 

  3219.   my $index = shift (@_);
    3220. 

  3220.   if ( $outtype_html or $outtype_htmlembed ) {
    3221. 

  3221.     if ( $index eq 'E' ) {
    3222. 

  3222.       $out_body{$index} .= "  <hr>
    3223. 

  3223.   <table border=\"0\">\n";
    3224. 

  3224.     } else {
    3225. 

  3225.       $out_body{$index} .= "  <hr>
    3226. 

  3226.   <h2><a name=\"$index\">$reports[$index]</a></h2>
    3227. 

  3227.   <table border=\"1\">\n";
    3228. 

  3228.     }
    3229. 

  3229.   } else {
    3230. 

  3230.     $out_body{$index} .= "\n# $reports[$index]\n" unless ( $index eq 'E' );
    3231. 

  3231.   }
    3232. 

  3232. }
    3233. 

  3233. 

  3234. sub outheader {
    3235. 

  3235.   my $index = shift (@_);
    3236. 

  3236.   my $print;
    3237. 

  3237.   my $no = 0;
    3238. 

  3238.   $out_body{$index} .= "   <tr>\n" if ( $outtype_html or $outtype_htmlembed );
    3239. 

  3239.   foreach (@_) {
    3240. 

  3240.     $p = $_;
    3241. 

  3241.     if ($outtype_unformatted) {
    3242. 

  3242.       $out_body{$index} .= "$p ";
    3243. 

  3243.     } elsif ( $outtype_html or $outtype_htmlembed ) {
    3244. 

  3244.       $p =~ s# +# #go;
    3245. 

  3245.       $p =~ s#(^ | $)##go;
    3246. 

  3246.       $p = '&nbsp;' if ( $p eq '' );
    3247. 

  3247.       $out_body{$index} .= "    <th>$p</th>\n";
    3248. 

  3248.     } elsif ( $format[$no] eq '%' ) {
    3249. 

  3249.       $out_body{$index} .=
    3250. 

  3250. 	sprintf( ' ' x ( 6 - length($p) ) ) . substr( $p, 0, 6 ) . ' ';
    3251. 

  3251.     } elsif ( $format[$no] eq 'kbs' ) {
    3252. 

  3252.       $out_body{$index} .=
    3253. 

  3253. 	sprintf( substr( $p, 0, 7 ) . ' ' x ( 7 - length($p) ) . ' ' );
    3254. 

  3254.     } else {
    3255. 

  3255.       $out_body{$index} .=
    3256. 

  3256. 	sprintf(
    3257. 

  3257. 		substr( $p, 0, $format[$no] )
    3258. 

  3258. 		. ' ' x	( $format[$no] - length($p) ) . ' ' );
    3259. 

  3259.     }
    3260. 

  3260.     $no++;
    3261. 

  3261.   }
    3262. 

  3262.   $out_body{$index} .= '   </tr>' if ( $outtype_html or $outtype_htmlembed );
    3263. 

  3263.   $out_body{$index} .= "\n";
    3264. 

  3264. }
    3265. 

  3265. 

  3266. sub outline {
    3267. 

  3267.   my $index = shift (@_);
    3268. 

  3268.   my $print;
    3269. 

  3269.   my $no = 0;
    3270. 

  3270.   $out_body{$index} .= "   <tr>\n" if ( $outtype_html or $outtype_htmlembed );
    3271. 

  3271.   foreach (@_) {
    3272. 

  3272.     $print = $_;
    3273. 

  3273.     if ($outtype_unformatted) {
    3274. 

  3274.       $out_body{$index} .= "$print ";
    3275. 

  3275.     } elsif ( $outtype_html or $outtype_htmlembed ) {
    3276. 

  3276.       $print =~ s# +# #go;
    3277. 

  3277.       $print =~ s# $##go;
    3278. 

  3278.       $print =~ s#<#\&lt\;#go;
    3279. 

  3279.       $print =~ s#>#\&gt\;#go;
    3280. 

  3280.       if ( $no == 0 ) {
    3281. 

  3281. 	unless ( $print =~ s#^ ##go ) {
    3282. 

  3282. 	  $out_body{$index} .= "    <th align=\"left\">$print</th>\n";
    3283. 

  3283. 	} else {
    3284. 

  3284. 	  $out_body{$index} .= "    <td>&nbsp;&nbsp;$print</td>\n";
    3285. 

  3285. 	}
    3286. 

  3286.       } elsif ( $format[$no] eq '%' or $format[$no] eq 'kbs' ) {
    3287. 

  3287. 	if ( $print eq '' or $print eq '-' ) {
    3288. 

  3288. 	  $out_body{$index} .= "    <td>&nbsp;</td>\n";
    3289. 

  3289. 	} else {
    3290. 

  3290. 	  $out_body{$index} .=
    3291. 

  3291. 	    sprintf( "    <td align=\"right\">%.2f</td>\n", $print );
    3292. 

  3292. 	}
    3293. 

  3293.       } elsif ( $no == 1 or $print =~ m#^[\d\.e\-\+]+$#o ) {
    3294. 

  3294. 	$out_body{$index} .=
    3295. 

  3295. 	  sprintf( "    <td align=\"right\">%d</td>\n", $print );
    3296. 

  3296.       } else {
    3297. 

  3297. 	if ($print) {
    3298. 

  3298. 	  $out_body{$index} .= "    <td align=\"right\">$print</td>\n";
    3299. 

  3299. 	} else {
    3300. 

  3300. 	  $out_body{$index} .= "    <td align=\"right\">&nbsp;</td>\n";
    3301. 

  3301. 	}
    3302. 

  3302.       }
    3303. 

  3303.     } else {
    3304. 

  3304.       if ( $no == 0 ) {
    3305. 

  3305. 	if ( length($print) > $format[$no] ) {
    3306. 

  3306. 	  $out_body{$index} .=
    3307. 

  3307. 	    sprintf( $print . "\n" . ' ' x $format[$no] . ' ' );
    3308. 

  3308. 	} else {
    3309. 

  3309. 	  $out_body{$index} .=
    3310. 

  3310. 	    sprintf( $print . ' ' x ( $format[$no] - length($print) ) . ' ' );
    3311. 

  3311. 	}
    3312. 

  3312.       } elsif ( $format[$no] eq '%' ) {
    3313. 

  3313. 	if ( $print eq ' ' ) {
    3314. 

  3314. 	  $out_body{$index} .= ' ' x 7;
    3315. 

  3315. 	} else {
    3316. 

  3316. 	  $out_body{$index} .= sprintf( "%6.2f ", $print );
    3317. 

  3317. 	}
    3318. 

  3318.       } elsif ( $format[$no] eq 'kbs' ) {
    3319. 

  3319. 	if ( $print eq '-' ) {
    3320. 

  3320. 	  $out_body{$index} .= '    -   ';
    3321. 

  3321. 	} else {
    3322. 

  3322. 	  if ( $print >= 10000 ) {
    3323. 

  3323. 	    $out_body{$index} .= sprintf( "%7.0f ", $print );
    3324. 

  3324. 	  } else {
    3325. 

  3325. 	    $out_body{$index} .= sprintf( "%7.2f ", $print );
    3326. 

  3326. 	  }
    3327. 

  3327. 	}
    3328. 

  3328.       } else {
    3329. 

  3329. 	$print = sprintf( "%d", $print + .5 ) if $print =~ m#^[\d\.e\-\+]+$#o;
    3330. 

  3330. 	$out_body{$index} .=
    3331. 

  3331. 	  sprintf( ' ' x ( $format[$no] - length($print) )
    3332. 

  3332. 	  . substr( $print, 0, $format[$no] ) . ' ' );
    3333. 

  3333.       }
    3334. 

  3334.     }
    3335. 

  3335.     $no++;
    3336. 

  3336.   }
    3337. 

  3337.   $out_body{$index} .= '   </tr>' if ( $outtype_html or $outtype_htmlembed );
    3338. 

  3338.   $out_body{$index} .= "\n";
    3339. 

  3339. }
    3340. 

  3340. 

  3341. sub outseperator {
    3342. 

  3342.   my $index = shift (@_);
    3343. 

  3343.   my $print;
    3344. 

  3344.   $out_body{$index} .= "   <tr>\n" if ( $outtype_html or $outtype_htmlembed );
    3345. 

  3345.   foreach $print (@format) {
    3346. 

  3346.     if ($outtype_unformatted) {
    3347. 

  3347.       $out_body{$index} .= "--- ";
    3348. 

  3348.     } elsif ( $outtype_html or $outtype_htmlembed ) {
    3349. 

  3349.       $out_body{$index} .= "    <td></td>\n";
    3350. 

  3350.     } elsif ( $print eq '%' ) {
    3351. 

  3351.       $out_body{$index} .= sprintf( '-' x 6 . ' ' );
    3352. 

  3352.     } elsif ( $print eq 'kbs' ) {
    3353. 

  3353.       $out_body{$index} .= sprintf( '-' x 7 . ' ' );
    3354. 

  3354.     } else {
    3355. 

  3355.       $out_body{$index} .= sprintf( '-' x $print . ' ' );
    3356. 

  3356.     }
    3357. 

  3357.   }
    3358. 

  3358.   $out_body{$index} .= '   </tr>' if ( $outtype_html or $outtype_htmlembed );
    3359. 

  3359.   $out_body{$index} .= "\n";
    3360. 

  3360. }
    3361. 

  3361. 

  3362. sub outstop {
    3363. 

  3363.   my $index = shift (@_);
    3364. 

  3364.   if ( $outtype_html or $outtype_htmlembed ) {
    3365. 

  3365.     $out_body{$index} .= "  </table>\n";
    3366. 

  3366.     $out_body{$index} .= "  <p><a href=\"#top\">Back to Top</a></p>\n";
    3367. 

  3367.   }
    3368. 

  3368. }
    3369. 

  3369. 

  3370. sub writecache {
    3371. 

  3371.   print CACHE join ( '?', @_ ) . "\n" if $opt_o;
    3372. 

  3372. }
    3373.