using System;
using Tamir.SharpSsh.jsch;
using System.IO;
using System.Text;
using System.Collections;
/*
* Scp.cs
*
* Copyright (c) 2006 Tamir Gal, http://www.tamirgal.com, All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the distribution.
*
* 3. The names of the authors may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR
* *OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
**/
namespace Tamir.SharpSsh{
/// <summary>
/// Class for handling SCP file transfers over SSH connection.
/// </summary>
public class Scp : SshTransferProtocolBase
{
private bool m_recursive = false;
private bool m_verbos = false;
private bool m_cancelled = false;
public Scp(string host, string user, string password)
: base(host, user, password)
{
}
public Scp(string host, string user)
: base(host, user)
{
}
protected override string ChannelType
{
get { return "exec"; }
}
/// <summary>
///This function is empty, so no channel is connected
///on session connect
/// </summary>
protected override void ConnectChannel()
{
}
/// <summary>
/// Gets or sets a value indicating the default recursive transfer behaviour
/// </summary>
public bool Recursive
{
get{return m_recursive;}
set{m_recursive=value;}
}
/// <summary>
/// Gets or sets a value indicating whether trace information should be printed
/// </summary>
public bool Verbos
{
get{return m_verbos;}
set{m_verbos=value;}
}
public override void Cancel()
{
m_cancelled = true;
}
/// <summary>
/// Creates a directory on the remot server
/// </summary>
/// <param name="dir">The new directory</param>
public override void Mkdir(string dir)
{
SCP_CheckConnectivity();
Channel channel=null;
Stream server = null;
m_cancelled=false;
SCP_ConnectTo(out channel, out server, dir, true);
SCP_EnterIntoDir(server, dir);
channel.disconnect();
}
public override void Put(string fromFilePath, string toFilePath)
{
this.To(fromFilePath, toFilePath);
}
public override void Get(string fromFilePath, string toFilePath)
{
this.From(fromFilePath, toFilePath);
}
/// <summary>
/// Copies a file from local machine to a remote SSH machine.
/// </summary>
/// <param name="localPath">The local file path.</param>
/// <param name="remotePath">The path of the remote file.</param>
public void To(string localPath, string remotePath)
{
this.To(localPath, remotePath, Recursive);
}
/// <summary>
/// Copies a file from local machine to a remote SSH machine.
/// </summary>
/// <param name="localPath">The local file path.</param>
/// <param name="remotePath">The path of the remote file.</param>
public void To(string localPath, string remotePath, bool _recursive)
{
SCP_CheckConnectivity();
Channel channel=null;
Stream server = null;
m_cancelled=false;
try
{
//if we are sending a single file
if(File.Exists(localPath))
{
SCP_ConnectTo(out channel, out server, remotePath, _recursive);
SCP_SendFile(server, localPath, remotePath);
channel.disconnect();
}
//else, if we are sending a local directory
else if(Directory.Exists(localPath))
{
if(!_recursive)
{
throw new SshTransferException(Path.GetFileName("'"+localPath)+"' is a directory, you should use recursive transfer.");
}
SCP_ConnectTo(out channel, out server, remotePath, true);
ToRecursive(server, localPath, remotePath);
channel.disconnect();
}
else
{
throw new SshTransferException("File not found: "+localPath);
}
}
catch(Exception e)
{
if(Verbos)
Console.WriteLine("Error: "+e.Message);
//SendEndMessage(remoteFile, localFile, filesize,filesize, "Transfer ended with an error.");
try{channel.disconnect();}
catch{}
throw e;
}
}
/// <summary>
/// Copies files and directories from local machine to a remote SSH machine using SCP.
/// </summary>
/// <param name="server">I/O Stream for the remote server</param>
/// <param name="src">Source to copy</param>
/// <param name="dst">Destination path</param>
private void ToRecursive(Stream server, string src, string dst)
{
if(Directory.Exists(src))
{
SCP_EnterIntoDir(server, Path.GetFileName(dst));
foreach(string file in Directory.GetFiles(src))
{
SCP_SendFile(server, file, Path.GetFileName( file));
}
if(m_cancelled)
{
return;
}
foreach(string dir in Directory.GetDirectories(src))
{
ToRecursive(server, dir, Path.GetFileName(dir));
}
SCP_EnterIntoParent(server);
}
else if(File.Exists(src))
{
SCP_SendFile(server, src, Path.GetFileName(src));
}
else
{
throw new SshTransferException("File not found: "+src);
}
}
/// <summary>
/// Copies a file from a remote SSH machine to the local machine using SCP.
/// </summary>
/// <param name="remoteFile">The remmote file name</param>
/// <param name="localPath">The local destination path</param>
public void From(string remoteFile, string localPath)
{
this.From(remoteFile, localPath, Recursive);
}
/// <summary>
/// Copies a file from a remote SSH machine to the local machine using SCP.
/// </summary>
/// <param name="remoteFile">The remmote file name</param>
/// <param name="localPath">The local destination path</param>
/// <param name="recursive">Value indicating whether a recursive transfer should take place</param>
public void From(string remoteFile, string localPath, bool _recursive)
{
SCP_CheckConnectivity();
Channel channel=null;
Stream server = null;
m_cancelled=false;
int filesize=0;
String filename=null;
string cmd = null;
try
{
String dir=null;
if(Directory.Exists(localPath))
{
dir= Path.GetFullPath( localPath );
}
SCP_ConnectFrom(out channel, out server, remoteFile, _recursive);
byte[] buf=new byte[1024];
// send '\0'
SCP_SendAck(server);
int c=SCP_CheckAck(server);
//parse scp commands
while((c=='D')||(c=='C')||(c=='E'))
{
if(m_cancelled)
break;
cmd = ""+(char)c;
if(c=='E')
{
c=SCP_CheckAck(server);
dir = Path.GetDirectoryName(dir);
if(Verbos) Console.WriteLine("E");
//send '\0'
SCP_SendAck(server);
c=(char)SCP_CheckAck(server);
continue;
}
// read '0644 ' or '0755 '
server.Read(buf, 0, 5);
for(int i=0;i<5;i++)
cmd+=(char)buf[i];
//reading file size
filesize=0;
while(true)
{
server.Read(buf, 0, 1);
if(buf[0]==' ')break;
filesize=filesize*10+(buf[0]-'0');
}
//reading file name
for(int i=0;;i++)
{
server.Read(buf, i, 1);
if(buf[i]==(byte)0x0a)
{
filename=Util.getString(buf, 0, i);
break;
}
}
cmd += " "+filesize+" "+filename;
// send '\0'
SCP_SendAck(server);
//Receive file
if(c=='C')
{
if(Verbos) Console.WriteLine("Sending file modes: "+cmd);
SCP_ReceiveFile(server, remoteFile,
dir==null?localPath:dir+"/"+filename,
filesize);
if(m_cancelled)
break;
// send '\0'
SCP_SendAck(server);
}
//Enter directory
else if(c=='D')
{
if(dir==null)
{
if(File.Exists(localPath)) throw new SshTransferException("'"+localPath+"' is not a directory");
dir = localPath;
Directory.CreateDirectory(dir);
}
if(Verbos) Console.WriteLine("Entering directory: "+cmd);
dir += "/"+filename;
Directory.CreateDirectory(dir);
}
c=SCP_CheckAck(server);
}
channel.disconnect();
}
catch(Exception e)
{
if(Verbos)
Console.WriteLine("Error: "+e.Message);
try
{
channel.disconnect();
}
catch{}
throw e;
}
}
#region SCP private functions
/// <summary>
/// Checks is a channel is already connected by this instance
/// </summary>
protected void SCP_CheckConnectivity()
{
if(!Connected)
throw new Exception("Channel is down.");
}
/// <summary>
/// Connect a channel to the remote server using the 'SCP TO' command ('scp -t')
/// </summary>
/// <param name="channel">Will contain the new connected channel</param>
/// <param name="server">Will contaun the new connected server I/O stream</param>
/// <param name="rfile">The remote path on the server</param>
/// <param name="recursive">Idicate a recursive scp transfer</param>
protected void SCP_ConnectTo(out Channel channel, out Stream server, string rfile, bool recursive)
{
string scpCommand = "scp -p -t ";
if(recursive) scpCommand += "-r ";
scpCommand += "\""+rfile+"\"";
channel = (ChannelExec)m_session.openChannel(ChannelType);
((ChannelExec)channel).setCommand(scpCommand);
server =
new Tamir.Streams.CombinedStream
(channel.getInputStream(), channel.getOutputStream());
channel.connect();
SCP_CheckAck(server);
}
/// <summary>
/// Connect a channel to the remote server using the 'SCP From' command ('scp -f')
/// </summary>
/// <param name="channel">Will contain the new connected channel</param>
/// <param name="server">Will contaun the new connected server I/O stream</param>
/// <param name="rfile">The remote path on the server</param>
/// <param name="recursive">Idicate a recursive scp transfer</param>
protected void SCP_ConnectFrom(out Channel channel, out Stream server, string rfile, bool recursive)
{
string scpCommand = "scp -f ";
if(recursive) scpCommand += "-r ";
scpCommand += "\""+rfile+"\"";
channel = (ChannelExec)m_session.openChannel(ChannelType);
((ChannelExec)channel).setCommand(scpCommand);
server =
new Tamir.Streams.CombinedStream
(channel.getInputStream(), channel.getOutputStream());
channel.connect();
//SCP_CheckAck(server);
}
/// <summary>
/// Transfer a file to the remote server
/// </summary>
/// <param name="server">A connected server I/O stream</param>
/// <param name="src">The source file to copy</param>
/// <param name="dst">The remote destination path</param>
protected void SCP_SendFile(Stream server, string src, string dst)
{
int filesize = 0;
int copied = 0;
filesize=(int)(new FileInfo(src)).Length;
byte[] tmp=new byte[1];
// send "C0644 filesize filename", where filename should not include '/'
string command="C0644 "+filesize+" "+Path.GetFileName(dst)+"\n";
if(Verbos) Console.WriteLine("Sending file modes: "+command);
SendStartMessage(src, dst, filesize, "Starting transfer.");
byte[] buff = Util.getBytes(command);
server.Write(buff, 0, buff.Length); server.Flush();
if(SCP_CheckAck(server)!=0)
{
throw new SshTransferException("Error openning communication channel.");
}
// send a content of lfile
SendProgressMessage(src, dst, copied, filesize, "Transferring...");
FileStream fis=File.OpenRead(src);
byte[] buf=new byte[1024*10*2];
while(!m_cancelled)
{
int len=fis.Read(buf, 0, buf.Length);
if(len<=0) break;
server.Write(buf, 0, len); server.Flush();
copied += len;
SendProgressMessage(src, dst, copied, filesize, "Transferring...");
}
fis.Close();
if(m_cancelled)
return;
// send '\0'
buf[0]=0; server.Write(buf, 0, 1); server.Flush();
SendProgressMessage(src, dst, copied, filesize, "Verifying transfer...");
if(SCP_CheckAck(server)!=0)
{
SendEndMessage(src, dst,copied,filesize, "Transfer ended with an error.");
throw new SshTransferException("Unknow error during file transfer.");
}
SendEndMessage(src, dst, copied, filesize, "Transfer completed successfuly ("+copied+" bytes).");
}
/// <summary>
/// Transfer a file from the remote server
/// </summary>
/// <param name="server">A connected server I/O stream</param>
/// <param name="rfile">The remote file to copy</param>
/// <param name="lfile">The local destination path</param>
protected void SCP_ReceiveFile(Stream server, string rfile, string lfile, int size)
{
int copied = 0;
SendStartMessage(rfile, lfile, size, "Connected, starting transfer.");
// read a content of lfile
FileStream fos=File.OpenWrite(lfile);
int foo;
int filesize=size;
byte[] buf = new byte[1024];
while(!m_cancelled)
{
if(buf.Length<filesize) foo=buf.Length;
else foo=filesize;
int len=server.Read(buf, 0, foo);
copied += len;
fos.Write(buf, 0, foo);
SendProgressMessage(rfile, lfile, copied, size, "Transferring...");
filesize-=foo;
if(filesize==0) break;
}
fos.Close();
if(m_cancelled)
return;
SCP_CheckAck(server);
SendEndMessage(rfile, lfile, copied, size, "Transfer completed successfuly ("+filesize+" bytes).");
}
/// <summary>
/// Instructs the remote server to enter into a directory
/// </summary>
/// <param name="server">A connected server I/O stream</param>
/// <param name="dir">The directory name/param>
protected void SCP_EnterIntoDir(Stream server, string dir)
{
try
{
byte[] tmp=new byte[1];
// send "C0644 filesize filename", where filename should not include '/'
string command="D0755 0 "+Path.GetFileName(dir)+"\n";
if(Verbos) Console.WriteLine("Enter directory: "+command);
byte[] buff = Util.getBytes(command);
server.Write(buff, 0, buff.Length); server.Flush();
if(SCP_CheckAck(server)!=0)
{
throw new SshTransferException("Error openning communication channel.");
}
}
catch{}
}
/// <summary>
/// Instructs the remote server to go up one level
/// </summary>
/// <param name="server">A connected server I/O stream</param>
protected void SCP_EnterIntoParent(Stream server)
{
try
{
byte[] tmp=new byte[1];
// send "C0644 filesize filename", where filename should not include '/'
string command="E\n";
if(Verbos) Console.WriteLine(command);
byte[] buff = Util.getBytes(command);
server.Write(buff, 0, buff.Length); server.Flush();
if(SCP_CheckAck(server)!=0)
{
throw new SshTransferException("Error openning communication channel.");
}
}
catch{}
}
/// <summary>
/// Gets server acknowledgment
/// </summary>
/// <param name="ins">A connected server I/O stream</param>
private int SCP_CheckAck(Stream ins)
{
int b=ins.ReadByte();
// b may be 0 for success,
// 1 for error,
// 2 for fatal error,
// -1
if(b==0) return b;
if(b==-1) return b;
if(b==1 || b==2)
{
StringBuilder sb=new StringBuilder();
int c;
do
{
c=ins.ReadByte();
sb.Append((char)c);
}
while(c!='\n');
if(b==1)
{ // error
//Console.WriteLine(sb.ToString());
throw new SshTransferException(sb.ToString());
}
if(b==2)
{ // fatal error
//Console.WriteLine(sb.ToString());
throw new SshTransferException(sb.ToString());
}
}
return b;
}
/// <summary>
/// Sends acknowledgment to remote server
/// </summary>
/// <param name="server">A connected server I/O stream</param>
private void SCP_SendAck(Stream server)
{
server.WriteByte(0);
server.Flush();
}
#endregion SCP private functions
}
}
|