public void TestUserReportedError2(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
FtpsClient ftp = new FtpsClient("127.0.0.1", port, protocol);
ftp.AlwaysAcceptServerCertificate = true;
ftp.Open("test", "test");
ftp.GetFile("luna.h", "luna1-2.h", FileAction.Create);
ftp.Close();
}
public void TestAbort(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
c.Abort();
}
}
public void TestGetFileInfo(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, ListingMethod method)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
Debug.WriteLine("********** BEGINNING **********");
c.AlwaysAcceptServerCertificate = true;
c.DirListingMethod = method;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
// get information about the root directory
FtpsItem m = c.GetFileInfo(".");
if (m is FtpsMlsxItem)
Debug.Write(((FtpsMlsxItem)m).ToString());
else
Debug.Write(m.ToString());
Debug.WriteLine("********** ENDING **********");
}
}
public void TestGetDirList(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
FtpsItemCollection lst = c.GetDirList();
Debug.WriteLine("===================================================");
Debug.WriteLine("DIRECTORY DUMP");
Debug.WriteLine("===================================================");
foreach (FtpsItem item in lst)
{
Debug.WriteLine(item.RawText);
Debug.WriteLine(item.ToString());
}
Debug.WriteLine("===================================================");
}
}
public void TestPutFileResumeCreate(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int fileSize)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
MemoryStream m1 = GetRandom(fileSize);
MemoryStream m2 = GetRandom(fileSize);
string fname = GetGuidString();
try
{
// attempt to put a new file on the system which will result in
// no resume action but rather a create action to be performed
c.PutFile(m1, fname, FileAction.ResumeOrCreate);
Assert.IsTrue(c.Exists(fname));
MemoryStream o1 = new MemoryStream();
c.GetFile(fname, o1, false);
o1.Position = 0;
//compare bytes to verify
Assert.IsTrue(Compare(m1, o1));
// try to resume the file after it has already been transmitted
// this should result in a test on the file lengths and no action
// being performed by the FTP client
c.PutFile(m1, fname, FileAction.Resume);
}
finally
{
c.DeleteFile(fname);
}
}
}
public void TestPutFileResume(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int fileSize)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
MemoryStream m1 = GetRandom(fileSize);
MemoryStream m2 = GetRandom(fileSize);
byte[] a = m1.ToArray();
byte[] b = m2.ToArray();
byte[] l = new byte[a.Length + b.Length];
Array.Copy(a, l, a.Length);
Array.Copy(b, 0, l, a.Length, b.Length);
// m3 is m1 + m2
MemoryStream m3 = new MemoryStream(l);
string fname = GetGuidString();
try
{
c.PutFile(m1, fname, FileAction.Create);
Assert.IsTrue(c.Exists(fname));
MemoryStream o1 = new MemoryStream();
c.GetFile(fname, o1, false);
o1.Position = 0;
//compare bytes to verify
Assert.IsTrue(Compare(m1, o1));
// put m3 as a resume file
c.PutFile(m3, fname, FileAction.Resume);
Assert.IsTrue(c.Exists(fname));
MemoryStream o2 = new MemoryStream();
c.GetFile(fname, o2, false);
o1.Position = 0;
//compare bytes to verify
Assert.IsTrue(Compare(m3, o2));
}
finally
{
c.DeleteFile(fname);
}
}
}
public void TestPutFileCreateNew(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int fileSize)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
MemoryStream m1 = GetRandom(fileSize);
MemoryStream m2 = GetRandom(fileSize);
string fname = GetGuidString();
bool fail = false;
try
{
c.PutFile(m1, fname, FileAction.Create);
Assert.IsTrue(c.Exists(fname));
MemoryStream o1 = new MemoryStream();
c.GetFile(fname, o1, false);
o1.Position = 0;
//compare bytes to verify
Assert.IsTrue(Compare(m1, o1));
c.PutFile(m1, fname, FileAction.Create);
try
{
// put a second time which should cause an exception to be thrown
// since there is an existing file already on the server
c.PutFile(m1, fname, FileAction.CreateNew);
}
catch (FtpsDataTransferException)
{
fail = true;
}
Assert.IsTrue(fail);
}
finally
{
c.DeleteFile(fname);
}
}
}
public void TestPutFileCreateOrAppend(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int fileSize)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
MemoryStream m1 = GetRandom(fileSize);
MemoryStream m2 = GetRandom(fileSize);
string fname = GetGuidString();
try
{
c.PutFile(m1, fname, FileAction.Create);
Assert.IsTrue(c.Exists(fname));
MemoryStream o1 = new MemoryStream();
c.GetFile(fname, o1, false);
o1.Position = 0;
//compare bytes to verify
Assert.IsTrue(Compare(m1, o1));
// put a second file which should append to the first file
c.PutFile(m2, fname, FileAction.CreateOrAppend);
Assert.IsTrue(c.Exists(fname));
MemoryStream o2 = new MemoryStream();
c.GetFile(fname, o2, false);
o1.Position = 0;
//compare bytes to verify m1 and m2 were appended together
Assert.IsTrue(Compare(m1, m2, o2));
}
finally
{
c.DeleteFile(fname);
}
}
}
public void TestGetSystemType(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
string r = c.GetSystemType();
Assert.IsNotNullOrEmpty(r);
Debug.WriteLine("RESULT: " + r);
}
}
public void TestPutFileUnique(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
byte[] bytes = new byte[1024];
MemoryStream m = new MemoryStream(bytes);
string fname = c.PutFileUnique(m);
c.DeleteFile(fname);
}
}
public void TestRepeatedOpen(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int connections)
{
for (int i = 0; i < connections; i++)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
Debug.WriteLine("********** START **********");
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
Debug.WriteLine("********** PASSED **********");
}
}
}
public void TestMultiOpen(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server, int connections)
{
FtpsClient[] lst = new FtpsClient[connections];
for(int i=0; i< lst.Length; i++)
{
FtpsClient c = new FtpsClient(host, port, protocol);
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
lst[i] = c;
}
for (int i = 0; i < lst.Length; i++)
{
lst[i].Close();
}
}
public void TestChangeDirectory(string host, int port, FtpsSecurityProtocol protocol,
string user, string pwd, string server)
{
using (FtpsClient c = new FtpsClient(host, port, protocol))
{
c.AlwaysAcceptServerCertificate = true;
c.Open(user, pwd);
Assert.IsTrue(c.IsConnected);
string dir1 = Guid.NewGuid().ToString();
string dir2 = Guid.NewGuid().ToString();
string dir3 = Guid.NewGuid().ToString();
string dir4 = Guid.NewGuid().ToString();
// create the directories and change into them
c.MakeDirectory(dir1);
c.ChangeDirectory(dir1);
c.MakeDirectory(dir2);
c.ChangeDirectory(dir2);
c.MakeDirectory(dir3);
c.ChangeDirectory(dir3);
c.MakeDirectory(dir4);
c.ChangeDirectoryUp();
c.ChangeDirectoryUp();
c.ChangeDirectoryUp();
c.ChangeDirectoryUp();
// try changing directory using a full path which does
// not work for all FTP servers
c.ChangeDirectory(String.Format("{0}/{1}/{2}/{3}", dir1, dir2, dir3, dir4));
c.ChangeDirectory("//");
// try changing directory using multipath command which should work
// for all FTP servers
c.ChangeDirectoryMultiPath(String.Format("{0}/{1}/{2}/{3}", dir1, dir2, dir3, dir4));
c.ChangeDirectoryUp();
// delete the temporary directories
c.DeleteDirectory(dir4);
c.ChangeDirectoryUp();
c.DeleteDirectory(dir3);
c.ChangeDirectoryUp();
c.DeleteDirectory(dir2);
c.ChangeDirectoryUp();
c.DeleteDirectory(dir1);
}
}
/// <summary>
/// Asynchronous File Exchange Protocol (FXP) allows server-to-server transfer which can greatly speed up file transfers.
/// </summary>
/// <param name="fileName">The name of the file to transfer.</param>
/// <param name="destination">The destination FTP server which must be supplied as an open and connected FtpsClient object.</param>
/// <remarks>
/// Both servers must support and have FXP enabled before you can transfer files between two remote servers using FXP. One FTP server must support PASV mode and the other server must allow PORT commands from a foreign address. Finally, firewall settings may interfer with the ability of one server to access the other server.
/// Starksoft FtpsClient will coordinate the FTP negoitaion and necessary PORT and PASV transfer commands.
/// </remarks>
/// <seealso cref="FxpCopyAsyncCompleted"/>
/// <seealso cref="FxpTransferTimeout"/>
/// <seealso cref="FxpCopy"/>
/// <seealso cref="FtpsBase.CancelAsync"/>
public void FxpCopyAsync(string fileName, FtpsClient destination)
{
if (base.AsyncWorker != null && base.AsyncWorker.IsBusy)
throw new InvalidOperationException("The FtpsClient object is already busy executing another asynchronous operation. You can only execute one asychronous method at a time.");
base.CreateAsyncWorker();
base.AsyncWorker.WorkerSupportsCancellation = true;
base.AsyncWorker.DoWork += new DoWorkEventHandler(FxpCopyAsync_DoWork);
base.AsyncWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(FxpCopyAsync_RunWorkerCompleted);
Object[] args = new Object[2];
args[0] = fileName;
args[1] = destination;
base.AsyncWorker.RunWorkerAsync(args);
}
/// <summary>
/// File Exchange Protocol (FXP) allows server-to-server transfer which can greatly speed up file transfers.
/// </summary>
/// <param name="fileName">The name of the file to transfer.</param>
/// <param name="destination">The destination FTP server which must be supplied as an open and connected FtpsClient object.</param>
/// <remarks>
/// Both servers must support and have FXP enabled before you can transfer files between two remote servers using FXP. One FTP server must support PASV mode and the other server must allow PORT commands from a foreign address. Finally, firewall settings may interfer with the ability of one server to access the other server.
/// Starksoft FtpsClient will coordinate the FTP negoitaion and necessary PORT and PASV transfer commands.
/// </remarks>
/// <seealso cref="FxpTransferTimeout"/>
/// <seealso cref="FxpCopyAsync"/>
public void FxpCopy(string fileName, FtpsClient destination)
{
if (this.IsConnected == false)
throw new FtpsException("The connection must be open before a transfer between servers can be intitiated.");
if (destination == null)
throw new ArgumentNullException("destination");
if (destination.IsConnected == false)
throw new FtpsException("The destination object must be open and connected before a transfer between servers can be intitiated.");
if (String.IsNullOrEmpty(fileName))
throw new ArgumentException("must have a value", "fileName");
// send command to destination FTP server to get passive port to be used from the source FTP server
try
{
destination.SendRequest(new FtpsRequest(base.Encoding, FtpsCmd.Pasv));
}
catch (FtpsException fex)
{
throw new FtpsException(String.Format("An error occurred when trying to set up the passive connection on '{1}' for a destination to destination copy between '{0}' and '{1}'.", this.Host, destination.Host), base.LastResponse, fex);
}
// get the begin and end positions to extract data from the response string
int startIdx = destination.LastResponse.Text.IndexOf("(") + 1;
int endIdx = destination.LastResponse.Text.IndexOf(")");
string dataPortInfo = destination.LastResponse.Text.Substring(startIdx, endIdx - startIdx);
// send a command to the source server instructing it to connect to
// the local ip address and port that the destination server will be bound to
try
{
this.SendRequest(new FtpsRequest(base.Encoding, FtpsCmd.Port, dataPortInfo));
}
catch (FtpsException fex)
{
throw new FtpsException(String.Format("Command instructing '{0}' to open connection failed.", this.Host), base.LastResponse, fex);
}
// send command to tell the source server to retrieve the file from the destination server
try
{
this.SendRequest(new FtpsRequest(base.Encoding, FtpsCmd.Retr, fileName));
}
catch (FtpsException fex)
{
throw new FtpsException(String.Format("An error occurred transfering on a server to server copy between '{0}' and '{1}'.", this.Host, destination.Host), base.LastResponse, fex);
}
// send command to tell the destination to store the file
try
{
destination.SendRequest(new FtpsRequest(base.Encoding, FtpsCmd.Stor, fileName));
}
catch (FtpsException fex)
{
throw new FtpsException(String.Format("An error occurred transfering on a server to server copy between '{0}' and '{1}'.", this.Host, destination.Host), base.LastResponse, fex);
}
// wait until we get a file completed response back from the destination server and the source server
destination.WaitForHappyCodes(this.FxpTransferTimeout, FtpsResponseCode.RequestedFileActionOkayAndCompleted, FtpsResponseCode.ClosingDataConnection);
this.WaitForHappyCodes(this.FxpTransferTimeout, FtpsResponseCode.RequestedFileActionOkayAndCompleted, FtpsResponseCode.ClosingDataConnection);
}
