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

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

Diff Legend

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

Comparing Coro/myhttpd/httpd.pl (file contents): Revision 1.12 by root, Sat Aug 11 23:10:56 2001 UTC vs. Revision 1.38 by root, Sun Sep 2 02:27:51 2001 UTC

Diff Legend

Comparing Coro/myhttpd/httpd.pl (file contents):
Revision 1.12 by root, Sat Aug 11 23:10:56 2001 UTC vs.
Revision 1.38 by root, Sun Sep 2 02:27:51 2001 UTC