[ViewVC] Diff of: cvs/cvsroot/Coro/myhttpd/httpd.pl

Comparing cvsroot/Coro/myhttpd/httpd.pl (file contents):
Revision 1.10 by root, Sat Aug 11 16:34:47 2001 UTC vs.
Revision 1.37 by root, Sun Sep 2 01:03:53 2001 UTC

…		…
1	use Coro;	1	use Coro;
2	use Coro::Semaphore;	2	use Coro::Semaphore;
3	use Coro::Event;	3	use Coro::Event;
4	use Coro::Socket;	4	use Coro::Socket;
5		5
		6	use HTTP::Date;
		7
6	no utf8;	8	no utf8;
7	use bytes;	9	use bytes;
8		10
9	# at least on my machine, this thingy serves files	11	# at least on my machine, this thingy serves files
10	# quite a bit faster than apache, ;)	12	# quite a bit faster than apache, ;)
11	# and quite a bit slower than thttpd :(	13	# and quite a bit slower than thttpd :(
12		14
13	$SIG{PIPE} = 'IGNORE';	15	$SIG{PIPE} = 'IGNORE';
14		16
		17	our $accesslog;
		18
		19	if ($ACCESS_LOG) {
		20	use IO::Handle;
		21	open $accesslog, ">>$ACCESS_LOG"
		22	or die "$ACCESS_LOG: $!";
		23	$accesslog->autoflush(1);
		24	}
		25
15	sub slog {	26	sub slog {
16	my $level = shift;	27	my $level = shift;
17	my $format = shift;	28	my $format = shift;
18	printf "---: $format\n", @_;	29	printf "---: $format\n", @_;
19	}	30	}
20		31
21	my $connections = new Coro::Semaphore $MAX_CONNECTS;	32	our $connections = new Coro::Semaphore $MAX_CONNECTS \|\| 250;
		33
		34	our $wait_factor = 0.95;
		35
		36	our @transfers = (
		37	[(new Coro::Semaphore $MAX_TRANSFERS_SMALL \|\| 50), 1],
		38	[(new Coro::Semaphore $MAX_TRANSFERS_LARGE \|\| 50), 1],
		39	);
22		40
23	my @newcons;	41	my @newcons;
24	my @pool;	42	my @pool;
25		43
26	# one "execution thread"	44	# one "execution thread"
43		61
44	my $http_port = new Coro::Socket	62	my $http_port = new Coro::Socket
45	LocalAddr => $SERVER_HOST,	63	LocalAddr => $SERVER_HOST,
46	LocalPort => $SERVER_PORT,	64	LocalPort => $SERVER_PORT,
47	ReuseAddr => 1,	65	ReuseAddr => 1,
48	Listen => 1,	66	Listen => 50,
49	or die "unable to start server";	67	or die "unable to start server";
50		68
51	push @listen_sockets, $http_port;	69	push @listen_sockets, $http_port;
		70
		71	our $NOW;
		72	our $HTTP_NOW;
		73
		74	Event->timer(interval => 1, hard => 1, cb => sub {
		75	$NOW = time;
		76	$HTTP_NOW = time2str $NOW;
		77	})->now;
52		78
53	# the "main thread"	79	# the "main thread"
54	async {	80	async {
55	slog 1, "accepting connections";	81	slog 1, "accepting connections";
56	while () {	82	while () {
57	$connections->down;	83	$connections->down;
58	push @newcons, [$http_port->accept];	84	push @newcons, [$http_port->accept];
59	#slog 3, "accepted @$connections ".scalar(@pool);	85	#slog 3, "accepted @$connections ".scalar(@pool);
60	$::NOW = time;
61	if (@pool) {	86	if (@pool) {
62	(pop @pool)->ready;	87	(pop @pool)->ready;
63	} else {	88	} else {
64	async \&handler;	89	async \&handler;
65	}	90	}
…		…
70	package conn;	95	package conn;
71		96
72	use Socket;	97	use Socket;
73	use HTTP::Date;	98	use HTTP::Date;
74	use Convert::Scalar 'weaken';	99	use Convert::Scalar 'weaken';
		100	use Linux::AIO;
75		101
		102	Linux::AIO::min_parallel $::AIO_PARALLEL;
		103
		104	Event->io(fd => Linux::AIO::poll_fileno,
		105	poll => 'r', async => 1,
		106	cb => \&Linux::AIO::poll_cb);
		107
76	our %conn; # $conn{ip}{fh} => connobj	108	our %conn; # $conn{ip}{self} => connobj
		109	our %uri; # $uri{ip}{uri}{self}
77	our %blocked;	110	our %blocked;
78	our %mimetype;	111	our %mimetype;
79		112
80	sub read_mimetypes {	113	sub read_mimetypes {
81	local *M;	114	local *M;
…		…
99	my $self = bless { fh => $fh }, $class;	132	my $self = bless { fh => $fh }, $class;
100	my (undef, $iaddr) = unpack_sockaddr_in $peername	133	my (undef, $iaddr) = unpack_sockaddr_in $peername
101	or $self->err(500, "unable to decode peername");	134	or $self->err(500, "unable to decode peername");
102		135
103	$self->{remote_addr} = inet_ntoa $iaddr;	136	$self->{remote_addr} = inet_ntoa $iaddr;
		137	$self->{time} = $::NOW;
104		138
105	# enter ourselves into various lists	139	$::conns++;
106	weaken ($conn{$self->{remote_addr}}{$self*1} = $self);
107		140
108	$self;	141	$self;
109	}	142	}
110		143
111	sub DESTROY {	144	sub DESTROY {
112	my $self = shift;	145	my $self = shift;
		146
		147	$::conns--;
		148
		149	$self->eoconn;
		150	}
		151
		152	# end of connection
		153	sub eoconn {
		154	my $self = shift;
		155
		156	# clean up hints
113	delete $conn{$self->{remote_addr}}{$self*1};	157	delete $conn{$self->{remote_id}}{$self*1};
114	delete $uri{$self->{uri}}{$self*1};	158	delete $uri{$self->{remote_id}}{$self->{uri}}{$self*1};
115	}	159	}
116		160
117	sub slog {	161	sub slog {
118	my $self = shift;	162	my $self = shift;
119	main::slog($_[0], "$self->{remote_addr}> $_[1]");	163	main::slog($_[0], ($self->{remote_id} \|\| $self->{remote_addr}) ."> $_[1]");
120	}	164	}
121		165
122	sub response {	166	sub response {
123	my ($self, $code, $msg, $hdr, $content) = @_;	167	my ($self, $code, $msg, $hdr, $content) = @_;
124	my $res = "HTTP/1.0 $code $msg\015\012";	168	my $res = "HTTP/1.1 $code $msg\015\012";
125		169
126	$res .= "Connection: close\015\012";	170	$self->{h}{connection} \|\|= $hdr->{Connection};
127	$res .= "Date: ".(time2str $::NOW)."\015\012"; # slow? nah. :(	171
		172	$res .= "Date: $HTTP_NOW\015\012";
128		173
129	while (my ($h, $v) = each %$hdr) {	174	while (my ($h, $v) = each %$hdr) {
130	$res .= "$h: $v\015\012"	175	$res .= "$h: $v\015\012"
131	}	176	}
132	$res .= "\015\012";	177	$res .= "\015\012";
133		178
134	$res .= $content if defined $content and $self->{method} eq "GET";	179	$res .= $content if defined $content and $self->{method} ne "HEAD";
135		180
136	print STDERR "$self->{remote_addr} \"$self->{uri}\" $code ".$hdr->{"Content-Length"}." \"$self->{h}{referer}\"\n";#d#	181	my $log = "$self->{remote_addr} \"$self->{uri}\" $code ".$hdr->{"Content-Length"}." \"$self->{h}{referer}\"\n";
137		182
		183	print $accesslog $log if $accesslog;
		184	print STDERR $log;
		185
		186	$self->{written} +=
138	print {$self->{fh}} $res;	187	print {$self->{fh}} $res;
139	}	188	}
140		189
141	sub err {	190	sub err {
142	my $self = shift;	191	my $self = shift;
143	my ($code, $msg, $hdr, $content) = @_;	192	my ($code, $msg, $hdr, $content) = @_;
144		193
145	unless (defined $content) {	194	unless (defined $content) {
146	$content = "$code $msg";	195	$content = "$code $msg\n";
147	$hdr->{"Content-Type"} = "text/plain";	196	$hdr->{"Content-Type"} = "text/plain";
148	$hdr->{"Content-Length"} = length $content;	197	$hdr->{"Content-Length"} = length $content;
149	}	198	}
		199	$hdr->{"Connection"} = "close";
150		200
151	$self->response($code, $msg, $hdr, $content);	201	$self->response($code, $msg, $hdr, $content);
152		202
153	die bless {}, err::;	203	die bless {}, err::;
154	}	204	}
155		205
156	sub err_blocked {
157	my $self = shift;
158	my $ip = $self->{remote_addr};
159	my $time = time2str $blocked{$ip} = $::NOW + $::BLOCKTIME;
160
161	Coro::Event::do_timer(after => 5);
162
163	$self->err(403, "too many connections",
164	{
165	"Content-Type" => "text/html",
166	"Retry-After" => $::BLOCKTIME
167	},
168	<<EOF);
169	<html><p>
170	You have been blocked because you opened too many connections. You
171	may retry at</p>
172
173	<p><blockquote>$time.</blockquote></p>
174
175	<p>Until then, each new access will renew the block. You might want to have a
176	look at the <a href="http://www.goof.com/pcg/marc/animefaq.html">FAQ</a>.</p>
177	</html>
178	EOF
179	}
180
181	sub handle {	206	sub handle {
182	my $self = shift;	207	my $self = shift;
183	my $fh = $self->{fh};	208	my $fh = $self->{fh};
184		209
		210	my $host;
		211
		212	$fh->timeout($::REQ_TIMEOUT);
185	#while() {	213	while() {
		214	$self->{reqs}++;
		215
		216	# read request and parse first line
		217	my $req = $fh->readline("\015\012\015\012");
		218
		219	unless (defined $req) {
		220	if (exists $self->{version}) {
		221	last;
		222	} else {
		223	$self->err(408, "request timeout");
		224	}
		225	}
		226
186	$self->{h} = {};	227	$self->{h} = {};
187		228
188	# read request and parse first line
189	$fh->timeout($::REQ_TIMEOUT);
190	my $req = $fh->readline("\015\012\015\012");
191	$fh->timeout($::RES_TIMEOUT);	229	$fh->timeout($::RES_TIMEOUT);
192
193	defined $req or
194	$self->err(408, "request timeout");
195
196	my $ip = $self->{remote_addr};
197
198	if ($blocked{$ip}) {
199	$self->err_blocked($blocked{$ip})
200	if $blocked{$ip} > $::NOW;
201
202	delete $blocked{$ip};
203	}
204
205	if (%{$conn{$ip}} > $::MAX_CONN_IP) {
206	$self->slog("blocked ip $ip");
207	$self->err_blocked;
208	}
209		230
210	$req =~ /^(?:\015\012)?	231	$req =~ /^(?:\015\012)?
211	(GET\|HEAD) \040+	232	(GET\|HEAD) \040+
212	([^\040]+) \040+	233	([^\040]+) \040+
213	HTTP\/([0-9]+\.[0-9]+)	234	HTTP\/([0-9]+\.[0-9]+)
214	\015\012/gx	235	\015\012/gx
215	or $self->err(403, "method not allowed", { Allow => "GET,HEAD" });	236	or $self->err(405, "method not allowed", { Allow => "GET,HEAD" });
216
217	$2 ne "1.0"
218	or $self->err(506, "http protocol version not supported");
219		237
220	$self->{method} = $1;	238	$self->{method} = $1;
221	$self->{uri} = $2;	239	$self->{uri} = $2;
		240	$self->{version} = $3;
		241
		242	$3 =~ /^1\./
		243	or $self->err(506, "http protocol version $3 not supported");
222		244
223	# parse headers	245	# parse headers
224	{	246	{
225	my (%hdr, $h, $v);	247	my (%hdr, $h, $v);
226		248
…		…
237		259
238	$self->{h}{$h} = substr $v, 1	260	$self->{h}{$h} = substr $v, 1
239	while ($h, $v) = each %hdr;	261	while ($h, $v) = each %hdr;
240	}	262	}
241		263
		264	# remote id should be unique per user
		265	my $id = $self->{remote_addr};
		266
		267	if (exists $self->{h}{"client-ip"}) {
		268	$id .= "[".$self->{h}{"client-ip"}."]";
		269	} elsif (exists $self->{h}{"x-forwarded-for"}) {
		270	$id .= "[".$self->{h}{"x-forwarded-for"}."]";
		271	}
		272
		273	$self->{remote_id} = $id;
		274
		275	if ($blocked{$id}) {
		276	$self->err_blocked($blocked{$id})
		277	if $blocked{$id} > $::NOW;
		278
		279	delete $blocked{$id};
		280	}
		281
		282	if (%{$conn{$id}} >= $::MAX_CONN_IP) {
		283	my $delay = $::PER_TIMEOUT + 15;
		284	while (%{$conn{$id}} >= $::MAX_CONN_IP) {
		285	if ($delay <= 0) {
		286	$self->slog(2, "blocked ip $id");
		287	$self->err_blocked;
		288	} else {
		289	Coro::Event::do_timer(after => 4); $delay -= 4;
		290	}
		291	}
		292	}
		293
		294	# find out server name and port
		295	if ($self->{uri} =~ s/^http:\/\/([^\/?#]*)//i) {
		296	$host = $1;
		297	} else {
		298	$host = $self->{h}{host};
		299	}
		300
		301	if (defined $host) {
242	$self->{server_port} = $self->{h}{host} =~ s/:([0-9]+)$// ? $1 : 80;	302	$self->{server_port} = $host =~ s/:([0-9]+)$// ? $1 : 80;
		303	} else {
		304	($self->{server_port}, $host)
		305	= unpack_sockaddr_in $self->{fh}->getsockname
		306	or $self->err(500, "unable to get socket name");
		307	$host = inet_ntoa $host;
		308	}
243		309
		310	$self->{server_name} = $host;
		311
		312	# enter ourselves into various lists
		313	weaken ($conn{$id}{$self*1} = $self);
244	weaken ($uri{$self->{uri}}{$self*1} = $self);	314	weaken ($uri{$id}{$self->{uri}}{$self*1} = $self);
245		315
		316	eval {
246	$self->map_uri;	317	$self->map_uri;
247	$self->respond;	318	$self->respond;
		319	};
		320
		321	$self->eoconn;
		322
		323	die if $@ && !ref $@;
		324
		325	last if $self->{h}{connection} =~ /close/ \|\| $self->{version} < 1.1;
		326
		327	$fh->timeout($::PER_TIMEOUT);
248	#}	328	}
249	}	329	}
250		330
251	# uri => path mapping	331	# uri => path mapping
252	sub map_uri {	332	sub map_uri {
253	my $self = shift;	333	my $self = shift;
254	my $host = $self->{h}{host} \|\| "default";	334	my $host = $self->{server_name};
255	my $uri = $self->{uri};	335	my $uri = $self->{uri};
256		336
257	# some massaging, also makes it more secure	337	# some massaging, also makes it more secure
258	$uri =~ s/%([0-9a-fA-F][0-9a-fA-F])/chr hex $1/ge;	338	$uri =~ s/%([0-9a-fA-F][0-9a-fA-F])/chr hex $1/ge;
259	$uri =~ s%//+%/%g;	339	$uri =~ s%//+%/%g;
…		…
269	$self->{path} = "$::DOCROOT/$host$uri";	349	$self->{path} = "$::DOCROOT/$host$uri";
270		350
271	$self->access_check;	351	$self->access_check;
272	}	352	}
273		353
274	sub server_address {
275	my $self = shift;
276	my ($port, $iaddr) = unpack_sockaddr_in $self->{fh}->getsockname
277	or $self->err(500, "unable to get socket name");
278	((inet_ntoa $iaddr), $port);
279	}
280
281	sub server_host {
282	my $self = shift;
283	if (exists $self->{h}{host}) {
284	return $self->{h}{host};
285	} else {
286	return (($self->server_address)[0]);
287	}
288	}
289
290	sub server_hostport {
291	my $self = shift;
292	my ($host, $port);
293	if (exists $self->{h}{host}) {
294	($host, $port) = ($self->{h}{host}, $self->{server_port});
295	} else {
296	($host, $port) = $self->server_address;
297	}
298	$port = $port == 80 ? "" : ":$port";
299	$host.$port;
300	}
301
302	sub _cgi {	354	sub _cgi {
303	my $self = shift;	355	my $self = shift;
304	my $path = shift;	356	my $path = shift;
305	my $fh;	357	my $fh;
306		358
307	# no two-way xxx supported	359	# no two-way xxx supported
308	if (0 == fork) {	360	if (0 == fork) {
309	open STDOUT, ">&".fileno($self->{fh});	361	open STDOUT, ">&".fileno($self->{fh});
310	if (chdir $::DOCROOT) {	362	if (chdir $::DOCROOT) {
311	$ENV{SERVER_SOFTWARE} = "thttpd-myhttpd"; # we are thttpd-alike	363	$ENV{SERVER_SOFTWARE} = "thttpd-myhttpd"; # we are thttpd-alike
312	$ENV{HTTP_HOST} = $self->server_host;	364	$ENV{HTTP_HOST} = $self->{server_name};
313	$ENV{HTTP_PORT} = $self->{server_host};	365	$ENV{HTTP_PORT} = $self->{server_port};
314	$ENV{SCRIPT_NAME} = $self->{name};	366	$ENV{SCRIPT_NAME} = $self->{name};
315	exec $path;	367	exec $path;
316	}	368	}
317	Coro::State::_exit(0);	369	Coro::State::_exit(0);
318	} else {	370	} else {
		371	die;
319	}	372	}
		373	}
		374
		375	sub server_hostport {
		376	$_[0]{server_port} == 80
		377	? $_[0]{server_name}
		378	: "$_[0]{server_name}:$_[0]{server_port}";
320	}	379	}
321		380
322	sub respond {	381	sub respond {
323	my $self = shift;	382	my $self = shift;
324	my $path = $self->{path};	383	my $path = $self->{path};
…		…
334		393
335	if (-d _ && -r _) {	394	if (-d _ && -r _) {
336	# directory	395	# directory
337	if ($path !~ /\/$/) {	396	if ($path !~ /\/$/) {
338	# create a redirect to get the trailing "/"	397	# create a redirect to get the trailing "/"
339	my $host = $self->server_hostport;	398	# we don't try to avoid the :80
340	$self->err(301, "moved permanently", { Location => "http://$host$self->{uri}/" });	399	$self->err(301, "moved permanently", { Location => "http://".$self->server_hostport."$self->{uri}/" });
341	} else {	400	} else {
342	$ims < $self->{stat}[9]	401	$ims < $self->{stat}[9]
343	or $self->err(304, "not modified");	402	or $self->err(304, "not modified");
344		403
345	if ($self->{method} eq "GET") {
346	if (-r "$path/index.html") {	404	if (-r "$path/index.html") {
347	$self->{path} .= "/index.html";	405	$self->{path} .= "/index.html";
348	$self->handle_file;	406	$self->handle_file;
349	} else {	407	} else {
350	$self->handle_dir;	408	$self->handle_dir;
351	}
352	}	409	}
353	}	410	}
354	} elsif (-f _ && -r _) {	411	} elsif (-f _ && -r _) {
355	-x _ and $self->err(403, "forbidden");	412	-x _ and $self->err(403, "forbidden");
356	$self->handle_file;	413	$self->handle_file;
…		…
371	$idx);	428	$idx);
372	}	429	}
373		430
374	sub handle_file {	431	sub handle_file {
375	my $self = shift;	432	my $self = shift;
376	my $length = -s _;	433	my $length = $self->{stat}[7];
		434	my $queue = $::transfers[$length >= $::TRANSFER_SMALL];
377	my $hdr = {	435	my $hdr = {
378	"Last-Modified" => time2str ((stat _)[9]),	436	"Last-Modified" => time2str ((stat _)[9]),
379	};	437	};
380		438
381	my @code = (200, "ok");	439	my @code = (200, "ok");
…		…
389	($l, $h) = ($1, ($2 ne "" \|\| $2 >= $length) ? $2 : $length - 1);	447	($l, $h) = ($1, ($2 ne "" \|\| $2 >= $length) ? $2 : $length - 1);
390	} else {	448	} else {
391	($l, $h) = (0, $length - 1);	449	($l, $h) = (0, $length - 1);
392	goto ignore;	450	goto ignore;
393	}	451	}
394	goto satisfiable if $l >= 0 && $l < $length && $h >= 0 && $h > $l;	452	goto satisfiable if $l >= 0 && $l < $length && $h >= 0 && $h >= $l;
395	}	453	}
396	$hdr->{"Content-Range"} = "bytes */$length";	454	$hdr->{"Content-Range"} = "bytes */$length";
		455	$hdr->{"Content-Length"} = $length;
397	$self->err(416, "not satisfiable", $hdr);	456	$self->err(416, "not satisfiable", $hdr, "");
398		457
399	satisfiable:	458	satisfiable:
400	# check for segmented downloads	459	# check for segmented downloads
401	if ($l && $::NO_SEGMENTED) {	460	if ($l && $::NO_SEGMENTED) {
		461	my $delay = $::PER_TIMEOUT + 15;
402	if (%{$uri{$self->{uri}}} > 1) {	462	while (%{$uri{$self->{remote_id}}{$self->{uri}}} > 1) {
403	$self->slog("segmented download refused\n");	463	if ($delay <= 0) {
404	$self->err(400, "segmented downloads are not allowed");	464	$self->err_segmented_download;
		465	} else {
		466	Coro::Event::do_timer(after => 4); $delay -= 4;
		467	}
405	}	468	}
406	}	469	}
407		470
408	$hdr->{"Content-Range"} = "bytes $l-$h/$length";	471	$hdr->{"Content-Range"} = "bytes $l-$h/$length";
409	@code = (206, "partial content");	472	@code = (206, "partial content");
…		…
419	$hdr->{"Content-Length"} = $length;	482	$hdr->{"Content-Length"} = $length;
420		483
421	$self->response(@code, $hdr, "");	484	$self->response(@code, $hdr, "");
422		485
423	if ($self->{method} eq "GET") {	486	if ($self->{method} eq "GET") {
		487	$self->{time} = $::NOW;
		488
		489	my $fudge = $queue->[0]->waiters;
		490	$fudge = $fudge ? ($fudge+1)/$fudge : 1;
		491
		492	$queue->[1] *= $fudge;
		493	my $transfer = $queue->[0]->guard;
		494
		495	if ($fudge != 1) {
		496	$queue->[1] /= $fudge;
		497	$queue->[1] = $queue->[1] * $::wait_factor
		498	+ ($::NOW - $self->{time}) * (1 - $::wait_factor);
		499	}
		500	$self->{time} = $::NOW;
		501
		502	$self->{fh}->writable or return;
		503
424	my ($fh, $buf);	504	my ($fh, $buf, $r);
		505	my $current = $Coro::current;
425	open $fh, "<", $self->{path}	506	open $fh, "<", $self->{path}
426	or die "$self->{path}: late open failure ($!)";	507	or die "$self->{path}: late open failure ($!)";
427		508
428	if ($l) {
429	sysseek $fh, $l, 0
430	or die "$self->{path}: cannot seek to $l ($!)";
431	}
432
433	$h -= $l - 1;	509	$h -= $l - 1;
434		510
		511	if (0) {
		512	if ($l) {
		513	sysseek $fh, $l, 0;
		514	}
		515	}
		516
435	while ($h > 0) {	517	while ($h > 0) {
		518	if (0) {
436	$h -= sysread $fh, $buf, $h > $::BUFSIZE ? $::BUFSIZE : $h;	519	sysread $fh, $buf, $h > $::BUFSIZE ? $::BUFSIZE : $h
437	$self->{fh}->syswrite($buf)	520	or last;
		521	} else {
		522	aio_read($fh, $l, ($h > $::BUFSIZE ? $::BUFSIZE : $h),
		523	$buf, 0, sub {
		524	$r = $_[0];
		525	Coro::ready($current);
		526	});
		527	&Coro::schedule;
		528	last unless $r;
		529	}
		530	my $w = syswrite $self->{fh}, $buf
438	or last;	531	or last;
		532	$::written += $w;
		533	$self->{written} += $w;
		534	$l += $r;
439	}	535	}
440	}
441		536
442	close $fh;	537	close $fh;
		538	}
443	}	539	}
444		540
445	1;	541	1;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing cvsroot/Coro/myhttpd/httpd.pl (file contents): Revision 1.10 by root, Sat Aug 11 16:34:47 2001 UTC vs. Revision 1.37 by root, Sun Sep 2 01:03:53 2001 UTC

Diff Legend

Comparing cvsroot/Coro/myhttpd/httpd.pl (file contents):
Revision 1.10 by root, Sat Aug 11 16:34:47 2001 UTC vs.
Revision 1.37 by root, Sun Sep 2 01:03:53 2001 UTC