content: /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  The ASF licenses this file to You under the Apache License, Version 2.0
   *  (the "License"); you may not use this file except in compliance with
   *  the License.  You may obtain a copy of the License at
   *
   *      https://www.apache.org/licenses/LICENSE-2.0
   *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   *
   */
  
  package org.apache.tools.ant.taskdefs.optional.ssh;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.Iterator;
  import java.util.List;
  
  import com.jcraft.jsch.ChannelSftp;
  import com.jcraft.jsch.JSchException;
  import com.jcraft.jsch.Session;
  import com.jcraft.jsch.SftpException;
  import com.jcraft.jsch.SftpProgressMonitor;
  
  /**
   * Utility class to carry out an upload by sftp.
   */
  public class ScpToMessageBySftp extends ScpToMessage/*AbstractSshMessage*/ {
  
      private static final int HUNDRED_KILOBYTES = 102400;
  
      private File localFile;
      private final String remotePath;
      private List<Directory> directoryList;
      private final boolean preserveLastModified;
  
      /**
       * Constructor for a local file to remote.
       * @param verbose if true do verbose logging
       * @param session the scp session to use
       * @param aLocalFile the local file
       * @param aRemotePath the remote path
       * @since Ant 1.7
       */
      public ScpToMessageBySftp(final boolean verbose,
                                final Session session,
                                final File aLocalFile,
                                final String aRemotePath) {
          this(verbose, session, aLocalFile, aRemotePath, false);
  
      }
  
      /**
       * Constructor for a local file to remote.
       * @param verbose if true do verbose logging
       * @param session the scp session to use
       * @param aLocalFile the local file
       * @param aRemotePath the remote path
       * @param preserveLastModified True if the last modified time needs to be preserved
       *                             on the transferred files. False otherwise.
       * @since Ant 1.9.10
       */
      public ScpToMessageBySftp(final boolean verbose,
                                final Session session,
                                final File aLocalFile,
                                final String aRemotePath,
                                final boolean preserveLastModified) {
          this(verbose, session, aRemotePath, preserveLastModified);
  
          this.localFile = aLocalFile;
      }
  
  
      /**
       * Constructor for a local directories to remote.
       * @param verbose if true do verbose logging
       * @param session the scp session to use
       * @param aDirectoryList a list of directories
       * @param aRemotePath the remote path
       * @since Ant 1.7
       */
      public ScpToMessageBySftp(final boolean verbose,
                                final Session session,
                                final List<Directory> aDirectoryList,
                                final String aRemotePath) {
          this(verbose, session, aDirectoryList, aRemotePath, false);
      }
  
      /**
       * Constructor for a local directories to remote.
       * @param verbose if true do verbose logging
       * @param session the scp session to use
       * @param aDirectoryList a list of directories
       * @param aRemotePath the remote path
       * @param preserveLastModified  True if the last modified time needs to be preserved
       *                             on the transferred files. False otherwise.
       * @since Ant 1.9.10
       */
      public ScpToMessageBySftp(final boolean verbose,
                                final Session session,
                                final List<Directory> aDirectoryList,
                                final String aRemotePath,
                                final boolean preserveLastModified) {
          this(verbose, session, aRemotePath, preserveLastModified);
  
          this.directoryList = aDirectoryList;
      }
  
  
      /**
       * Constructor for ScpToMessage.
       * @param verbose if true do verbose logging
       * @param session the scp session to use
       * @param aRemotePath the remote path
       * @param preserveLastModified True if the last modified time needs to be preserved
       *                             on the transferred files. False otherwise.
       */
      private ScpToMessageBySftp(final boolean verbose,
                                 final Session session,
                                 final String aRemotePath,
                                 final boolean preserveLastModified) {
          super(verbose, session);
          this.remotePath = aRemotePath;
          this.preserveLastModified = preserveLastModified;
      }
  
      /**
       * Constructor for ScpToMessage.
       * @param session the scp session to use
       * @param aLocalFile the local file
       * @param aRemotePath the remote path
       */
      public ScpToMessageBySftp(final Session session,
                                final File aLocalFile,
                                final String aRemotePath) {
          this(false, session, aLocalFile, aRemotePath);
      }
  
      /**
       * Constructor for ScpToMessage.
       * @param session the scp session to use
       * @param aDirectoryList a list of directories
       * @param aRemotePath the remote path
       */
      public ScpToMessageBySftp(final Session session,
                                final List<Directory> aDirectoryList,
                                final String aRemotePath) {
          this(false, session, aDirectoryList, aRemotePath);
      }
  
      /**
       * Carry out the transfer.
       * @throws IOException on i/o errors
       * @throws JSchException on errors detected by scp
       */
      @Override
      public void execute() throws IOException, JSchException {
          if (directoryList != null) {
              doMultipleTransfer();
          }
          if (localFile != null) {
              doSingleTransfer();
          }
          log("done.\n");
      }
  
      private void doSingleTransfer() throws JSchException {
          final ChannelSftp channel = openSftpChannel();
          try {
              channel.connect();
              try {
                  sendFileToRemote(channel, localFile, remotePath);
              } catch (final SftpException e) {
                  throw new JSchException("Could not send '" + localFile
                          + "' to '" + remotePath + "' - "
                          + e.toString(), e);
              }
          } finally {
              if (channel != null) {
                  channel.disconnect();
              }
          }
      }
  
      private void doMultipleTransfer() throws IOException, JSchException {
          final ChannelSftp channel = openSftpChannel();
          try {
              channel.connect();
  
              try {
                  try {
                      channel.stat(remotePath);
                  } catch (final SftpException e) {
                      if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
                          // dir does not exist.
                          channel.mkdir(remotePath);
                          channel.chmod(getDirMode(), remotePath);
                      } else {
                          throw new JSchException("failed to access remote dir '"
                                                  + remotePath + "'", e);
                      }
                  }
                  channel.cd(remotePath);
              } catch (final SftpException e) {
                  throw new JSchException("Could not CD to '" + remotePath
                                          + "' - " + e.toString(), e);
              }
              for (Directory current : directoryList) {
                  try {
                      if (getVerbose()) {
                          log("Sending directory " + current);
                      }
                      sendDirectory(channel, current);
                  } catch (final SftpException e) {
                      String msg = "Error sending directory";
                      if (current != null && current.getDirectory() != null) {
                          msg += " '" + current.getDirectory().getName() + "'";
                      }
                      throw new JSchException(msg, e);
                  }
              }
          } finally {
              if (channel != null) {
                  channel.disconnect();
              }
          }
      }
  
      private void sendDirectory(final ChannelSftp channel,
                                 final Directory current)
          throws IOException, SftpException {
          for (final Iterator<File> fileIt = current.filesIterator(); fileIt.hasNext();) {
              sendFileToRemote(channel, fileIt.next(), null);
          }
          for (final Iterator<Directory> dirIt = current.directoryIterator(); dirIt.hasNext();) {
              sendDirectoryToRemote(channel, dirIt.next());
          }
      }
  
      private void sendDirectoryToRemote(final ChannelSftp channel,
                                         final Directory directory)
          throws IOException, SftpException {
          final String dir = directory.getDirectory().getName();
          try {
              channel.stat(dir);
          } catch (final SftpException e) {
              // dir does not exist.
              if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
                  channel.mkdir(dir);
                  channel.chmod(getDirMode(), dir);
              }
          }
          channel.cd(dir);
          sendDirectory(channel, directory);
          channel.cd("..");
      }
  
      private void sendFileToRemote(final ChannelSftp channel,
                                    final File localFile,
                                    String remotePath)
          throws SftpException {
          final long filesize = localFile.length();
  
          if (remotePath == null) {
              remotePath = localFile.getName();
          }
  
          final long startTime = System.currentTimeMillis();
          final long totalLength = filesize;
  
          // only track progress for files larger than 100kb in verbose mode
          final boolean trackProgress = getVerbose() && filesize > HUNDRED_KILOBYTES;
  
          SftpProgressMonitor monitor = null;
          if (trackProgress) {
              monitor = getProgressMonitor();
          }
  
          try {
              if (this.getVerbose()) {
                  log("Sending: " + localFile.getName() + " : " + filesize);
              }
              channel.put(localFile.getAbsolutePath(), remotePath, monitor);
              // set the fileMode on the transferred file. The "remotePath" can potentially be a directory
              // into which the file got transferred, so we can't/shouldn't go ahead and try to change that directory's
              // permissions. Instead we determine the path of the transferred file on remote.
              final String transferredFileRemotePath;
              if (channel.stat(remotePath).isDir()) {
                  // Note: It's correct to use "/" as the file separator without worrying about what the remote
                  // server's file separator is, since the SFTP spec expects "/" to be considered as file path
                  // separator. See section 6.2 "File Names" of the spec, which states:
                  // "This protocol represents file names as strings.  File names are
                  // assumed to use the slash ('/') character as a directory separator."
                  transferredFileRemotePath = remotePath + "/" + localFile.getName();
              } else {
                  transferredFileRemotePath = remotePath;
              }
              if (this.getVerbose()) {
                  log("Setting file mode '" + Integer.toOctalString(getFileMode()) + "' on remote path " + transferredFileRemotePath);
              }
              channel.chmod(getFileMode(), transferredFileRemotePath);
              if (getPreserveLastModified()) {
                  // set the last modified time (seconds since epoch) on the transferred file
                  final int lastModifiedTime = (int) (localFile.lastModified() / 1000L);
                  if (this.getVerbose()) {
                      log("Setting last modified time on remote path " + transferredFileRemotePath + " to " + lastModifiedTime);
                  }
                  channel.setMtime(transferredFileRemotePath, lastModifiedTime);
              }
          } finally {
              if (this.getVerbose()) {
                  final long endTime = System.currentTimeMillis();
                  logStats(startTime, endTime, (int) totalLength);
              }
          }
      }
  
      /**
       * Get the local file.
       * @return the local file.
       */
      @Override
      public File getLocalFile() {
          return localFile;
      }
  
      /**
       * Get the remote path.
       * @return the remote path.
       */
      @Override
      public String getRemotePath() {
          return remotePath;
      }
  
      /**
       * Returns true if the last modified time needs to be preserved on the
       * file(s) that get transferred. Returns false otherwise.
       *
       * @return boolean
       */
      public boolean getPreserveLastModified() {
          return this.preserveLastModified;
      }
  }
  