# This spawns a secure HTTP server that uses a master process and a pool of
#   slave processes.  Each slave process has a pair of pipes to communicate
#   with the master process.  The master process does nothing but listen on a
#   socket, and multiplex the HTTP requests and responses between the client
#   and the slave processes assigned to the client connections.  HTTP pipelining
#   is supported.
# This code is not a complete program; it calls routines that are in the main
#   program but not here.  Full program available upon request.
#
# The basic flow in the main select() loop is:
#   for each writeable filehandle, do an accept, shutdown, read, or write,
#     depending on what that filehandle currently needs
#   for each readable (non-listening) filehandle, do the same
#
# In each of try_SSL_accept(), try_SSL_read(), try_SSL_write(), try_SSL_shutdown(),
#   and try_syswrite(), upon success various variables like %pipe and %fh are modified
#   to reflect the new state; also, $select_read and $select_write are updated.
#
# The important variables are:
#   $select_read, $select_write -- the constantly-updated IO::Select objects 
#   @slaves -- the pool of slave processes not currently in use
#   %in_use -- the set of slave processes currently in use, keyed by their slave PID
#   %fh -- data stored for each filehandle, keyed by the filehandle itself
#     Important fields are:
#       needs_accept, needs_shutdown, needs_read -- flags indicating such states
#       buf_to_write -- data that needs to be written to this filehandle (obviates "needs_write")
#       ssl -- the SSL object for this filehandle
#       twin -- for the pipes to and from a slave, this is the other of the pair
#   %pipe -- data stored for each source/sink pair, keyed by the source filehandle;
#     one of the source or sink is the client socket, and the other is a slave pipe.
#     Important fields are:
#       owner -- PID of the associated slave process, if the source is a slave pipe
#       sink -- sink filehandle
#       source_ssl, sink_ssl -- SSL objects for the respective filehandles
#       conn_close -- true if "Connection: close" header came through this pipe
#       buf -- data that's been fully written, that must be analyzed for complete HTTP messages
#       left, chunked, left_in_chunk, has_body, got_headers -- used in message_is_complete()
#
# The word "pipe" has multiple meanings, unfortunately.

sub start_https_pooling_server {
    our($LISTEN, $LOCK_FH, $max_slaves)= @_ ;
    our($select_read, $select_write, @slaves, $num_slaves, %in_use, %pipe, $buf, %fh) ;

    SSL_Handle::create_SSL_CONTEXT(1) ;

    my $new_pid= double_fork_daemon($LOCK_FH, $LISTEN) ;
    return $new_pid if $new_pid ;

    # We are now in the master daemon process.

    # Get the port bound to by $LISTEN.
    our $port= (unpack_sockaddr_in(getsockname($LISTEN)))[0] ;

    # Record port and PID in lockfile.
    select((select($LOCK_FH), $|=1)[0]) ;   # make $LOCK_FH autoflush output
    seek($LOCK_FH, 0, 0) ;
    print $LOCK_FH "$port,$$\n" ;

    # Clear permissions mask, for easier file-handling.
    umask 0 ;

    local $SIG{CHLD} = \&SLAVE_REAPER;
    local $SIG{PIPE}= 'IGNORE' ;


    # Multiplex multiple requests and responses at once.

    $select_read= IO::Select->new($LISTEN) ;
    $select_write= IO::Select->new() ;

    while (1) {
      SELECT:
	my($read_ready, $write_ready)= IO::Select->select($select_read, $select_write) ;

	foreach (@$write_ready) {
	    if ($fh{''.$_}{needs_accept}) {
		my $rv= try_SSL_accept($_) ;

	    } elsif ($fh{''.$_}{needs_shutdown}) {
		my $rv= try_SSL_shutdown($_) ;

	    } elsif ($fh{''.$_}{needs_read}) {
		my($got, $rv)= try_SSL_read($_) ;

	    } elsif ($fh{''.$_}{buf_to_write} ne '') {
		# This implies the selected handle is a pipe to a slave.
		if (defined $fh{''.$_}{twin}) {
		    my $rv= try_syswrite($_) ;

		# Else it's the socket to the client.
		} else {
		    my $rv= try_SSL_write($_) ;
		}

	    } else {
		$select_write->remove($_) ;
	    }
	}


	foreach (@$read_ready) {

	    # Handle listening socket.
	    if ($_==$LISTEN) {
		my $SOCK2CLIENT ;
		my $paddr= accept($SOCK2CLIENT, $LISTEN) ;
		next if !$paddr and $!==EINTR ;
		die "accept: $!"  unless $paddr ;

		# Set $SOCK2CLIENT to be non-blocking.
		my $flags= fcntl($SOCK2CLIENT, F_GETFL, 0) or die "fcntl F_GETFL: $!\n";
		fcntl($SOCK2CLIENT, F_SETFL, $flags|O_NONBLOCK) or die "fcntl F_SETFL O_NONBLOCK: $!\n" ;

		select((select($SOCK2CLIENT), $|=1)[0]) ;      # unbuffer the socket

		my $ssl= Net::SSLeay::new($SSL_Handle::SSL_CONTEXT)
		    or die "Can't create SSL connection: $!" ;
		Net::SSLeay::set_fd($ssl, fileno($SOCK2CLIENT))
		    or die "Can't set_fd: $!" ;
		$fh{''.$SOCK2CLIENT}{ssl}= $ssl ;

		# try_SSL_accept() also sets up many variables upon success.
		my $rv= try_SSL_accept($SOCK2CLIENT) ;


	    # Handle other (non-listening) sockets and pipes.
	    } else {
		# Finish accept() if required.
		if ($fh{''.$_}{needs_accept}) {
		    my $rv= try_SSL_accept($_) ;

		} elsif ($fh{''.$_}{needs_shutdown}) {
		    my $rv= try_SSL_shutdown($_) ;

		# Handle write requirement, which may select on read availability.
		} elsif ($fh{''.$_}{buf_to_write} ne '' and $fh{''.$_}{ssl}) {
		    my $rv= try_SSL_write($_) ;

		# Handle actual reads, not accepts or writes.
		} else {
		    my($got, $rv) ;

		    # Handle if pipe's source is slave pipe.
		    # jsm-- must handle if destination server returns no CL or TE-- how to end on end of response?
		    if (defined $pipe{''.$_}{owner}) {
			# Reading pipe from slave, writing to SSL client.
			$rv= sysread($_, $got, 32768-length($fh{''.$pipe{''.$_}{sink}}{buf_to_write})) ;
			if (!defined $rv) {
			    next if $!==EAGAIN or $!==EWOULDBLOCK or $!==EINTR or $!==ENOBUFS ;
			    die "sysread($_) failed: $!\n" ;
			}
			if ($rv==0) {
			    # Slave pipe died for some reason-- kill slave.
			    kill_slave($_) ;
			    next ;
			}

			# Success-- copy $got over to write buffer.
			$fh{''.$pipe{''.$_}{sink}}{buf_to_write}.= $got ;
			$select_write->add($pipe{''.$_}{sink}) ;

		    # Handle if pipe's source is remote client socket.
		    } else {
			# Reading from SSL client, writing pipe to slave.
			($got, $rv)= try_SSL_read($_) ;
			next if defined $rv and $rv==0 ;
			next unless defined $got ;
		    }
		}
	    }
	}
    }


    # Clean up zombies.  Damn zombies.
    sub SLAVE_REAPER {
	local $! ;
	1 while waitpid(-1, WNOHANG)>0 and WIFEXITED($?) ;
	$SIG{CHLD} = \&SLAVE_REAPER;
    }


    # "Accept" (in the OpenSSL sense), and handle all cases.
    # Upon success, set up %fh, %pipe, etc. as needed.
    sub try_SSL_accept {
	my($socket)= @_ ;

	my $ssl= $fh{''.$socket}{ssl} ;
	my $rv= Net::SSLeay::accept($ssl) ;
	if ($rv<=0) {
	    $fh{''.$socket}{needs_accept}= 1 ;
	    my $err= Net::SSLeay::get_error($ssl, $rv) ;
	    if ($err==Net::SSLeay::ERROR_WANT_READ()) {
		$select_read->add($socket)  unless $select_read->exists($socket) ;
		$select_write->remove($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_WANT_WRITE() or $err==Net::SSLeay::ERROR_WANT_ACCEPT()) {
		$select_write->add($socket) ;
		$select_read->remove($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_SSL()) {
		warn Net::SSLeay::ERR_error_string($err) . "\n"  while $err= Net::SSLeay::ERR_get_error() ;
		die "Net::SSLeay::accept() failed\n" ;
	    } elsif ($err==Net::SSLeay::ERROR_SYSCALL()) {
	    }
	    return 0 ;

	# Upon success, set all needed variables.
	} else {
	    $fh{''.$socket}{needs_accept}= 0 ;
	    $select_write->remove($socket) ;

	    my $slave= shift(@slaves) ;
	    if (!$slave) {
		if (++$num_slaves>$max_slaves) {
		    die "Server too busy right now." ;   # jsm-- don't die, but just return error
		    next ;
		}
		$slave= make_slave($LOCK_FH, $port) ;
	    }
	    # Send 4-char client address to slave to start session.
	    my $fh= $slave->{pipe_to} ;  # required to avoid syntax error
	    print $fh (unpack_sockaddr_in(getpeername($socket)))[1] ;

	    $in_use{$slave->{pid}}= $slave ;
	    $slave->{client}= $socket ;
	    $select_read->add($slave->{pipe_from}) unless $select_read->exists($slave->{pipe_from}) ;
	    $select_read->add($slave->{client}) unless $select_read->exists($slave->{client}) ;

	    $pipe{''.$slave->{client}}=    { sink => $slave->{pipe_to},
					     source_ssl => $ssl } ;
	    $pipe{''.$slave->{pipe_from}}= { owner => $slave->{pid},
					     sink => $slave->{client},
					     sink_ssl => $ssl } ;
	    $fh{''.$slave->{pipe_to}}{twin}= $slave->{pipe_from} ;
	    $fh{''.$slave->{pipe_from}}{twin}= $slave->{pipe_to} ;

	    return 1 ;
	}
    }


    sub try_SSL_write {
	my($socket)= @_ ;

	my $ssl= $fh{''.$socket}{ssl} ;
	my $buf= $fh{''.$socket}{buf_to_write} ;
	my $rv= Net::SSLeay::write($ssl, $buf) ;
	if ($rv<=0) {
	    my $err= Net::SSLeay::get_error($ssl, $rv) ;
	    if ($err==Net::SSLeay::ERROR_WANT_READ()) {
		$select_read->add($socket)  unless $select_read->exists($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_WANT_WRITE()) {
		$select_write->add($socket) ;
		$select_read->remove($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_ZERO_RETURN()) {
		my $rv= try_SSL_shutdown($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_SSL()) {
		warn Net::SSLeay::ERR_error_string($err) . "\n"  while $err= Net::SSLeay::ERR_get_error() ;
		die "Net::SSLeay::write() failed; err=[$err]\n" ;
	    } else {
		die "Net::SSLeay::write() failed 2; err=[$err]\n" ;
	    }
	} else {
	    if ($rv<length($buf)) {
		# Add part written to $pipe->{buf} .
		$pipe{''.$fh{''.$pipe{''.$socket}{sink}}{twin}}{buf}.= substr($buf, 0, $rv) ;
		substr($fh{''.$socket}{buf_to_write}, 0, $rv)= '' ;
	    } else {
		$pipe{''.$fh{''.$pipe{''.$socket}{sink}}{twin}}{buf}.= $buf ;
		$fh{''.$socket}{buf_to_write}= '' ;
		$select_write->remove($socket) ;
	    }

	    # Analyze data coming from slave pipe, counting completed messages.
	    my $msgs_completed ;
	    $msgs_completed++ while message_is_complete($pipe{''.$fh{''.$pipe{''.$socket}{sink}}{twin}}) ;   # leaves remainder in $pipe->{buf}
	    if ($msgs_completed) {

		# Close client socket, unless pipelining.
		# jsm-- don't use eof() on socket-- eof() uses buffered I/O.
		if ($pipe{''.$socket}{conn_close} or $pipe{''.$fh{''.$pipe{''.$socket}{sink}}{twin}}{conn_close} or $pipe{''.$socket}{sink}->eof) {
		    my $rv= try_SSL_shutdown($socket) ;
		}
	    }
	}
	return $rv ;
    }


    sub try_SSL_read {
	my($socket)= @_ ;

	my($got, $rv)= Net::SSLeay::read($fh{''.$socket}{ssl}) ;
	die "Can't Net::SSLeay::read(): $!\n"
	    unless defined $got or $!==EAGAIN or $!==EWOULDBLOCK or $!==EINTR or $!==ENOBUFS ;
	if ($rv<=0) {
	    $fh{''.$socket}{needs_read}= 1 ;
	    my $err= Net::SSLeay::get_error($fh{''.$socket}{ssl}, $rv) ;
	    if ($err==Net::SSLeay::ERROR_WANT_READ()) {
		$select_read->add($socket)  unless $select_read->exists($socket) ;
		$select_write->remove($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_WANT_WRITE()) {
		$select_write->add($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_ZERO_RETURN()) {
		my $rv= try_SSL_shutdown($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_SSL()) {
		warn Net::SSLeay::ERR_error_string($err) . "\n"  while $err= Net::SSLeay::ERR_get_error() ;
	    } elsif ($err==Net::SSLeay::ERROR_SYSCALL()) {
		warn "err==Net::SSLeay::ERROR_SYSCALL: [$!]\n" ;
		warn Net::SSLeay::ERR_error_string($err) . "\n"  while $err= Net::SSLeay::ERR_get_error() ;
	    } else {
		die "Net::SSLeay::read() failed 3; err=[$err]\n" ;
	    }
	    return (undef, $rv) ;
	} else {
	    $fh{''.$pipe{''.$socket}{sink}}{buf_to_write}.= $got ;
	    $select_write->add($pipe{''.$socket}{sink}) ;
	    $select_write->remove($socket) ;
	    $fh{''.$socket}{needs_read}= 0 ;
	    return ($got, $rv) ;
	}
    }


    sub try_SSL_shutdown {
	my($socket)= @_ ;

	my $ssl= $fh{''.$socket}{ssl} ;
	my $rv= Net::SSLeay::shutdown($ssl) ;
	if ($rv<=0) {
	    $fh{''.$socket}{needs_shutdown}= 1 ;
	    my $err= Net::SSLeay::get_error($ssl, $rv) ;
	    if ($err==Net::SSLeay::ERROR_WANT_READ()) {
		$select_read->add($socket)  unless $select_read->exists($socket) ;
		$select_write->remove($socket) ;
	    } elsif ($err==Net::SSLeay::ERROR_WANT_WRITE()) {
		$select_write->add($socket) ;
		$select_read->remove($socket) ;

	    # This is an erroneous error message, but it may happen.
	    } elsif ($err==Net::SSLeay::ERROR_SYSCALL()) {
		# what should happen here with $select_read and $select_write?
	    } else {
	    }
	} else {
	    $select_read->remove($socket, $fh{$pipe{''.$socket}{sink}}{twin}) ;
	    $select_write->remove($socket, $pipe{''.$socket}{sink}) ;
	    $fh{''.$socket}{needs_shutdown}= 0 ;
	    Net::SSLeay::free($ssl) ;
	    close($socket) ;

	    push(@slaves, delete $in_use{$pipe{$fh{''.$pipe{''.$socket}{sink}}{twin}}{owner}}) ;   # sorry
	    delete $pipe{$fh{''.$pipe{''.$socket}{sink}}{twin}} ;
	    delete $pipe{''.$socket} ;
	    delete $fh{''.$socket} ;
	}
	return $rv ;
    }


    sub try_syswrite {
	my($pipe_to)= @_ ;

	my $written= syswrite($pipe_to, $fh{''.$pipe_to}{buf_to_write}) ;
	if ($written==-1) {
	    return undef  if $!==EAGAIN or $!==EWOULDBLOCK or $!==EINTR ;
	    if ($!==EPIPE) {
		kill_slave($fh{''.$pipe_to}{twin}) ;
		return undef ;
	    }
	    die "syswrite($pipe_to) failed: $!\n" ;
	}
	$pipe{''.$pipe{''.$fh{''.$pipe_to}{twin}}{sink}}{buf}.= substr($fh{''.$pipe_to}{buf_to_write}, 0, $written) ;
	substr($fh{''.$pipe_to}{buf_to_write}, 0, $written)= '' ;
	$select_write->remove($pipe_to)  if $fh{''.$pipe_to}{buf_to_write} eq '' ;
	return $written ;
    }


    sub kill_slave {
	my($pipe_from)= @_ ;

	my $rv= try_SSL_shutdown($pipe{''.$pipe_from}{sink}) ;
	kill 'TERM', $pipe{''.$pipe_from}{owner} ;
	pop(@slaves)  if $rv>0 ;      # try_SSL_shutdown() recycled $slave
	delete $fh{''.$fh{''.$pipe_from}{twin}} ;
	delete $fh{''.$pipe{''.$pipe_from}{sink}} ;
	delete $fh{''.$pipe_from} ;
	delete $pipe{''.$pipe{''.$pipe_from}{sink}} ;
	delete $pipe{''.$pipe_from} ;
	$num_slaves-- ;
    }

}


# Create a new slave process, returning its info in a hash reference.
# This is where the slave processing takes place.
sub make_slave {
    my($LOCK_FH, $port)= @_ ;
    my($pipe_read1, $pipe_write1, $pipe_read2, $pipe_write2) ;

    pipe($pipe_read1, $pipe_write1) ;
    pipe($pipe_read2, $pipe_write2) ;
    my $pid= fork() ;
    if ($pid) {   # parent daemon
	close($pipe_read1) ;
	close($pipe_write2) ;

	# Set parent's pipes to be non-blocking.
	my $flags= fcntl($pipe_write1, F_GETFL, 0) or die "fcntl F_GETFL: $!\n";
	fcntl($pipe_write1, F_SETFL, $flags|O_NONBLOCK) or die "fcntl F_SETFL O_NONBLOCK: $!\n" ;
	$flags= fcntl($pipe_read2, F_GETFL, 0) or die "fcntl F_GETFL: $!\n";
	fcntl($pipe_read2, F_SETFL, $flags|O_NONBLOCK) or die "fcntl F_SETFL O_NONBLOCK: $!\n" ;

	select((select($pipe_write1), $|=1)[0]) ;   # make pipe autoflush output
	return { pid => $pid, pipe_to => $pipe_write1, pipe_from => $pipe_read2 } ;

    } else {   # new slave process
	close($pipe_read2) ;
	close($pipe_write1) ;
	close($LOCK_FH) ;     # slave processes shouldn't hold the lock
	select((select($pipe_write2), $|=1)[0]) ;   # make pipe autoflush output
	&handle_http_request($pipe_read1, $port, 0, $pipe_write2, 1) while 1 ;   # jsm-- need exit-- signal?
	exit ;
    }
}


# Given a "pipe" with an input buffer, determine if a complete HTTP message has been
#   transmitted.  Manage a buffer for each pipe.
sub message_is_complete {
    my($pipe)= @_ ;
    my $buf= $pipe->{buf} ;
    if (!$pipe->{got_headers}) {
	($headers, $buf)= split(/\015?\012\015?\012/, $buf, 2) ;
	return 0  unless defined $buf ;    # headers not fully read yet
	$pipe->{left}= $1  if $headers=~ /^Content-Length:[ \t]*(\d+)/mi ;
	$pipe->{chunked}= !$pipe->{left} && $headers=~ /^Transfer-Encoding:[ \t]*chunked\b/mi ;
	$pipe->{conn_close}= 1  if $headers=~ /^Connection:[ \t]*close\b/mi ;
	$pipe->{has_body}= $pipe->{left} or $pipe->{chunked} or $headers=~ /^Content-Type:/mi ;
	$pipe->{got_headers}= 1 ;
    }

    if (defined $pipe->{left}) {
	if ($pipe->{left}>length($buf)) {
	    $pipe->{left}-= length($buf) ;
	    $pipe->{buf}= '' ;
	    return 0 ;
	} else {
	    $pipe->{buf}= substr($buf, $pipe->{left}) ;
	    $pipe->{left}= 0 ;
	    $pipe->{got_headers}= 0 ;
	    return 1 ;
	}

    } elsif ($pipe->{chunked}) {
	if (defined $pipe->{left_in_chunk}) {
	    if ($pipe->{left_in_chunk}>length($buf)) {
		$pipe->{left_in_chunk}-= length($buf) ;
		$pipe->{buf}= '' ;
		return 0 ;
	    } else {
		pos($buf)= $pipe->{left_in_chunk} ;
		$pipe->{left_in_chunk}= 0 ;
	    }
	}

	my $csize ;
	while ($buf=~ /\G([\da-fA-F]+).*?\n/gc) {
	    $pipe->{buf}= substr($buf, pos($buf)), return 0  unless defined $1 ;
	    $csize= hex($1) ;

	    last if $csize==0 ;

	    if ($csize>length($buf)-pos($buf)) {
		$pipe->{left_in_chunk}= $csize-(length($buf)-pos($buf)) ;
		$pipe->{buf}= '' ;
		return 0 ;
	    } else {
		$pipe->{left_in_chunk}= 0 ;
		pos($buf)+= $csize ;
	    }
	}
	if ($buf=~ /\G^\015?\012/gcm) {   # jsm-- need to account for erroneously missing EOL at end of request
	    $pipe->{got_headers}= $pipe->{chunked}= $pipe->{left_in_chunk}= 0 ;  # jsm-- verify all are cleared correctly
	    $pipe->{buf}= substr($buf, pos($buf)) ;
	    return 1 ;
	} else {
	    $pipe->{buf}= substr($buf, pos($buf)) ;
	    return 0 ;
	}

    } elsif (!$pipe->{has_body}) {
	$pipe->{got_headers}= $pipe->{chunked}= $pipe->{left_in_chunk}= 0 ;
	$pipe->{buf}= $buf ;
	return 1 ;
    }
}

