File Coverage

blib/lib/Net/xFTP.pm

Criterion	Covered	Total	%
statement	25	180	13.8
branch	0	84	0.0
condition	0	29	0.0
subroutine	13	19	68.4
pod	6	6	100.0
total	44	318	13.8

package Net::xFTP;

require 5.001;

use warnings;

use strict;
use vars qw(@ISA $VERSION %CONSTANTS);
use Carp;
use Cwd 'cwd';
#x use Fcntl ':mode';
#x use File::Copy;

my @supported_mods = (qw(ftp sftp ssh2 local foreign openssh fsp ftpssl));
my %haveit;
my  $haveSFTPConstants = 0;

foreach my $imod (@supported_mods)
{
	$haveit{$imod} = 0;
}
$haveit{'local'} = 1;  #JWT:ADDED 20150123 - WE *ALWAYS* HAVE "local", SINCE NO EXTERNAL MODULE REQUIRED!

my $bummer = ($^O =~ /Win/o) ? 1 : 0;

eval 'use Net::FTP; $haveit{"ftp"} = 1; 1';
eval 'use Net::SFTP; $haveit{"sftp"} = 1; 1';
eval 'use Net::SFTP::Constants qw(SSH2_FXF_WRITE SSH2_FXF_CREAT SSH2_FXF_TRUNC); $haveSFTPConstants = 1; 1';
eval 'use Net::SSH2; use Net::SSH2::SFTP; $haveit{"ssh2"} = 1; 1';
eval 'use Net::SFTP::Foreign; $haveit{"foreign"} = 1; 1';
eval 'use Net::OpenSSH; use IO::Pty; $haveit{"openssh"} = 1; 1';
eval 'use Net::FSP; $haveit{"fsp"} = 1; 1';
eval 'use Net::FTPSSL; $haveit{"ftpssl"} = 1; 1';

our $VERSION = '1.01';

sub new
{
	my $class = shift;
	$@ = '';
	my $pkg  = shift || 0;
	$pkg =~ s/\s+//go;
	$pkg = 'Net::' . $pkg  unless (!$pkg || $pkg =~ /^Net/o);
	$pkg = 'Net::SFTP::Foreign'  if ($pkg eq 'Net::Foreign');   #FIXUP.
	my $host = shift;
	my %args = @_;
	my $xftp;
	my %xftp_args;
	my ($i, $j, $t);

	foreach $i (keys %args)
	{
		if ($i =~ s/^xftp_//o)   #EXTRACT OUT OUR SPECIAL ARGS ("xftp_*")
		{
			$xftp_args{$i} = $args{"xftp_$i"};

			delete $args{"xftp_$i"};
		}
	}
	if ($pkg =~ /Net::FTPSSL/)
	{
		eval { require "Net/xFTP_FTPSSL.pm" };
		if ($@ || !$haveit{'ftpssl'})
		{
			warn "xFTP:Could not require Net::xFTP_FTPSSL.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'ftpssl')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::FTPSSL::new_ftpssl("${class}::FTPSSL", $pkg, $host, %args);
	}
	elsif ($pkg =~ /Net::FTP/)
	{
		eval { require "Net/xFTP_FTP.pm" };
		if ($@ || !$haveit{'ftp'})
		{
			warn "xFTP:Could not require Net::xFTP_FTP.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'ftp')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::FTP::new_ftp("${class}::FTP", $pkg, $host, %args);
	}
	elsif ($pkg =~ /Net::SFTP::Foreign/)
	{
		eval { require "Net/xFTP_Foreign.pm" };
		if ($@ || !$haveit{'foreign'})
		{
			warn "xFTP:Could not require Net::xFTP_Foreign.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'foreign')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::Foreign::new_foreign("${class}::Foreign", $pkg, $host, %args);
	}
	elsif ($pkg =~ /Net::SSH2/)
	{
		eval { require "Net/xFTP_SSH2.pm" };
		if ($@ || !$haveit{'ssh2'})
		{
			warn "xFTP:Could not require Net::xFTP_SSH2.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'ssh2')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::SSH2::new_ssh2("${class}::SSH2", $pkg, $host, %args);
	}
	elsif ($pkg =~ /Net::SFTP/)
	{
		eval { require "Net/xFTP_SFTP.pm" };
		if ($@ || !$haveit{'sftp'})
		{
			warn "xFTP:Could not require Net::xFTP_SFTP.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'sftp')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::SFTP::new_sftp("${class}::SFTP", $pkg, $host, %args);
		$xftp->{haveSFTPConstants} = $haveSFTPConstants  if ($xftp);
	}
	elsif ($pkg =~ /Net::FSP/)
	{
		eval { require "Net/xFTP_FSP.pm" };
		if ($@ || !$haveit{'fsp'})
		{
			warn "xFTP:Could not require Net::xFTP_FSP.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'fsp')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::FSP::new_fsp("${class}::FSP", $pkg, $host, %args);
	}
	elsif ($pkg =~ /Net::OpenSSH/)
	{
		eval { require "Net/xFTP_OpenSSH.pm" };
		if ($@ || !$haveit{'openssh'})
		{
			warn "xFTP:Could not require Net::xFTP_OpenSSH.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'openssh')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::OpenSSH::new_openssh("${class}::OpenSSH", $pkg, $host, %args);
	}
	elsif (!$pkg || $pkg =~ /local/i)
	{
		eval { require "Net/xFTP_LOCAL.pm" };
		if ($@)
		{
			warn "xFTP:Could not require Net::xFTP_LOCAL.pm module($@)!";
			return undef;
		}
		foreach $i (keys %args)
		{
			foreach $j (@supported_mods)
			{
				if ($i =~ /^${j}\_/)
				{
					if ($j eq 'local')
					{
						($t = $i) =~ s/^${j}_//;
						$args{$t} = $args{$i};
					}
					delete $args{$i};
				}
			}
		}
		$xftp = Net::xFTP::LOCAL::new_local("${class}::LOCAL", $pkg, $host, %args);
	}
	else
	{
	$@ = "No such package \"$pkg\"!";
		warn "xFTP:$@!";
		return undef;
	}

	if ($xftp)
	{
		$xftp->{pkg} = ($pkg =~ /local/io) ? $pkg : '';
		$xftp->{bummer} = ($^O =~ /Win/o) ? 1 : 0;
		return $xftp;
	}
	else
	{
		@_ = @_ . " Could not get new $pkg object (undef)!";
	}
	return undef;
}

sub haveFTP        #DEPRECIATED, USE haveModule($module) INSTEAD!
{
	return $haveit{'ftp'};
}

sub haveSFTP
{
	return $haveit{'sftp'};
}

sub haveModule
{
	my $self = shift;
	my $modul = shift;

	my $modHash = &haveModules();
	if ($modul =~ /^Net\:\:/) {
		return (defined $modHash->{$modul}) ? $modHash->{$modul} : 0;
	}
	$modul =~ tr/A-Z/a-z/;
	return (defined $haveit{$modul}) ? $haveit{$modul} : 0;
}

sub haveModules
{
	return { 'Net::FTP' => $haveit{'ftp'}, 'Net::SFTP' => $haveit{'sftp'},
			'Net::SSH2' => $haveit{'ssh2'}, 'Net::SFTP::Foreign' => $haveit{'foreign'},
			'Net::OpenSSH' => $haveit{'openssh'}, 'Net::FSP' => $haveit{'fsp'},
			'Net::FTPSSL' => $haveit{'ftpssl'}};
}

sub protocol
{
	my $self = shift;

	return $self->{pkg};
}

1

__END__