File Coverage

blib/lib/Sudo.pm

Criterion	Covered	Total	%
statement	12	139	8.6
branch	0	80	0.0
condition	0	36	0.0
subroutine	4	7	57.1
pod	1	3	33.3
total	17	265	6.4

package Sudo;

use IPC::Run qw(run timeout start harness);
use Term::ReadPassword;
use base qw(Class::Accessor);

use strict;
our $VERSION = '0.33';


sub sudo_run
    {
     # Ok, glue the bits together.
     my $self = shift;
     my (%ret,$binary,$sudo,$program,$command,$sudo_args,$program_args);
     my ($final_cmd,$sudo_pipe_handle,@cmd,$in,$out,$err,$line);
     my ($username,$remote_machine,$remote_user);

     #   Ok, IPC::Run is very (I mean very) sensitive to
     # its @cmd processing.  Each option has to be its own entry
     # in the array.  This means that options that flow in, if they
     # are not of the form -\w but are -\w\s+\S+ (e.g. an option with
     # an option parameter, such as -u username), have to be broken up
     # into their own array elements in @cmd.
     #
     # Hopefully IPC::Run will be fixed one day.  Until then, we write
     # to the real API (not the documented one).
     #

     # do we have a binary ...
     if ($self->{debug})
        {
	  $ENV{IPCRUNDEBUG}='basic';
	  if ($self->{debug} == 2)
	     {
	       $ENV{IPCRUNDEBUG}='data';
	     }
	  elsif ($self->{debug} >= 3)
	     {
	       $ENV{IPCRUNDEBUG}='details';
	     }
	}
     if (!defined($self->{sudo}))
        {
	  %ret = (
	          'error' => 'Error: you did not tell me where the sudo binary is was not set'
	         );
	  return \%ret;
	}

     $self->{sudo} =~ /^(\S+)$/;    # force binary to be a
     				    # single string with no
				    # spaces.  This may break
				    # some folks paths, but it
				    # should be safer than allowing
				    # any command string.
     $sudo = $1;

     # test for remote execution ... you need to have the ssh keys
     # setup before this ...
     #$remote_machine=$self->{hostname}if (defined($self->{hostname}));
     if (defined($remote_machine))
        {
	  $remote_user	= getpwuid($<);  # default user name is the user running the script
	  if (defined($self->{username}))
	     {
	       $remote_user	= $self->{username};
	     }
	   push @cmd,"ssh";
	   push @cmd, (sprintf '%s@%s',$remote_user,$remote_machine);
	}
     if (!defined($remote_machine))
        {
	 if (! -e $sudo )
            {
	      %ret = (
	              'error' => (sprintf 'Error: the sudo binary "%s" does not exist',$sudo)
	             );
	      return \%ret;
	    }

	 if (! -x $sudo )
            {
	      %ret = (
	              'error' => (sprintf 'Error: the sudo binary "%s" is not executable',$sudo)
	             );
	      return \%ret;
	    }
	}
     push @cmd,$sudo;

     # force the -S switch to take the password from
     # STDIN
     push @cmd,'-S';

     if (!exists($self->{_timeout})) { $self->{_timeout} = 10; }

     $program_args	= "";

     # ok, append the user information
     if (!defined($self->{username}))
        {
	  %ret = (
	          'error' => 'Error:  username was not set'
	         );
	  return \%ret;
	}

     if (exists	($self->{sudo_args}))
        {
	  # process the arguments, splitting on white space
	  $self->{sudo_args} =~ s/^\s+//;  # trim leading spaces
	  $self->{sudo_args} =~ s/\s+$//;  # trim trailing spaces
	  push @cmd,(split(/\s+/,$self->{sudo_args}));
	}

     push @cmd,"-u";
     push @cmd,$self->{username};

     if (!defined($self->{program}))
        {
	  %ret = (
	          'error' => 'Error: the program attribute was not set'
	         );
	  return \%ret;
	}
     $self->{program} =~ /^(\S+)$/;  # force binary to be a
     				    # single string with no
				    # spaces.  This may break
				    # some folks paths, but it
				    # should be safer than allowing
				    # any command string.
     $program = $1;
     if (!defined($remote_machine) && (! -e $program ))
        {
	  %ret = (
	          'error' => (sprintf 'Error: the program "%s" does not exist',$program)
	         );
	  return \%ret;
	}

     if (!defined($remote_machine) && (! -x $program ))
        {
	  %ret = (
	          'error' => (sprintf 'Error: the program "%s" is not executable',$program)
	         );
	  return \%ret;
	}
     push @cmd,$program;

     if (exists	($self->{program_args}))
        {
	  # process the arguments, splitting on white space
	  $self->{program_args} =~ s/^\s+//;  # trim leading spaces
	  $self->{program_args} =~ s/\s+$//;  # trim trailing spaces
	  # Note:  this might break some programs due to the
	  # multiple ways options may be specified and the actual
	  # command line argument contents.  Hopefully it will be
	  # ok to start...
	  push @cmd,(split(/\s+/,$self->{program_args}));
	}



     # ok, build the final "options" to the sudo we are going to run
     $command = join(" ",@cmd);
     printf STDERR "- command: %s\n",$command if ($self->{debug});
     if (
	 exists($self->{debug}) &&
	 $self->{debug} >= 2
        )
        {
	 my $index=0;
	 foreach my $entry (@cmd)
	   {
             printf STDERR "- _ [%s]: %s\n",$index,$entry;
	     $index++;
	   }
       }
     printf STDERR "\n< username = %s\n",$username if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< password = %s\n",$self->{password} if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< sudo = %s\n",$sudo if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< program = %s\n",$program if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< program args = %s\n",$program_args if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );


     printf STDERR ": starting sudo \n" if ($self->{debug});

     $in=$self->{password};
     $out="";
     $err="";
     my $h = run \@cmd,\$in,\$out,\$err,timeout($self->{_timeout});


     printf STDERR "\n\n> output: %s \n> result: %s\n\n",$out,$? if ($self->{debug});

     %ret = (
              'stdout'	=>	$out,
	      'stderr'	=>	$err,
	      'rc'	=>	$h
            );

     return \%ret;
  }

sub sudo_shell_start
    {
     # Ok, glue the bits together.
     my $self = shift;
     my (%ret,$binary,$sudo,$program,$command,$sudo_args,$program_args);
     my ($final_cmd,$sudo_pipe_handle,@cmd,$in,$out,$err,$line);
     my ($username,$remote_machine,$remote_user);

     #   Ok, IPC::Run is very (I mean very) sensitive to
     # its @cmd processing.  Each option has to be its own entry
     # in the array.  This means that options that flow in, if they
     # are not of the form -\w but are -\w\s+\S+ (e.g. an option with
     # an option parameter, such as -u username), have to be broken up
     # into their own array elements in @cmd.
     #
     # Hopefully IPC::Run will be fixed one day.  Until then, we write
     # to the real API (not the documented one).
     #

     # do we have a binary ...
     if ($self->{debug})
        {
	  $ENV{IPCRUNDEBUG}='basic';
	  if ($self->{debug} == 2)
	     {
	       $ENV{IPCRUNDEBUG}='data';
	     }
	  elsif ($self->{debug} >= 3)
	     {
	       $ENV{IPCRUNDEBUG}='details';
	     }
	}
     if (!defined($self->{sudo}))
        {
	  %ret = (
	          'error' => 'Error: you did not tell me where the sudo binary is was not set'
	         );
	  return \%ret;
	}

     $self->{sudo} =~ /^(\S+)$/;    # force binary to be a
     				    # single string with no
				    # spaces.  This may break
				    # some folks paths, but it
				    # should be safer than allowing
				    # any command string.
     $sudo = $1;

     if (! -e $sudo )
        {
	  %ret = (
	          'error' => (sprintf 'Error: the sudo binary "%s" does not exist',$sudo)
	         );
	  return \%ret;
	}

     if (! -x $sudo )
        {
	  %ret = (
	          'error' => (sprintf 'Error: the sudo binary "%s" is not executable',$sudo)
	         );
	  return \%ret;
	}
     push @cmd,$sudo;

     # force the -S switch to take the password from
     # STDIN
     push @cmd,'-S';

     # force the -s switch to use a shell
     push @cmd,'-S';


     # ok, append the user information
     if (!defined($self->{username}))
        {
	  %ret = (
	          'error' => 'Error:  username was not set'
	         );
	  return \%ret;
	}

     if (exists	($self->{sudo_args}))
        {
	  # process the arguments, splitting on white space
	  $self->{sudo_args} =~ s/^\s+//;  # trim leading spaces
	  $self->{sudo_args} =~ s/\s+$//;  # trim trailing spaces
	  push @cmd,(split(/\s+/,$self->{sudo_args}));
	}

     push @cmd,"-u";
     push @cmd,$self->{username};


     # ok, build the final "options" to the sudo we are going to run
     $command = join(" ",@cmd);
     printf STDERR "- command: %s\n",$command if ($self->{debug});
     if (
	 exists($self->{debug}) &&
	 $self->{debug} >= 2
        )
        {
	 my $index=0;
	 foreach my $entry (@cmd)
	   {
             printf STDERR "- _ [%s]: %s\n",$index,$entry;
	     $index++;
	   }
       }
     printf STDERR "\n< username = %s\n",$username if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< password = %s\n",$self->{password} if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );
     printf STDERR "< sudo = %s\n",$sudo if (
     					        exists($self->{debug}) &&
						$self->{debug} >= 2
					      );

     printf STDERR ": starting sudo \n" if ($self->{debug});

     $self->{in}=$self->{password};
     $self->{out}="";
     $self->{err}="";
     $self->{sudo_handle} = start \@cmd,\$self->{in},\$self->{out},\$self->{err};


     printf STDERR "\n\n> output: %s \n> result: %s\n\n",$out,$? if ($self->{debug});

  }

sub sudo_shell_pump_nb
    {
      my ($self)=shift;
      $self->{handle}->pump_nb;
    }
1;
__END__