#!/usr/bin/perl

BEGIN { @main::args = @ARGV ; }

use strict ;
use Getopt::Long ;
use IO::Select ;
use IO::Socket::UNIX ;
use IO::Socket::INET ;
use POSIX ;
use Sys::Syslog ;


$SIG{CHLD} = 'IGNORE' ;
$SIG{PIPE} = 'IGNORE' ;


my %opts = () ;
GetOptions(\%opts,
	"d",		# debug
) ;

sub usage {
	print STDERR "Usage: $0 [-d]\n" ;
	exit(1) ;
}

$Utils::DEBUG = 1 if $opts{d} ;

my $sockname = "/var/run/vservers/vproxy.sock" ;
do_tool_mode($sockname) if (scalar(@ARGV)) ;

# Open syslog
init_slog('vproxy') ;
slog('info', "$0 starting ($0 " . join(' ', @main::args) . ")") ;

# Setup the Unix domain control socket
if ((-e $sockname)&&(! unlink($sockname))){
	scroak("Can't unlink '$sockname': $!\n") ;
}
my $control = new IO::Socket::UNIX(
	Local => $sockname,
	Type => SOCK_STREAM,
	Listen => 5,
	Timeout => 5,
	Reuse => 1
) ;
scroak("Can't create UNIX socket '$sockname': $!\n") unless defined($control) ;
scroak("Can't chmod UNIX socket '$sockname': $!\n") unless chmod(0777, $sockname) ;


if (! $opts{d}){
	my $pid = fork() ;
	if (! defined($pid)){
		scroak("Can't fork: $!") ;
	}
	elsif ($pid != 0){
		exit(0) ;
	}
    POSIX::setsid() ;
    open(STDERR, ">/dev/null") or die("Error opening /dev/null: $!");
    open(STDOUT, ">/dev/null") or die("Error opening /dev/null: $!");
    open(STDIN, "</dev/null") or die("Error opening /dev/null: $!");
}


# Main loop
my %sockets = () ;
my $select = new IO::Select($control) ;
while (1){
	my @ready = $select->can_read() ;
	foreach my $fh (@ready){
		my $sock = $fh->accept() ;
		# Sometimes a signal can break the loop...
		next if !defined($sock) ;

		if ($fh eq $control){
			my $cmd = <$sock> ;
			chomp($cmd) ;
			my ($verb, @args) = split(/\s+/, $cmd) ;
			slog('info', "Command received on control socket: $verb " . join(' ', @args)) ;
			my $vserver = $args[0] ;
			my $vserver_root = $args[1] ;
			if ($verb eq 'start'){
				add_vserver($vserver, $vserver_root) ; 
			}
			elsif ($verb eq 'stop'){
				remove_vserver($vserver, $vserver_root) ; 
			}
			elsif ($verb eq 'status'){
				print $sock "OK: " . join(", ", keys %sockets) . "\n" ; 
			}
			else {
				slog('warn', "Invalid command received on control socket: $verb " . join(' ', @args)) ;
			}
			next ;
		}

		# We got a message on the client socket.
		my $vinfo = undef ;
		foreach my $v (keys %sockets){
			if ($sockets{$v}->{fh} eq $fh){
				$vinfo = $sockets{$v} ;
				last ;
			}
		}

		my $pid = fork() ;
		if (! defined($pid)){
			scroak("Can't fork: $!\n") ;
		}
		elsif ($pid == 0){
			close($control) ;
			$SIG{CHLD} = 'DEFAULT' ;

			scroak("Unknown socket '$fh' ?!") unless $vinfo ;
			my $cmd = <$sock> ;
			chomp($cmd) ;
			slog('info', "Command received on vserver $vinfo->{vserver} socket ($vinfo->{path}): $cmd") ;
			scroak("Invalid command '$cmd' from vserver $vinfo->{vserver}") unless $cmd =~ /^\w+$/ ;

			my $script = "/etc/vservers/$vinfo->{vserver}.sh" ;
			debug("Script is $script") ;
			if ((-f $script)&&(-x $script)){
				slog('info', "Executing $script '$cmd' '$vinfo->{vserver}' '$vinfo->{root}':") ;
				my $rc = open(SCRIPT, "$script '$cmd' '$vinfo->{vserver}' '$vinfo->{root}' 2>&1 |") ;
				while (<SCRIPT>){
					my $line = $_ ;
					chomp ($line) ;
					print $sock "$line\n" ;
					slog('info', "  $line") ;
				}
				slog('info', "Executed $script '$cmd' '$vinfo->{vserver}' '$vinfo->{root}': $?") ;
			}
			
			exit ;
		}
		else {
			slog('info', "Accepted connection from $vinfo->{vserver} and forked $pid") ;
		}
	}
}


sub add_vserver {
	my $vserver = shift ;
	my $vserver_root = shift ;

	# Setup the Unix domain socket
	my $sockname = "$vserver_root/dev/vproxy.sock" ;
	if ((-e $sockname)&&(! unlink($sockname))){
		slog('err', "Can't unlink '$sockname': $!\n") ;
	}

	my $sock = new IO::Socket::UNIX(
		Local => $sockname,
		Type => SOCK_STREAM,
		Listen => 5,
		Timeout => 5,
		Reuse => 1
	) ;

	if ($sock){
		slog('err', "Can't chmod UNIX socket '$sockname': $!\n") unless chmod(0777, $sockname) ;

		if ($sockets{$vserver}->{fh}){
			# Make sure previous socket (if any) is freed.
			$select->remove($sockets{$vserver}->{fh}) ;
		}
		$select->add($sock) ;
		$sockets{$vserver}->{vserver} = $vserver ;
		$sockets{$vserver}->{path} = $sockname ;
		$sockets{$vserver}->{root} = $vserver_root ;
		$sockets{$vserver}->{fh} = $sock ;
	}
	else {
		slog('err', "Can't create UNIX socket '$sockname': $!\n") ;
	}
}


sub remove_vserver {
	my $vserver = shift ;
	my $vserver_root = shift ;

	$select->remove($sockets{$vserver}->{fh}) ;
	delete $sockets{$vserver} ;

	# Setup the Unix domain socket
	my $sockname = "$vserver_root/dev/vproxy.sock" ;
	if ((-e $sockname)&&(! unlink($sockname))){
		slog('err', "Can't unlink '$sockname': $!\n") ;
	}
}


sub do_tool_mode {
	my $sockname = shift ;

	my ($cmd, @args) = @ARGV ;
	if (($cmd eq "send")&&(scalar(@args))){
		my $sock = new IO::Socket::UNIX(Peer => $sockname) ;
		die("Can't connect to $sockname: $!\n") unless $sock ;
		print $sock join(' ', @args) . "\n" ;
		while (<$sock>){
			print $_ ;
		}
		exit ;
	}
	die("Usage: $0 send CMD [ARG...]\n") ;
}



#################################################



$Utils::DEBUG = $ENV{DEBUG} ;


sub debug {
	my $msg = shift ;
	my $caller = shift || (caller())[0] ;

	if ($Utils::DEBUG){
		print STDERR "[$$] $caller: $msg\n" ;
	}
}


sub slog {
	my $level = shift ;
	my $msg = shift ;

	syslog($level, $msg) ;
	debug("[$level] $msg", (caller())[0]) ;
}


sub scroak {
    my $msg = shift ;

    slog("err", $msg) ;
    die($msg) ;
}


sub init_slog {
	my $name = shift ;

	Sys::Syslog::setlogsock('unix') ;
	openlog($name, 'pid', 'user') or die("Can't open syslog: $!") ;
}


1 ;