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

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

Diff Legend

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

Comparing Coro/myhttpd/httpd.pl (file contents): Revision 1.24 by root, Sat Aug 18 13:32:17 2001 UTC vs. Revision 1.40 by root, Mon Sep 3 00:06:06 2001 UTC

Diff Legend

Comparing Coro/myhttpd/httpd.pl (file contents):
Revision 1.24 by root, Sat Aug 18 13:32:17 2001 UTC vs.
Revision 1.40 by root, Mon Sep 3 00:06:06 2001 UTC