# Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

# 

# Initial Contributors:

# Nokia Corporation - initial contribution.

# 

# Contributors:

# 

# Description:

# 

#

# Description:

# RemoteSite::FTP.pm

#

package RemoteSite::FTP;

use strict;

use Net::FTP;

use File::Basename;

use IO::File;

use RemoteSite;

use vars qw(@ISA);

@ISA=("RemoteSite");

#

# Constants

#

use constant DEFAULTRECONNECTS => 5;

use constant DEFAULTTIMEOUT => 30;

use constant BLOCKSIZE => 32768;

#

# Initialization

#

sub Initialize {

  my $self = shift;

  my %args = @_;

  $self->{username} = $args{username};

  $self->{password} = $args{password};

  $self->{passiveMode} = $args{passive_mode};

  $self->{resumeMode} = $args{resume_mode};

  $self->{timeout} = $args{timeout};

  $self->{reconnects} = $args{reconnects};

  #call base class initialization

  $self->SUPER::Initialize(@_);

  #if username or password not defined ask for them interactively

  unless ($self->Username()) {

    $self->HandleError("No remote host defined.") unless $self->Host();

    print 'FTP username: ';

    my $userName = <STDIN>;

    if ($userName) {

      chomp ($userName);

      $self->Username($userName);

    }

  }

  unless ($self->Password()) {

    print 'FTP password: ';

    $self->Password(Utils::QueryPassword());

  }

  #set timeout to default value if not set or not a positive integer

  unless (defined $self->{timeout} and $self->{timeout} =~ /^\d+$/) {

    $self->{timeout} = DEFAULTTIMEOUT;

  }

  #set reconnects to default value if not set or not a positive integer

  unless (defined $self->{reconnects} and $self->{reconnects} =~ /^\d+$/) {

    $self->{reconnects} = DEFAULTRECONNECTS;

  }

  #connect to FTP site, login and set to binary mode

  $self->Connect();

}

#

# Public getters/setters

#

sub Username {

  my $self = shift;

  if (defined $_[0]) {$self->{username} = shift;}

  return $self->{username};

}

sub Password {

  my $self = shift;

  if (defined $_[0]) {$self->{password} = shift;}

  return $self->{password};

}

sub PassiveMode {

  my $self = shift;

  if (defined $_[0]) {$self->{passiveMode} = shift;}

  return $self->{passiveMode};

}

sub ResumeMode {

  my $self = shift;

  if (defined $_[0]) {$self->{resumeMode} = shift;}

  return $self->{resumeMode};

}

sub Timeout {

  my $self = shift;

  return $self->{timeout};

}

sub Reconnects {

  my $self = shift;

  return $self->{reconnects};

}

#

# Public (from RemoteSite)

#

sub SendFile {

  my $self = shift;

  my $localFile = shift;

  my $remoteFile = shift;

  unless (defined $localFile and defined $remoteFile) {

    $self->HandleError("Incorrect args passed to ".ref($self)."::SendFile");

  }

  $remoteFile =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  my $localFileSize = Utils::FileSize($localFile);

  if ($self->{verbose}) {

    print 'Uploading '.basename($localFile).' to FTP site '.$self->Host()." ...\n";

  }

  elsif ($localFileSize) {

    print 'Uploading '.basename($localFile).':    ';

  }

  #check the file to upload exists

  unless (-e $localFile) {

    $self->HandleError("Local file $localFile does not exist");

  }

  #check remote dir exists and create it if it doesn't

  my $remoteDir = dirname($remoteFile);

  unless ($self->DirExists($remoteDir)) {

    $self->MakeDir($remoteDir);

  }

  #if a file with same name as the remote file already exists delete it (even if it has different case)

  if (my $actualFileName = $self->FileExists($remoteFile)) {

    $self->DeleteFile($actualFileName);

  }

  #create a temporary file name in the remote directory for uploading to

  my $tmpFile = $self->CreateTemporaryFile($remoteDir);

  #send the file

  if ($self->ResumeMode()) {

    $self->SendFileWithResume($localFile, $tmpFile);

  }

  else {

    if ($self->{verbose} and $localFileSize) {

      print "Upload progress: ";

    }

    $self->DisplayProgress($localFileSize);

    $self->SendFileWithoutResume($localFile, $tmpFile);

  }

  #rename the temporary file to the final remote file name

  $self->MoveFile($tmpFile, $remoteFile);

  if ($self->{verbose} > 1) {

    print "Upload successful. Stored as $remoteFile on FTP site.\n";

  }

}

sub GetFile {

  my $self = shift;

  my $remoteFile = shift;

  my $localFile = shift;

  unless (defined $localFile and defined $remoteFile) {

    $self->HandleError("Incorrect args passed to ".ref($self)."::GetFile");

  }

  $remoteFile =~ s{\\}{\/}g;     #convert back slashes to forward slashes

  if ($self->{verbose}) {

    print "Downloading ".$remoteFile." from FTP site ".$self->Host()." ...\n";

  }

  else {

    print "Downloading ".basename($remoteFile).":    ";

  }

  #check that the file to download exists

  my $actualFileName;

  unless ($actualFileName = $self->FileExists($remoteFile)) {

    $self->HandleError("Remote file $remoteFile does not exist");

  }

  $remoteFile = $actualFileName;  #handles case sensitivity correctly

  #check local dir exists and create it if it doesn't

  my $localDir = dirname($localFile);

  unless (-e $localDir) {

    Utils::MakeDir($localDir);

    if ($self->{verbose}) {

      print "Created directory $localDir on local drive\n";

    }

  }

  my $remoteFileSize = $self->FileSize($remoteFile);

  if ($self->{verbose} and $remoteFileSize) {

    print "Download progress: ";

  }

  #get the file

  if ($self->ResumeMode()) {

    $self->DisplayProgress($remoteFileSize);

    $self->GetFileWithResume($remoteFile, $localFile);

  }

  else {

    $self->DisplayProgress($remoteFileSize);

    $self->GetFileWithoutResume($remoteFile, $localFile);

  }

  if ($self->{verbose} > 1) {

    print "Download successful. Stored as $localFile on local site.\n";

  }

}

sub FileExists {

  my $self = shift;

  my $remoteFile = shift;

  unless (defined $remoteFile) {

    return 0;

  }

  #use Carp qw/cluck/;

  #cluck "Called FileExists";

  # List the directory the file is in, and see if the file name is in it.

  $remoteFile =~ s{\/}{\\}g;     #convert forward slashes to back slashes

  (my $path, my $baseName, my $ext) = Utils::SplitFileName($remoteFile);

  my $fileName = $baseName . $ext;

  $path =~ s/\\$//;       #remove trailing slash

  $path =~ s/\\/\//g;     #convert back slashes to forward slashes

  my $ls = $self->DirList($path);

  print "Checking for existence of remote file \"$remoteFile\" by looking for \"$fileName\" in \"$path\".\n" if ($self->{verbose} && $ls);

  return 0 unless $ls; # definitely doesn't exist if nothing in the directory

  my @present = grep /(\/|\\|^\s*)\Q$fileName\E\s*$/i, @$ls;

  if (@present) {

    print "Have found file: YES\n" if ($self->{verbose});

    $present[0] = $path."/".$present[0] if ( $present[0] !~ /\// );

    return $present[0];

  }

  else {

    print "Have found file: NO\n" if ($self->{verbose});

    return 0;

  }

}

sub DirList {

  my $self = shift;

  my $remoteDir = shift;

  print "Listing FTP directory $remoteDir\n" if ($self->{verbose});

  my $dirlist_retries = 3;

  $remoteDir =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  my $retry;

  for ($retry = 0; $retry < $dirlist_retries; $retry++) {

    unless ($self->Connected()) {

      $self->Connect();

    }

    # The Net::FTP module that we're using here has two options for listing the contents

    # of a directory. They are the 'ls' and 'dir' calls.

    # The 'ls' call is great, and just returns a list of the items. But, irritatingly, it

    # misses out directories: the returned list just contains names of *files*.

    # dir is better, in some ways, as it lists directories too, but its output format

    # varies from one FTP site to the next. So we have to stick with ls.

    print "About to call dir(\"$remoteDir\")\n" if ($self->{verbose});

    my $ls = $self->{ftp}->ls($remoteDir);

    my $resp = $self->{ftp}->message;

    print "FTP response to list command was \"$resp\"\n" if ($self->{verbose});

    if (ref $ls) {

      print "FTP dir returned \"$ls\" which is a ".(ref $ls)." containing ".(scalar @$ls)." items\n" if ($self->{verbose});

      $ls = undef if ($resp eq ""); # if we didn't get "Opening BINARY mode connection..." or something similar, then we've

        # come across the problem where Net::FTP says Net::FTP: Unexpected EOF on command channel at d:/reltools/2.6x/personal/bin/Net

        # /FTP/dataconn.pm line 73. Unfortunately, it doesn't die, and it returns an empty array, so the only way to find out this has

        # happened is to check message.

      $ls = undef if ($resp =~ m/^connection closed/i);

    }

    # $ls might now be undef

    if (ref($ls)) {

      return $ls;

    }

    else {

      if ($self->Connected()) {

        return undef;

      }

      else {

        print "Warning: Listing of \"$remoteDir\" failed due to an FTP site problem: " . $self->{ftp}->message . ". ";

        if ($self->PassiveMode()) {

          print "PASV mode FTP is currently enabled. This can cause connectivity issues under certain circumstances. ",

            "To disable, remove the pasv_transfer_mode directive from your reltools.ini file.\n";

        }

        else {

          print "PASV mode FTP is currently disabled. Enabling it can prevent connectivity issues under certain circumstances. ",

            "To enable, add the pasv_transfer_mode directive to your reltools.ini file.\n";

        }

        # Fall through to next loop iteration

      }

    }

  }

  die "Error: have tried to list \"$remoteDir\" $retry times with no success - giving up\n";

}

sub MakeDir {

  my $self = shift;

  my $remoteDir = shift;

  $remoteDir =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  unless ($self->Connected()) {

    $self->Connect();

  }

  if ($self->{ftp}->mkdir($remoteDir, 1)) {

    if ($self->{verbose}) {

      print "Created directory $remoteDir on FTP site\n";

    }

  }

  else {

    if ($self->Connected()) {

      $self->HandleError("Cannot make directory $remoteDir on FTP site");

    }

    else {

      $self->MakeDir($remoteDir);

    }

  }

}

sub FileSize {

  my $self = shift;

  my $file = shift;

  $file =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  unless ($self->Connected()) {

    $self->Connect();

  }

  my $size;

  if (defined($size = $self->{ftp}->size($file))) {

    return $size;

  }

  else {

    if ($self->Connected()) {

      return 0;

    }

    else {

      $self->FileSize($file);  #try to get the size again after reconnecting

    }

  }

}

sub DeleteFile {

  my $self = shift;

  my $file = shift;

  $file =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  unless ($self->Connected()) {

    $self->Connect();

  }

  if ($self->{ftp}->delete($file)) {

    return;

  }

  elsif ($self->{ftp}->rmdir($file)) {

    return;

  }

  else {

    if ($self->Connected()) {

      $self->HandleError("Cannot delete $file on FTP site");

    }

    else {

      $self->DeleteFile($file);

    }

  }

}

sub MoveFile {

  my $self = shift;

  my $oldFile = shift;

  my $newFile = shift;

  $oldFile =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  $newFile =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  unless ($self->Connected()) {

    $self->Connect();

  }

  if ($self->{ftp}->rename($oldFile, $newFile)) {

    return;

  }

  else {

    if ($self->Connected()) {

      $self->HandleError("Cannot move $oldFile to $newFile on FTP site");

    }

    else {

      $self->MoveFile($oldFile, $newFile);

    }

  }

}

sub FileModifiedTime {

  my $self = shift;

  my $file = shift;

  $file =~ s{\\}{\/}g;   #convert back slashes to forward slashes

  unless ($self->Connected()) {

    $self->Connect();

  }

  my $modifiedTime;

  if (defined($modifiedTime = $self->{ftp}->mdtm($file))) {

    return $modifiedTime;

  }

  else {

    if ($self->Connected()) {

      print "Warning: failed to find modified time for file \"$file\"\n";

      return undef;

    }

    else {

      $self->FileModifiedTime($file);

    }

  }

}

#

# Private

#

sub Connect {

  my $self = shift;

  unless ($self->Host()) {

    $self->HandleError("Cannot connect FTP host name not defined");

  }

  my $debug = (($self->{verbose} && $self->{verbose} > 1) ? 1 : 0);

  #Attempt to connect (or reconnect if connection fails)

  for (1..$self->Reconnects()) {

    $self->{ftp} = undef;

    if ($self->{verbose}) {

      print "Connecting to FTP site ".$self->Host()."...\n";

    }

    $self->{ftp} = Net::FTP->new($self->Host(),

				 Passive => $self->PassiveMode(),

				 Debug => $debug,

				 Timeout => $self->Timeout());

    if (defined $self->{ftp}) {

      #login to FTP site

      $self->{ftp}->login($self->Username(), $self->Password())

	or $self->HandleError("FTP login failed");

      #change transfer mode to binary

      $self->{ftp}->binary()

	or $self->HandleError("Failed to set FTP server to binary transfer mode");

      return;

    }

  }

  $self->HandleError("Cannot connect to FTP site ".$self->Host());

}

sub Connected {

  my $self = shift;

  return (defined $self->{ftp} and defined $self->{ftp}->pwd);

}

sub SendFileWithResume {

  my $self = shift;

  my $localFile = shift;

  my $remoteFile = shift;

  #open the local file for reading

  $self->{localfh} = IO::File->new("< $localFile");

  binmode($self->{localfh});

  my $localFileSize = Utils::FileSize($localFile);

  my $buffer;

  my $bytesSent;

  my $totalBytesSent = 0;

 RESUME:

  #Open the temporary file on the FTP site for writing/appending

  $self->{dataconn} = $self->OpenRemoteFileForAppending($remoteFile);

  if ($self->{verbose} and $localFileSize) {

    print "Upload progress:    ";

  }

  #upload temporary file in blocks

  while ($self->{localfh}->read($buffer, BLOCKSIZE)) {

    eval {

      $bytesSent = $self->{dataconn}->write($buffer, length($buffer));