[OpenSPARC-T2-DV] / tools / perl-5.8.0 / lib / site_perl / 5.8.0 / Psh / OS / Unix.pm

package Psh::OS::Unix;

use strict;
require POSIX;
require Psh::Locale;

$Psh::OS::PATH_SEPARATOR=':';
$Psh::OS::FILE_SEPARATOR='/';

$Psh::history_file = ".psh_history";

# Sets the title of the current window
sub set_window_title {
	my $title= shift;
	my $term= $ENV{TERM};
	if( $term=~ /^(rxvt.*)|(xterm.*)|(.*xterm)|(kterm)|(aixterm)|(dtterm)/) {
		print "\017\033]2;$title\007";
	}
}

#
# Returns the hostname of the machine psh is running on, preferrably
# the full version
#

sub get_hostname {
	require Sys::Hostname;
	return Sys::Hostname::hostname();
}

sub getcwd_psh {
    my $cwd;
    chomp($cwd = `pwd`);
    $cwd;
}

#
# Returns a list of well-known hosts (from /etc/hosts)
#
sub get_known_hosts {
	my $hosts_file = "/etc/hosts"; # TODO: shouldn't be hard-coded?
	my @result=();
	local *F_KNOWNHOST;
	if (open(F_KNOWNHOST,"< $hosts_file")) {
		my $hosts_text = join ('', <F_KNOWNHOST>);
		close(F_KNOWNHOST);
		push @result,Psh::Util::parse_hosts_file($hosts_text);
	}
	my $tmp= catfile(Psh::OS::get_home_dir(),
					 '.ssh','known_hosts');
	if (-r $tmp) {
		if (open(F_KNOWNHOST, "< $tmp")) {
			while (<F_KNOWNHOST>) {
				chomp;
				next unless $_;
				if (/^([a-zA-Z].*?)\,/) {
					push @result, $1;
				}
			}
		}
	}
	if (!@result) {
		push @result,'localhost';
	}
	return @result;
}

#
# Returns a list of all users on the system, prepended with ~
#
{
	my @user_cache;
	sub get_all_users {
		unless (@user_cache) {
			CORE::setpwent;
			while (my ($name) = CORE::getpwent) {
				push(@user_cache,'~'.$name);
			}
			CORE::endpwent;
		}
		return @user_cache;
	}
}

#
# void display_pod(text)
#
sub display_pod {
	my $tmp= Psh::OS::tmpnam();
	my $text= shift;

	local *TMP;
	open( TMP,">$tmp");
	print TMP $text;
	close(TMP);

	eval {
		require Pod::Text;
		Pod::Text::pod2text($tmp,*STDOUT);
	};
	Psh::Util::print_debug_class('e',"Error: $@") if $@;
	print $text if $@;

	unlink($tmp);
}

sub get_home_dir {
	my $user = shift || $ENV{USER};
	return $ENV{HOME} if ((! $user) && (-d $ENV{HOME}));
	return (CORE::getpwnam($user))[7]||'';
}

sub get_rc_files {
	my @rc=();

	if (-r '/etc/pshrc') {
		push @rc, '/etc/pshrc';
	}
	my $home= Psh::OS::get_home_dir();
	if ($home) { push @rc, catfile($home,'.pshrc') };
	return @rc;
}

sub get_path_extension { return (''); }

#
# int inc_shlvl ()
#
# Increments $ENV{SHLVL}. Also checks for login shell status and does
# appropriate OS-specific tasks depending on it.
#
sub inc_shlvl {
	my @pwent = CORE::getpwuid($<);
	if ((! $ENV{SHLVL}) && ($pwent[8] eq $0)) { # would use $Psh::bin, but login shells are guaranteed full paths
		$Psh::login_shell = 1;
		$ENV{SHLVL} = 1;
	} else {
		$Psh::login_shell = 0;
		$ENV{SHLVL}++;
	}
}


###################################################################
# JOB CONTROL
###################################################################


#
# void _give_terminal_to (int PID)
#
# Make pid the foreground process of the terminal controlling STDIN.
#

{
	my $terminal_owner=0;

	sub _give_terminal_to
    {
		# If a fork of a psh fork tries to call this then exit
		# as it would probably mess up the shell
		# This hack is necessary as e.g.
		# alias ls=/bin/ls
		# ls &
		# call fork_process from within a fork

		return if $Psh::OS::Unix::forked_already;
		return if $terminal_owner==$_[0];
		$terminal_owner=$_[0];

		local $SIG{TSTP}  = 'IGNORE';
		local $SIG{TTIN}  = 'IGNORE';
		local $SIG{TTOU}  = 'IGNORE';
		local $SIG{CHLD}  = 'IGNORE';

		my ($pkg,$file,$line,$sub)= caller(1);
		my $status= POSIX::tcsetpgrp(fileno STDIN,$_[0]);
	}

	sub _get_terminal_owner
    {
		return $terminal_owner;
	}
}


#
# void _wait_for_system(int PID, [bool QUIET_EXIT], [bool NO_TERMINAL])
#
# Waits for a program to be stopped/ended, prints no message on normal
# termination if QUIET_EXIT is specified and true.
#
# If NO_TERMINAL is specified and true it won't try to transfer
# terminal ownership
#

sub _wait_for_system
{
	my($pid, $quiet) = @_;
	if (!defined($quiet)) { $quiet = 0; }

	my $psh_pgrp = CORE::getpgrp();

	my $pid_status = -1;

	my $job= Psh::Joblist::get_job($pid);

	return if ! $job;

	my $term_pid= $job->{pgrp_leader}||$pid;

	_give_terminal_to($term_pid);

	my $output='';
	my $status=1;
	my $returnpid;
	while (1) {
		if (!$job->{running}) { $job->continue; }
		{
			local $Psh::currently_active = $pid;
			$returnpid = CORE::waitpid($pid,POSIX::WUNTRACED());
			$pid_status = $?;
		}
		last if $returnpid<1;

		# Very ugly work around for the problem that
		# processes occasionally get SIGTTOUed without reason
		# We can do this here because we know the process has
		# to run and could not have been stopped by TTOU
		if ($returnpid== $pid &&
			POSIX::WIFSTOPPED($pid_status) &&
			Psh::OS::signal_name(POSIX::WSTOPSIG($pid_status)) eq 'TTOU') {
			$job->continue;
			next;
		}
		# Collect output here - we cannot print it while another
		# process might possibly be in the foreground;
		$output.=_handle_wait_status($returnpid, $pid_status, $quiet, 1);
		if ($returnpid == $pid) {
			$status=POSIX::WEXITSTATUS($pid_status);
			last;
		}
	}
	_give_terminal_to($psh_pgrp);
	Psh::Util::print_out($output) if length($output);
	return $status==0;
}

#
# void _handle_wait_status(int PID, int STATUS, bool QUIET_EXIT)
#
# Take the appropriate action given that waiting on PID returned
# STATUS. Normal termination is not reported if QUIET_EXIT is true.
#

sub _handle_wait_status {
	my ($pid, $pid_status, $quiet, $collect) = @_;
	# Have to obtain these before we potentially delete the job
	my $job= Psh::Joblist::get_job($pid);
	my $command = $job->{call};
	my $visindex= Psh::Joblist::get_job_number($pid);
	my $verb='';

	if (POSIX::WIFEXITED($pid_status)) {
		my $status= POSIX::WEXITSTATUS($pid_status);
		if ($status==0) {
			$verb= ucfirst(Psh::Locale::get_text('done')) unless $quiet;
		} else {
			$verb= ucfirst(Psh::Locale::get_text('error'));
		}
		Psh::Joblist::delete_job($pid);
	} elsif (POSIX::WIFSIGNALED($pid_status)) {
		my $tmp= Psh::Locale::get_text('terminated');
		$verb = "\u$tmp (" .
			Psh::OS::signal_description(POSIX::WTERMSIG($pid_status)) . ')';
		Psh::Joblist::delete_job($pid);
	} elsif (POSIX::WIFSTOPPED($pid_status)) {
		my $tmp= Psh::Locale::get_text('stopped');
		$verb = "\u$tmp (" .
			Psh::OS::signal_description(POSIX::WSTOPSIG($pid_status)) . ')';
		$job->{running}= 0;
	}
	if ($verb && $visindex>0) {
		my $line="[$visindex] $verb $pid $command\n";
		return $line if $collect;

		Psh::Util::print_out($line );
	}
	return '';
}


#
# void reap_children()
#
# Checks wether any children we spawned died
#

sub reap_children
{
	my $returnpid=0;
	while (($returnpid = CORE::waitpid(-1, POSIX::WNOHANG() |
									   POSIX::WUNTRACED())) > 0) {
		_handle_wait_status($returnpid, $?);
	}
}

sub execute_complex_command {
	my @array= @{shift()};
	my $fgflag= shift @array;
	my @return_val;
	my $success= 0;
	my $eval_thingie;
	my $pgrp_leader= 0;
	my $pid;
	my $string='';
	my @tmp;

	my ($read,$chainout,$chainin);

	for( my $i=0; $i<@array; $i++) {
		# ([ $strat, $how, \@options, \@words, $line]);
		my ($strategy, $how, $options, $words, $text, $opt)= @{$array[$i]};
		local $Psh::current_options= $opt;
		$text||='';

		my $line= join(' ',@$words);
		my $forcefork;
		($success, $eval_thingie,$words,$forcefork, @return_val)= $strategy->execute( \$line, $words, $how, $i>0);

		$forcefork||=$i<$#array;

		if( defined($eval_thingie)) {
  			if( $#array) {
  				($read,$chainout)= POSIX::pipe();
  			}
			foreach (@$options) {
				if ($_->[0]==Psh::Parser::T_REDIRECT() and
				    ($_->[1] eq '<&' or $_->[1] eq '>&')) {
					if ($_->[3] eq 'chainin') {
						$_->[3]= $chainin;
					} elsif ($_->[3] eq 'chainout') {
						$_->[3]= $chainout;
					}
				}
			}
			my $termflag=!($i==$#array);

			($pid,$success,@tmp)= _fork_process($eval_thingie,$words,
												$fgflag,$text,$options,
												$pgrp_leader,$termflag,
												$forcefork);

			if( !$i && !$pgrp_leader) {
				$pgrp_leader=$pid;
			}

  			if( $i<$#array && $#array) {
  				POSIX::close($chainout);
  				$chainin= $read;
  			}
			if( @return_val < 1 ||
				!defined($return_val[0])) {
				@return_val= @tmp;
			}
		}
		$string.='|' if $i>0;
		$string.=$text;
	}

	if( $pid) {
		my $job= Psh::Joblist::create_job($pid,$string);
		$job->{pgrp_leader}=$pgrp_leader;
		if( $fgflag) {
			$success=_wait_for_system($pid, 1);
		} else {
			my $visindex= Psh::Joblist::get_job_number($job->{pid});
			Psh::Util::print_out("[$visindex] Background $pgrp_leader $string\n");
		}
	}
	return ($success,\@return_val);
}

sub _setup_redirects {
	my $options= shift;
	my $save= shift;

	return [] if ref $options ne 'ARRAY';

	my @cache=();
	foreach my $option (@$options) {
		if( $option->[0] == Psh::Parser::T_REDIRECT()) {
			my $type= $option->[2];
			my $cachefileno;

			if ($option->[1] eq '<&') {
				POSIX::dup2($option->[3], $type);
			} elsif ($option->[1] eq '>&') {
				POSIX::dup2($option->[3], $type);
			} elsif ($option->[1] eq '<') {
				my $tmpfd= POSIX::open( $option->[3], &POSIX::O_RDONLY);
				POSIX::dup2($tmpfd, $type);
				POSIX::close($tmpfd);
			} elsif ($option->[1] eq '>') {
				my $tmpfd= POSIX::open( $option->[3], &POSIX::O_WRONLY |
										&POSIX::O_TRUNC | &POSIX::O_CREAT );
				POSIX::dup2($tmpfd, $type);
				POSIX::close($tmpfd);
			} elsif ($option->[1] eq '>>') {
				my $tmpfd= POSIX::open( $option->[3], &POSIX::O_WRONLY |
									   &POSIX::O_CREAT);
				POSIX::lseek($tmpfd,0, &POSIX::SEEK_END);
				POSIX::dup2($tmpfd, $type);
				POSIX::close($tmpfd);
			}
			if ($^F<$type) { # preserve filedescriptors higher than 2
				$^F=$type;
			}
		}
	}
	select(STDOUT);
	return \@cache;
}

sub _has_redirects {
	my $options= shift;
	return 0 if ref $options ne 'ARRAY';

	foreach my $option (@$options) {
		return 1 if( $option->[0] == Psh::Parser::T_REDIRECT());
	}
	return 0;
}

#
# void fork_process( code|program, words,
#                    int fgflag, text to display in jobs,
#                    redirection options,
#                    pid of pgroupleader, do not set terminal flag,
#                    force a fork?)
#

sub _fork_process {
    my( $code, $words, $fgflag, $string, $options,
		$pgrp_leader, $termflag, $forcefork) = @_;
	my($pid);

	# HACK - if it's foreground code AND perl code AND
	# there are no redirects
	# we do not fork, otherwise we'll never get
	# the result value, changed variables etc.
	if( $fgflag and !$forcefork and ref($code) eq 'CODE'
		and !_has_redirects($options)
	  ) {
		my @result= eval { &$code };
		Psh::Util::print_error($@) if $@ && $@ !~/^SECRET/;
		return (0,@result);
	}

	unless ($pid = fork) { #child
		unless (defined $pid) {
			Psh::Util::print_error_i18n('fork_failed');
			return (-1,0,undef);
		}

		$Psh::OS::Unix::forked_already=1;
		close(READ) if( $pgrp_leader);
		_setup_redirects($options,0);
		POSIX::setpgid(0,$pgrp_leader||$$);
		_give_terminal_to($pgrp_leader||$$) if $fgflag && !$termflag;
		remove_signal_handlers();

		if( ref($code) eq 'CODE') {
			my @tmp=&{$code};
			if (!@tmp or $tmp[0]) {
				CORE::exit(0);
			}
			CORE::exit(1);
		} else {
			{
				if( ! ref $options) {
					exec $code;
				} else {
					$code= shift @$words;
					exec { $code } @$words;
				}
			} # Avoid unreachable warning
			Psh::Util::print_error_i18n('exec_failed',$code);
			CORE::exit(-1);
		}
	}
	POSIX::setpgid($pid,$pgrp_leader||$pid);
	_give_terminal_to($pgrp_leader||$pid) if $fgflag && !$termflag;
	return ($pid,0,undef);
}

sub fork_process {
    my( $code, $fgflag, $string, $options) = @_;
	my ($pid,$sucess,@result)= _fork_process($code,undef,$fgflag,$string,$options);
	return @result if !$pid;
	my $job= Psh::Joblist::create_job($pid,$string);
	if( !$fgflag) {
		my $visindex= Psh::Joblist::get_job_number($job->{pid});
		Psh::Util::print_out("[$visindex] Background $pid $string\n");
	}
	_wait_for_system($pid, 1) if $fgflag;
	return undef;
}

#
# Returns true if the system has job_control abilities
#
sub has_job_control { return 1; }

#
# void restart_job(bool FOREGROUND, int JOB_INDEX)
#
sub restart_job
{
	my ($fg_flag, $job_to_start) = @_;

	my $job= Psh::Joblist::find_job($job_to_start);

	if(defined($job)) {
		my $pid = $job->{pid};
		my $command = $job->{call};

		if ($command) {
			my $verb;
			my $qRunning = $job->{running};

			if ($fg_flag) {
				$verb= ucfirst(Psh::Locale::get_text('foreground'));
			} elsif ($qRunning) {
				# bg request, and it's already running:
				return;
			} else {
				$verb= ucfirst(Psh::Locale::get_text('restart'));
			}
			my $visindex = Psh::Joblist::get_job_number($pid);
			Psh::Util::print_out("[$visindex] $verb $pid $command\n");

			if($fg_flag) {
				eval { _wait_for_system($pid, 0); };
				Psh::Util::print_debug_class('e',"Error: $@") if $@;
			} elsif( !$qRunning) {
				$job->continue;
			}
		}
	}
}

sub resume_job {
	my $job= shift;

	kill 'CONT', -$job->{pid};
	kill 'CONT', -$job->{pgrp_leader} if $job->{pgrp_leader};
}

# Simply doing backtick eval - mainly for Prompt evaluation
sub backtick {
	my $com=join ' ',@_;
	local $^F=50;
	my ($read,$write)= POSIX::pipe();

	unless(my $pid=fork) {
		POSIX::close($read);
		POSIX::dup2($write,fileno(*STDOUT));
		$^F=$write if ($write>$^F);
		my ($success)= Psh::evl($com);
		CORE::exit(!$success);
	}
	POSIX::close($write);
	my $result='';
	local(*READ);
	open(READ,"<&=$read");
	while(<READ>) {
		$result.=$_;
	}
	close(READ);
	return $result;
}

###################################################################
# SIGNALS
###################################################################

# Setup special treatment of certain signals
# Having a value of 0 means to ignore the signal completely in
# the loops while a code ref installs a different default
# handler. Note that calling _ignore_handler is different than
# setting the signal action to ignore - if you set the signal
# action to ignore, the signal might be passed on to parent processes
# which could decide to handle them for us

my %special_handlers= (
					   'CHLD' => \&_ignore_handler,
					   'CLD'  => \&_ignore_handler,
					   'TTOU' => \&_ttou_handler,
					   'TTIN' => \&_ttou_handler,
					   'TERM' => \&Psh::OS::fb_exit_psh,
					   'HUP'  => \&Psh::OS::fb_exit_psh,
					   'SEGV' => 0,
					   'WINCH'=> 0,
					   'ZERO' => 0,
					   );

my @signals= grep { substr($_,0,1) ne '_' } keys %SIG;

#
# void remove_signal_handlers()
#
# This used to manually set INT, QUIT, CONT, STOP, TSTP, TTIN,
# TTOU, and CHLD.
#
# The new technique changes the settings of *all* signals. It is
# from Recipe 16.13 of The Perl Cookbook (Page 582). It should be
# compatible with Perl 5.004 and later.
#

sub remove_signal_handlers
{
	foreach my $sig (@signals) {
		next if exists($special_handlers{$sig}) &&
			! ref($special_handlers{$sig});
		$SIG{$sig} = 'DEFAULT';
	}
}

#
# void setup_signal_handlers
#
# This used to manually set INT, QUIT, CONT, STOP, TSTP, TTIN,
# TTOU, and CHLD.
#
# See comment for remove_signal_handlers() for more information.
#

sub setup_signal_handlers
{
	foreach my $sig (@signals) {
		if( exists($special_handlers{$sig})) {
			if( ref($special_handlers{$sig})) {
				$SIG{$sig}= $special_handlers{$sig};
			}
			next;
		}
		$SIG{$sig} = \&_signal_handler;
	}

	reinstall_resize_handler();
}


#
# Setup the SIGSEGV handler
#
sub setup_sigsegv_handler
{
	$SIG{SEGV} = \&_error_handler;
}

#
# Setup SIGINT handler for readline
#
sub setup_readline_handler
{
	$SIG{INT}= \&_readline_handler;
}

sub remove_readline_handler
{
	$SIG{INT}= \&_signal_handler;
}

sub reinstall_resize_handler
{
	Psh::OS::fb_reinstall_resize_handler();
	&_resize_handler('WINCH');
}


#
# readline_handler()
#
# Readline ^C handler.
#

sub _readline_handler
{
	my $sig= shift;
	setup_readline_handler();
	print "\n"; # Clean up the display
	die "SECRET $Psh::bin: Signal $sig\n"; # changed to SECRET... just in case
}

sub _ttou_handler
{
	_give_terminal_to($$);
}

#
# void _signal_handler( string SIGNAL )
#

sub _signal_handler
{
	my ($sig) = @_;

	if ($Psh::currently_active > 0) {
		Psh::Util::print_debug("Received signal SIG$sig, sending to $Psh::currently_active\n");

		kill $sig, -$Psh::currently_active;
	} elsif ($Psh::currently_active < 0) {
		Psh::Util::print_debug("Received signal SIG$sig, sending to Perl code\n");
		die "SECRET ${Psh::bin}: Signal $sig\n";
	} else {
		_give_terminal_to($$);
		Psh::Util::print_debug("Received signal SIG$sig, die-ing\n");
		die "SECRET ${Psh::bin}: Signal $sig\n" if $sig eq 'INT';
	}

	$SIG{$sig} = \&_signal_handler;
}


#
# ignore_handler()
#

sub _ignore_handler
{
}


sub _error_handler
{
	my ($sig) = @_;
	Psh::Util::print_error_i18n('unix_received_strange_sig',$sig);
	kill 'INT', $$; # HACK to stop a possible endless loop!
}

#
# _resize_handler()
#

sub _resize_handler
{
	my ($sig) = @_;

	Psh::OS::check_terminal_size();

	$SIG{$sig} = \&_resize_handler;
}

{
	my $debian=-1;
	sub _check_debian {
		if ($debian==-1) {
			if (-r '/etc/debian-version') {
				$debian=1;
			} else {
				$debian=0;
			}
		}
		return $debian;
	}
}

sub get_editor {
	my $file= shift;
	my $suggestion= shift;
	my $editor= $suggestion||$ENV{VISUAL}||$ENV{EDITOR};
	if (_check_debian()) {
		$editor ||='editor';
	} else {
		$editor ||='vi';
	}
	return $editor;
}

# File::Spec

sub canonpath {
    my ($path) = @_;
    $path =~ s|/+|/|g unless($^O eq 'cygwin');     # xx////xx  -> xx/xx
    $path =~ s|(/\.)+/|/|g;                        # xx/././xx -> xx/xx
    $path =~ s|^(\./)+||s unless $path eq "./";    # ./xx      -> xx
    $path =~ s|^/(\.\./)+|/|s;                     # /../../xx -> xx
    $path =~ s|/\Z(?!\n)|| unless $path eq "/";          # xx/       -> xx
    return $path;
}

sub catfile {
    my $file = pop @_;
    return $file unless @_;
    my $dir = catdir(@_);
    $dir .= "/" unless substr($dir,-1) eq "/";
    return $dir.$file;
}

sub catdir {
    my @args = @_;
    foreach (@args) {
        # append a slash to each argument unless it has one there
        $_ .= "/" if $_ eq '' || substr($_,-1) ne "/";
    }
    return canonpath(join('', @args));
}

sub file_name_is_absolute {
	my $file= shift;
	return scalar($file =~ m:^/:s);
}

sub rootdir {
	'/';
}

sub splitdir {
    my ($directories) = @_ ;

    if ( $directories !~ m|/\Z(?!\n)| ) {
        return split( m|/|, $directories );
    }
    else {
        my( @directories )= split( m|/|, "${directories}dummy" ) ;
        $directories[ $#directories ]= '' ;
        return @directories ;
    }
}

sub rel2abs {
    my ($path,$base ) = @_;
 
    # Clean up $path
    if ( ! file_name_is_absolute( $path ) ) {
        # Figure out the effective $base and clean it up.
        if ( !defined( $base ) || $base eq '' ) {
            $base = Psh::getcwd_psh() ;
        }
        elsif ( ! file_name_is_absolute( $base ) ) {
            $base = rel2abs( $base ) ;
        }
        else {
            $base = canonpath( $base ) ;
        }
 
        # Glom them together
        $path = catdir( $base, $path ) ;
    }
 
    return canonpath( $path ) ;
}

1;

__END__
Commit	Line	Data
86530b38 AT	1	package Psh::OS::Unix;
	2
	3	use strict;
	4	require POSIX;
	5	require Psh::Locale;
	6
	7	$Psh::OS::PATH_SEPARATOR=':';
	8	$Psh::OS::FILE_SEPARATOR='/';
	9
	10	$Psh::history_file = ".psh_history";
	11
	12	# Sets the title of the current window
	13	sub set_window_title {
	14	my $title= shift;
	15	my $term= $ENV{TERM};
	16	if( $term=~ /^(rxvt.)\|(xterm.)\|(.*xterm)\|(kterm)\|(aixterm)\|(dtterm)/) {
	17	print "\017\033]2;$title\007";
	18	}
	19	}
	20
	21	#
	22	# Returns the hostname of the machine psh is running on, preferrably
	23	# the full version
	24	#
	25
	26	sub get_hostname {
	27	require Sys::Hostname;
	28	return Sys::Hostname::hostname();
	29	}
	30
	31	sub getcwd_psh {
	32	my $cwd;
	33	chomp($cwd = `pwd`);
	34	$cwd;
	35	}
	36
	37	#
	38	# Returns a list of well-known hosts (from /etc/hosts)
	39	#
	40	sub get_known_hosts {
	41	my $hosts_file = "/etc/hosts"; # TODO: shouldn't be hard-coded?
	42	my @result=();
	43	local *F_KNOWNHOST;
	44	if (open(F_KNOWNHOST,"< $hosts_file")) {
	45	my $hosts_text = join ('', <F_KNOWNHOST>);
	46	close(F_KNOWNHOST);
	47	push @result,Psh::Util::parse_hosts_file($hosts_text);
	48	}
	49	my $tmp= catfile(Psh::OS::get_home_dir(),
	50	'.ssh','known_hosts');
	51	if (-r $tmp) {
	52	if (open(F_KNOWNHOST, "< $tmp")) {
	53	while (<F_KNOWNHOST>) {
	54	chomp;
	55	next unless $_;
	56	if (/^([a-zA-Z].*?)\,/) {
	57	push @result, $1;
	58	}
	59	}
	60	}
	61	}
	62	if (!@result) {
	63	push @result,'localhost';
	64	}
65	return @result;
66	}
67
68	#
69	# Returns a list of all users on the system, prepended with ~
70	#
71	{
72	my @user_cache;
73	sub get_all_users {
74	unless (@user_cache) {
75	CORE::setpwent;
76	while (my ($name) = CORE::getpwent) {
77	push(@user_cache,'~'.$name);
78	}
79	CORE::endpwent;
80	}
81	return @user_cache;
82	}
83	}
84
85	#
86	# void display_pod(text)
87	#
88	sub display_pod {
89	my $tmp= Psh::OS::tmpnam();
90	my $text= shift;
91
92	local *TMP;
93	open( TMP,">$tmp");
94	print TMP $text;
95	close(TMP);
96
97	eval {
98	require Pod::Text;
99	Pod::Text::pod2text($tmp,*STDOUT);
100	};
101	Psh::Util::print_debug_class('e',"Error: $@") if $@;
102	print $text if $@;
103
104	unlink($tmp);
105	}
106
107	sub get_home_dir {
108	my $user = shift \|\| $ENV{USER};
109	return $ENV{HOME} if ((! $user) && (-d $ENV{HOME}));
110	return (CORE::getpwnam($user))[7]\|\|'';
111	}
112
113	sub get_rc_files {
114	my @rc=();
115
116	if (-r '/etc/pshrc') {
117	push @rc, '/etc/pshrc';
118	}
119	my $home= Psh::OS::get_home_dir();
120	if ($home) { push @rc, catfile($home,'.pshrc') };
121	return @rc;
122	}
123
124	sub get_path_extension { return (''); }
125
126	#
127	# int inc_shlvl ()
128	#
129	# Increments $ENV{SHLVL}. Also checks for login shell status and does
130	# appropriate OS-specific tasks depending on it.
131	#
132	sub inc_shlvl {
133	my @pwent = CORE::getpwuid($<);
134	if ((! $ENV{SHLVL}) && ($pwent[8] eq $0)) { # would use $Psh::bin, but login shells are guaranteed full paths
135	$Psh::login_shell = 1;
136	$ENV{SHLVL} = 1;
137	} else {
138	$Psh::login_shell = 0;
139	$ENV{SHLVL}++;
140	}
141	}
142
143
144	###################################################################
145	# JOB CONTROL
146	###################################################################
147
148
149	#
150	# void _give_terminal_to (int PID)
151	#
152	# Make pid the foreground process of the terminal controlling STDIN.
153	#
154
155	{
156	my $terminal_owner=0;
157
158	sub _give_terminal_to
159	{
160	# If a fork of a psh fork tries to call this then exit
161	# as it would probably mess up the shell
162	# This hack is necessary as e.g.
163	# alias ls=/bin/ls
164	# ls &
165	# call fork_process from within a fork
166
167	return if $Psh::OS::Unix::forked_already;
168	return if $terminal_owner==$_[0];
169	$terminal_owner=$_[0];
170
171	local $SIG{TSTP} = 'IGNORE';
172	local $SIG{TTIN} = 'IGNORE';
173	local $SIG{TTOU} = 'IGNORE';
174	local $SIG{CHLD} = 'IGNORE';
175
176	my ($pkg,$file,$line,$sub)= caller(1);
177	my $status= POSIX::tcsetpgrp(fileno STDIN,$_[0]);
178	}
179
180	sub _get_terminal_owner
181	{
182	return $terminal_owner;
183	}
184	}
185
186
187
188	#
189	# void _wait_for_system(int PID, [bool QUIET_EXIT], [bool NO_TERMINAL])
190	#
191	# Waits for a program to be stopped/ended, prints no message on normal
192	# termination if QUIET_EXIT is specified and true.
193	#
194	# If NO_TERMINAL is specified and true it won't try to transfer
195	# terminal ownership
196	#
197
198	sub _wait_for_system
199	{
200	my($pid, $quiet) = @_;
201	if (!defined($quiet)) { $quiet = 0; }
202
203	my $psh_pgrp = CORE::getpgrp();
204
205	my $pid_status = -1;
206
207	my $job= Psh::Joblist::get_job($pid);
208
209	return if ! $job;
210
211	my $term_pid= $job->{pgrp_leader}\|\|$pid;
212
213	_give_terminal_to($term_pid);
214
215	my $output='';
216	my $status=1;
217	my $returnpid;
218	while (1) {
219	if (!$job->{running}) { $job->continue; }
220	{
221	local $Psh::currently_active = $pid;
222	$returnpid = CORE::waitpid($pid,POSIX::WUNTRACED());
223	$pid_status = $?;
224	}
225	last if $returnpid<1;
226
227	# Very ugly work around for the problem that
228	# processes occasionally get SIGTTOUed without reason
229	# We can do this here because we know the process has
230	# to run and could not have been stopped by TTOU
231	if ($returnpid== $pid &&
232	POSIX::WIFSTOPPED($pid_status) &&
233	Psh::OS::signal_name(POSIX::WSTOPSIG($pid_status)) eq 'TTOU') {
234	$job->continue;
235	next;
236	}
237	# Collect output here - we cannot print it while another
238	# process might possibly be in the foreground;
239	$output.=_handle_wait_status($returnpid, $pid_status, $quiet, 1);
240	if ($returnpid == $pid) {
241	$status=POSIX::WEXITSTATUS($pid_status);
242	last;
243	}
244	}
245	_give_terminal_to($psh_pgrp);
246	Psh::Util::print_out($output) if length($output);
247	return $status==0;
248	}
249
250	#
251	# void _handle_wait_status(int PID, int STATUS, bool QUIET_EXIT)
252	#
253	# Take the appropriate action given that waiting on PID returned
254	# STATUS. Normal termination is not reported if QUIET_EXIT is true.
255	#
256
257	sub _handle_wait_status {
258	my ($pid, $pid_status, $quiet, $collect) = @_;
259	# Have to obtain these before we potentially delete the job
260	my $job= Psh::Joblist::get_job($pid);
261	my $command = $job->{call};
262	my $visindex= Psh::Joblist::get_job_number($pid);
263	my $verb='';
264
265	if (POSIX::WIFEXITED($pid_status)) {
266	my $status= POSIX::WEXITSTATUS($pid_status);
267	if ($status==0) {
268	$verb= ucfirst(Psh::Locale::get_text('done')) unless $quiet;
269	} else {
270	$verb= ucfirst(Psh::Locale::get_text('error'));
271	}
272	Psh::Joblist::delete_job($pid);
273	} elsif (POSIX::WIFSIGNALED($pid_status)) {
274	my $tmp= Psh::Locale::get_text('terminated');
275	$verb = "\u$tmp (" .
276	Psh::OS::signal_description(POSIX::WTERMSIG($pid_status)) . ')';
277	Psh::Joblist::delete_job($pid);
278	} elsif (POSIX::WIFSTOPPED($pid_status)) {
279	my $tmp= Psh::Locale::get_text('stopped');
280	$verb = "\u$tmp (" .
281	Psh::OS::signal_description(POSIX::WSTOPSIG($pid_status)) . ')';
282	$job->{running}= 0;
283	}
284	if ($verb && $visindex>0) {
285	my $line="[$visindex] $verb $pid $command\n";
286	return $line if $collect;
287
288	Psh::Util::print_out($line );
289	}
290	return '';
291	}
292
293
294	#
295	# void reap_children()
296	#
297	# Checks wether any children we spawned died
298	#
299
300	sub reap_children
301	{
302	my $returnpid=0;
303	while (($returnpid = CORE::waitpid(-1, POSIX::WNOHANG() \|
304	POSIX::WUNTRACED())) > 0) {
305	_handle_wait_status($returnpid, $?);
306	}
307	}
308
309	sub execute_complex_command {
310	my @array= @{shift()};
311	my $fgflag= shift @array;
312	my @return_val;
313	my $success= 0;
314	my $eval_thingie;
315	my $pgrp_leader= 0;
316	my $pid;
317	my $string='';
318	my @tmp;
319
320	my ($read,$chainout,$chainin);
321
322	for( my $i=0; $i<@array; $i++) {
323	# ([ $strat, $how, \@options, \@words, $line]);
324	my ($strategy, $how, $options, $words, $text, $opt)= @{$array[$i]};
325	local $Psh::current_options= $opt;
326	$text\|\|='';
327
328	my $line= join(' ',@$words);
329	my $forcefork;
330	($success, $eval_thingie,$words,$forcefork, @return_val)= $strategy->execute( \$line, $words, $how, $i>0);
331
332	$forcefork\|\|=$i<$#array;
333
334	if( defined($eval_thingie)) {
335	if( $#array) {
336	($read,$chainout)= POSIX::pipe();
337	}
338	foreach (@$options) {
339	if ($_->[0]==Psh::Parser::T_REDIRECT() and
340	($_->[1] eq '<&' or $_->[1] eq '>&')) {
341	if ($_->[3] eq 'chainin') {
342	$_->[3]= $chainin;
343	} elsif ($_->[3] eq 'chainout') {
344	$_->[3]= $chainout;
345	}
346	}
347	}
348	my $termflag=!($i==$#array);
349
350	($pid,$success,@tmp)= _fork_process($eval_thingie,$words,
351	$fgflag,$text,$options,
352	$pgrp_leader,$termflag,
353	$forcefork);
354
355	if( !$i && !$pgrp_leader) {
356	$pgrp_leader=$pid;
357	}
358
359	if( $i<$#array && $#array) {
360	POSIX::close($chainout);
361	$chainin= $read;
362	}
363	if( @return_val < 1 \|\|
364	!defined($return_val[0])) {
365	@return_val= @tmp;
366	}
367	}
368	$string.='\|' if $i>0;
369	$string.=$text;
370	}
371
372	if( $pid) {
373	my $job= Psh::Joblist::create_job($pid,$string);
374	$job->{pgrp_leader}=$pgrp_leader;
375	if( $fgflag) {
376	$success=_wait_for_system($pid, 1);
377	} else {
378	my $visindex= Psh::Joblist::get_job_number($job->{pid});
379	Psh::Util::print_out("[$visindex] Background $pgrp_leader $string\n");
380	}
381	}
382	return ($success,\@return_val);
383	}
384
385	sub _setup_redirects {
386	my $options= shift;
387	my $save= shift;
388
389	return [] if ref $options ne 'ARRAY';
390
391	my @cache=();
392	foreach my $option (@$options) {
393	if( $option->[0] == Psh::Parser::T_REDIRECT()) {
394	my $type= $option->[2];
395	my $cachefileno;
396
397	if ($option->[1] eq '<&') {
398	POSIX::dup2($option->[3], $type);
399	} elsif ($option->[1] eq '>&') {
400	POSIX::dup2($option->[3], $type);
401	} elsif ($option->[1] eq '<') {
402	my $tmpfd= POSIX::open( $option->[3], &POSIX::O_RDONLY);
403	POSIX::dup2($tmpfd, $type);
404	POSIX::close($tmpfd);
405	} elsif ($option->[1] eq '>') {
406	my $tmpfd= POSIX::open( $option->[3], &POSIX::O_WRONLY \|
407	&POSIX::O_TRUNC \| &POSIX::O_CREAT );
408	POSIX::dup2($tmpfd, $type);
409	POSIX::close($tmpfd);
410	} elsif ($option->[1] eq '>>') {
411	my $tmpfd= POSIX::open( $option->[3], &POSIX::O_WRONLY \|
412	&POSIX::O_CREAT);
413	POSIX::lseek($tmpfd,0, &POSIX::SEEK_END);
414	POSIX::dup2($tmpfd, $type);
415	POSIX::close($tmpfd);
416	}
417	if ($^F<$type) { # preserve filedescriptors higher than 2
418	$^F=$type;
419	}
420	}
421	}
422	select(STDOUT);
423	return \@cache;
424	}
425
426	sub _has_redirects {
427	my $options= shift;
428	return 0 if ref $options ne 'ARRAY';
429
430	foreach my $option (@$options) {
431	return 1 if( $option->[0] == Psh::Parser::T_REDIRECT());
432	}
433	return 0;
434	}
435
436	#
437	# void fork_process( code\|program, words,
438	# int fgflag, text to display in jobs,
439	# redirection options,
440	# pid of pgroupleader, do not set terminal flag,
441	# force a fork?)
442	#
443
444	sub _fork_process {
445	my( $code, $words, $fgflag, $string, $options,
446	$pgrp_leader, $termflag, $forcefork) = @_;
447	my($pid);
448
449	# HACK - if it's foreground code AND perl code AND
450	# there are no redirects
451	# we do not fork, otherwise we'll never get
452	# the result value, changed variables etc.
453	if( $fgflag and !$forcefork and ref($code) eq 'CODE'
454	and !_has_redirects($options)
455	) {
456	my @result= eval { &$code };
457	Psh::Util::print_error($@) if $@ && $@ !~/^SECRET/;
458	return (0,@result);
459	}
460
461	unless ($pid = fork) { #child
462	unless (defined $pid) {
463	Psh::Util::print_error_i18n('fork_failed');
464	return (-1,0,undef);
465	}
466
467	$Psh::OS::Unix::forked_already=1;
468	close(READ) if( $pgrp_leader);
469	_setup_redirects($options,0);
470	POSIX::setpgid(0,$pgrp_leader\|\|$$);
471	_give_terminal_to($pgrp_leader\|\|$$) if $fgflag && !$termflag;
472	remove_signal_handlers();
473
474	if( ref($code) eq 'CODE') {
475	my @tmp=&{$code};
476	if (!@tmp or $tmp[0]) {
477	CORE::exit(0);
478	}
479	CORE::exit(1);
480	} else {
481	{
482	if( ! ref $options) {
483	exec $code;
484	} else {
485	$code= shift @$words;
486	exec { $code } @$words;
487	}
488	} # Avoid unreachable warning
489	Psh::Util::print_error_i18n('exec_failed',$code);
490	CORE::exit(-1);
491	}
492	}
493	POSIX::setpgid($pid,$pgrp_leader\|\|$pid);
494	_give_terminal_to($pgrp_leader\|\|$pid) if $fgflag && !$termflag;
495	return ($pid,0,undef);
496	}
497
498	sub fork_process {
499	my( $code, $fgflag, $string, $options) = @_;
500	my ($pid,$sucess,@result)= _fork_process($code,undef,$fgflag,$string,$options);
501	return @result if !$pid;
502	my $job= Psh::Joblist::create_job($pid,$string);
503	if( !$fgflag) {
504	my $visindex= Psh::Joblist::get_job_number($job->{pid});
505	Psh::Util::print_out("[$visindex] Background $pid $string\n");
506	}
507	_wait_for_system($pid, 1) if $fgflag;
508	return undef;
509	}
510
511	#
512	# Returns true if the system has job_control abilities
513	#
514	sub has_job_control { return 1; }
515
516	#
517	# void restart_job(bool FOREGROUND, int JOB_INDEX)
518	#
519	sub restart_job
520	{
521	my ($fg_flag, $job_to_start) = @_;
522
523	my $job= Psh::Joblist::find_job($job_to_start);
524
525	if(defined($job)) {
526	my $pid = $job->{pid};
527	my $command = $job->{call};
528
529	if ($command) {
530	my $verb;
531	my $qRunning = $job->{running};
532
533	if ($fg_flag) {
534	$verb= ucfirst(Psh::Locale::get_text('foreground'));
535	} elsif ($qRunning) {
536	# bg request, and it's already running:
537	return;
538	} else {
539	$verb= ucfirst(Psh::Locale::get_text('restart'));
540	}
541	my $visindex = Psh::Joblist::get_job_number($pid);
542	Psh::Util::print_out("[$visindex] $verb $pid $command\n");
543
544	if($fg_flag) {
545	eval { _wait_for_system($pid, 0); };
546	Psh::Util::print_debug_class('e',"Error: $@") if $@;
547	} elsif( !$qRunning) {
548	$job->continue;
549	}
550	}
551	}
552	}
553
554	sub resume_job {
555	my $job= shift;
556
557	kill 'CONT', -$job->{pid};
558	kill 'CONT', -$job->{pgrp_leader} if $job->{pgrp_leader};
559	}
560
561	# Simply doing backtick eval - mainly for Prompt evaluation
562	sub backtick {
563	my $com=join ' ',@_;
564	local $^F=50;
565	my ($read,$write)= POSIX::pipe();
566
567	unless(my $pid=fork) {
568	POSIX::close($read);
569	POSIX::dup2($write,fileno(*STDOUT));
570	$^F=$write if ($write>$^F);
571	my ($success)= Psh::evl($com);
572	CORE::exit(!$success);
573	}
574	POSIX::close($write);
575	my $result='';
576	local(*READ);
577	open(READ,"<&=$read");
578	while(<READ>) {
579	$result.=$_;
580	}
581	close(READ);
582	return $result;
583	}
584
585	###################################################################
586	# SIGNALS
587	###################################################################
588
589	# Setup special treatment of certain signals
590	# Having a value of 0 means to ignore the signal completely in
591	# the loops while a code ref installs a different default
592	# handler. Note that calling _ignore_handler is different than
593	# setting the signal action to ignore - if you set the signal
594	# action to ignore, the signal might be passed on to parent processes
595	# which could decide to handle them for us
596
597	my %special_handlers= (
598	'CHLD' => \&_ignore_handler,
599	'CLD' => \&_ignore_handler,
600	'TTOU' => \&_ttou_handler,
601	'TTIN' => \&_ttou_handler,
602	'TERM' => \&Psh::OS::fb_exit_psh,
603	'HUP' => \&Psh::OS::fb_exit_psh,
604	'SEGV' => 0,
605	'WINCH'=> 0,
606	'ZERO' => 0,
607	);
608
609	my @signals= grep { substr($_,0,1) ne '_' } keys %SIG;
610
611	#
612	# void remove_signal_handlers()
613	#
614	# This used to manually set INT, QUIT, CONT, STOP, TSTP, TTIN,
615	# TTOU, and CHLD.
616	#
617	# The new technique changes the settings of all signals. It is
618	# from Recipe 16.13 of The Perl Cookbook (Page 582). It should be
619	# compatible with Perl 5.004 and later.
620	#
621
622	sub remove_signal_handlers
623	{
624	foreach my $sig (@signals) {
625	next if exists($special_handlers{$sig}) &&
626	! ref($special_handlers{$sig});
627	$SIG{$sig} = 'DEFAULT';
628	}
629	}
630
631	#
632	# void setup_signal_handlers
633	#
634	# This used to manually set INT, QUIT, CONT, STOP, TSTP, TTIN,
635	# TTOU, and CHLD.
636	#
637	# See comment for remove_signal_handlers() for more information.
638	#
639
640	sub setup_signal_handlers
641	{
642	foreach my $sig (@signals) {
643	if( exists($special_handlers{$sig})) {
644	if( ref($special_handlers{$sig})) {
645	$SIG{$sig}= $special_handlers{$sig};
646	}
647	next;
648	}
649	$SIG{$sig} = \&_signal_handler;
650	}
651
652	reinstall_resize_handler();
653	}
654
655
656	#
657	# Setup the SIGSEGV handler
658	#
659	sub setup_sigsegv_handler
660	{
661	$SIG{SEGV} = \&_error_handler;
662	}
663
664	#
665	# Setup SIGINT handler for readline
666	#
667	sub setup_readline_handler
668	{
669	$SIG{INT}= \&_readline_handler;
670	}
671
672	sub remove_readline_handler
673	{
674	$SIG{INT}= \&_signal_handler;
675	}
676
677	sub reinstall_resize_handler
678	{
679	Psh::OS::fb_reinstall_resize_handler();
680	&_resize_handler('WINCH');
681	}
682
683
684	#
685	# readline_handler()
686	#
687	# Readline ^C handler.
688	#
689
690	sub _readline_handler
691	{
692	my $sig= shift;
693	setup_readline_handler();
694	print "\n"; # Clean up the display
695	die "SECRET $Psh::bin: Signal $sig\n"; # changed to SECRET... just in case
696	}
697
698	sub _ttou_handler
699	{
700	_give_terminal_to($$);
701	}
702
703	#
704	# void _signal_handler( string SIGNAL )
705	#
706
707	sub _signal_handler
708	{
709	my ($sig) = @_;
710
711	if ($Psh::currently_active > 0) {
712	Psh::Util::print_debug("Received signal SIG$sig, sending to $Psh::currently_active\n");
713
714	kill $sig, -$Psh::currently_active;
715	} elsif ($Psh::currently_active < 0) {
716	Psh::Util::print_debug("Received signal SIG$sig, sending to Perl code\n");
717	die "SECRET ${Psh::bin}: Signal $sig\n";
718	} else {
719	_give_terminal_to($$);
720	Psh::Util::print_debug("Received signal SIG$sig, die-ing\n");
721	die "SECRET ${Psh::bin}: Signal $sig\n" if $sig eq 'INT';
722	}
723
724	$SIG{$sig} = \&_signal_handler;
725	}
726
727
728	#
729	# ignore_handler()
730	#
731
732	sub _ignore_handler
733	{
734	}
735
736
737	sub _error_handler
738	{
739	my ($sig) = @_;
740	Psh::Util::print_error_i18n('unix_received_strange_sig',$sig);
741	kill 'INT', $$; # HACK to stop a possible endless loop!
742	}
743
744	#
745	# _resize_handler()
746	#
747
748	sub _resize_handler
749	{
750	my ($sig) = @_;
751
752	Psh::OS::check_terminal_size();
753
754	$SIG{$sig} = \&_resize_handler;
755	}
756
757	{
758	my $debian=-1;
759	sub _check_debian {
760	if ($debian==-1) {
761	if (-r '/etc/debian-version') {
762	$debian=1;
763	} else {
764	$debian=0;
765	}
766	}
767	return $debian;
768	}
769	}
770
771	sub get_editor {
772	my $file= shift;
773	my $suggestion= shift;
774	my $editor= $suggestion\|\|$ENV{VISUAL}\|\|$ENV{EDITOR};
775	if (_check_debian()) {
776	$editor \|\|='editor';
777	} else {
778	$editor \|\|='vi';
779	}
780	return $editor;
781	}
782
783	# File::Spec
784
785	sub canonpath {
786	my ($path) = @_;
787	$path =~ s\|/+\|/\|g unless($^O eq 'cygwin'); # xx////xx -> xx/xx
788	$path =~ s\|(/\.)+/\|/\|g; # xx/././xx -> xx/xx
789	$path =~ s\|^(\./)+\|\|s unless $path eq "./"; # ./xx -> xx
790	$path =~ s\|^/(\.\./)+\|/\|s; # /../../xx -> xx
791	$path =~ s\|/\Z(?!\n)\|\| unless $path eq "/"; # xx/ -> xx
792	return $path;
793	}
794
795	sub catfile {
796	my $file = pop @_;
797	return $file unless @_;
798	my $dir = catdir(@_);
799	$dir .= "/" unless substr($dir,-1) eq "/";
800	return $dir.$file;
801	}
802
803	sub catdir {
804	my @args = @_;
805	foreach (@args) {
806	# append a slash to each argument unless it has one there
807	$_ .= "/" if $_ eq '' \|\| substr($_,-1) ne "/";
808	}
809	return canonpath(join('', @args));
810	}
811
812	sub file_name_is_absolute {
813	my $file= shift;
814	return scalar($file =~ m:^/:s);
815	}
816
817	sub rootdir {
818	'/';
819	}
820
821	sub splitdir {
822	my ($directories) = @_ ;
823
824	if ( $directories !~ m\|/\Z(?!\n)\| ) {
825	return split( m\|/\|, $directories );
826	}
827	else {
828	my( @directories )= split( m\|/\|, "${directories}dummy" ) ;
829	$directories[ $#directories ]= '' ;
830	return @directories ;
831	}
832	}
833
834	sub rel2abs {
835	my ($path,$base ) = @_;
836
837	# Clean up $path
838	if ( ! file_name_is_absolute( $path ) ) {
839	# Figure out the effective $base and clean it up.
840	if ( !defined( $base ) \|\| $base eq '' ) {
841	$base = Psh::getcwd_psh() ;
842	}
843	elsif ( ! file_name_is_absolute( $base ) ) {
844	$base = rel2abs( $base ) ;
845	}
846	else {
847	$base = canonpath( $base ) ;
848	}
849
850	# Glom them together
851	$path = catdir( $base, $path ) ;
852	}
853
854	return canonpath( $path ) ;
855	}
856
857	1;
858
859	__END__
860
861