/// <summary>
/// Starts file read (download from device) operation
/// </summary>
/// <param name="in_file_name"></param>
public void FileDownloadStart(string in_file_name, FileTransferCallback in_callback)
{
// sanity check
if (m_file_transfer_state != FileTransferState.Idle)
{
throw new Exception("File transfer already pending.");
}
// initialize file transfer info
m_file_transfer_callback = in_callback;
m_file_transfer_state = FileTransferState.ReadInfo;
m_file_transfer_current_name = in_file_name;
m_file_transfer_current_position = 0;
m_file_transfer_current_size = 0;
UpdateFileTransferState();
// file info packet
PacketFileInfoRequest request_packet = new PacketFileInfoRequest();
request_packet.FileName = in_file_name;
FileOperationStart(request_packet, null);
}
/// <summary>
/// Starts file write (upload to the device) operation
/// </summary>
/// <param name="in_file_id"></param>
/// <param name="in_file_pos"></param>
/// <param name="in_data"></param>
/// <param name="in_callback"></param>
/// <returns></returns>
public void FileUploadStart(byte in_file_id, UInt32 in_file_pos, byte[] in_data, FileTransferCallback in_callback)
{
// sanity check
if (m_file_transfer_state != FileTransferState.Idle)
{
throw new Exception("File transfer already pending.");
}
// init file transfer
m_file_transfer_callback = in_callback;
m_file_transfer_state = FileTransferState.WriteData;
m_file_transfer_current_position = in_file_pos;
m_file_transfer_current_id = in_file_id;
// create write packet
PacketFileDataWriteRequestHeader request_packet;
// create file write packet
request_packet = new PacketFileDataWriteRequestHeader((byte)in_data.Length);
request_packet.ID = m_file_transfer_current_id;
request_packet.Pos = m_file_transfer_current_position;
// starts file operation
FileOperationStart(request_packet, in_data, null);
}
// uploads a file (async)
public bool UploadFileAsync(TransferFile file, bool showProgress,
Uri remotePath, string localPath, FileTransferCallback callback)
{
var files = new List <TransferFile>()
{
file
};
return(TransferFilesAsync(files, showProgress, remotePath, localPath, callback, false));
}
// up- or downloads files (async)
private bool TransferFilesAsync(List <TransferFile> files, bool showProgress,
Uri remotePath, string localPath, FileTransferCallback callback, bool download)
{
// set busy flag
lock (this)
{
if (busy)
{
return(false);
}
if (files.Count == 0)
{
callback.Invoke(FileTransferResult.Success);
return(true);
}
busy = true;
}
totalTransferred = 0;
totalSize = 0;
// calculate total size
foreach (TransferFile file in files)
{
totalSize += file.Size;
}
this.files = files;
this.remotePath = remotePath;
this.localPath = localPath;
this.showProgress = showProgress;
this.callback = callback;
this.download = download;
// select next file
fileEnumerator = files.GetEnumerator();
fileEnumerator.MoveNext();
// check if progress should be displayed
if (showProgress)
{
EnableProgress();
buffer.Clear();
startTime = DateTime.Now;
progressTimer.Start();
}
// up- or download next file
TransferNextFile();
return(true);
}
/// <summary>
/// Send file operation finish request
/// </summary>
/// <param name="in_file_id"></param>
/// <param name="in_request_code"></param>
public void SendFileFinishRequest(FileOperationFinishMode in_finish_mode, FileTransferCallback in_callback)
{
PacketFileOperationFinishedRequest request_packet;
// create packet
request_packet = new PacketFileOperationFinishedRequest();
request_packet.ID = m_file_transfer_current_id;
request_packet.FinishMode = in_finish_mode;
m_file_transfer_callback = in_callback;
FileOperationStart(request_packet, null);
}
// sends an request to the remote server (async)
private void SendRequestAsync(string name, Uri remotePath, FileTransferCallback callback, DelegateRequest caller)
{
try
{
caller.BeginInvoke(name, remotePath,
delegate(IAsyncResult iar)
{
var c = (DelegateRequest)iar.AsyncState;
c.EndInvoke(iar);
callback.Invoke(FileTransferResult.Success);
}, caller);
}
catch (Exception e)
{
ErrorLog.Add(this, e.Message);
callback.Invoke(FileTransferResult.Failure);
}
}
/// <summary>
/// PutUniqueFile overload to easily transfer a file from local to remote.
/// </summary>
/// <param name="localFileName"></param>
/// <param name="remoteFileName"></param>
/// <param name="transferCallback"></param>
public ulong PutUniqueFile(string localFileName, out string remoteFileName, FileTransferCallback transferCallback)
{
using (Stream s = PutUniqueFile(out remoteFileName))
return SendFile(localFileName, remoteFileName, s, transferCallback);
}
/// <summary>
/// AppendFile overload to easily transfer a file from local to remote
/// </summary>
/// <param name="localFileName"></param>
/// <param name="remoteFileName"></param>
public ulong AppendFile(string localFileName, string remoteFileName, FileTransferCallback transferCallback)
{
using (Stream s = AppendFile(remoteFileName))
return SendFile(localFileName, remoteFileName, s, transferCallback);
}
/// <summary>
///
/// </summary>
/// <param name="localDirectoryName"></param>
/// <param name="remoteDirectoryName"></param>
/// <param name="filePattern"></param>
/// <param name="patternStyle"></param>
/// <param name="recursive"></param>
/// <param name="transferCallback"></param>
public void PutFiles(string localDirectoryName, string remoteDirectoryName,
string filePattern, EPatternStyle patternStyle, bool recursive,
FileTransferCallback transferCallback)
{
Regex regex = null;
if (filePattern != null)
{
string fileRegexPattern = GetRegexPattern(filePattern, patternStyle);
regex = new Regex(fileRegexPattern);
}
string previuosDirName = null;
string currRemoteDirectoryName = remoteDirectoryName;
if (currRemoteDirectoryName != null)
{
previuosDirName = GetCurrentDirectory();
EnsureDir(currRemoteDirectoryName, transferCallback);
}
else
currRemoteDirectoryName = GetCurrentDirectory();
string currLocalDirectoryName = localDirectoryName;
if (currLocalDirectoryName == null || currLocalDirectoryName.Length == 0)
currLocalDirectoryName = Directory.GetCurrentDirectory();
string[] dirItems = Directory.GetFiles(currLocalDirectoryName);
foreach (string itemName in dirItems)
{
String fileName = Path.GetFileName(itemName);
if (regex == null || regex.IsMatch(fileName))
{
string remoteFileName = CombineRemotePath(currRemoteDirectoryName, fileName);
PutFile(itemName, remoteFileName, transferCallback);
}
}
if (recursive)
{
dirItems = Directory.GetDirectories(currLocalDirectoryName);
foreach (string itemName in dirItems)
{
string remoteNextDirName = CombineRemotePath(currRemoteDirectoryName, Path.GetFileName(itemName));
PutFiles(itemName, remoteNextDirName, filePattern, patternStyle, recursive, transferCallback);
}
}
if (previuosDirName != null)
SetCurrentDirectory(previuosDirName);
}
/// <summary>
/// Transfers all files, matching the given pattern, from the given remote directory. Optionally recursive
/// </summary>
/// <param name="remoteDirectoryName">Absolute or relative remote path, null indicates the current directory</param>
/// <param name="localDirectoryName">Absolute local path</param>
/// <param name="filePattern">May be null to transfer all files</param>
/// <param name="patternStyle"></param>
/// <param name="recursive"></param>
/// <param name="transferCallback"></param>
/// <remarks>
/// </remarks>
public void GetFiles(string remoteDirectoryName, string localDirectoryName,
string filePattern, EPatternStyle patternStyle, bool recursive,
FileTransferCallback transferCallback)
{
Regex regex = null;
if (filePattern != null)
{
string fileRegexPattern = GetRegexPattern(filePattern, patternStyle);
regex = new Regex(fileRegexPattern);
}
string currLocalDirectoryName = localDirectoryName;
if (currLocalDirectoryName == null || currLocalDirectoryName.Length == 0)
currLocalDirectoryName = Directory.GetCurrentDirectory();
else if (!Directory.Exists(currLocalDirectoryName))
{
// Create local directory if needed
Directory.CreateDirectory(currLocalDirectoryName);
CallTransferCallback(transferCallback, ETransferActions.LocalDirectoryCreated, currLocalDirectoryName, null, 0, null);
}
string currRemoteDirectoryName = remoteDirectoryName;
if (currRemoteDirectoryName == null || currRemoteDirectoryName.Length == 0)
currRemoteDirectoryName = GetCurrentDirectory();
IList<DirectoryListItem> dirList = GetDirectoryList(currRemoteDirectoryName);
// TODO: add SymLink dir recursion check
CheckSymLinks(currRemoteDirectoryName, dirList);
foreach (DirectoryListItem item in dirList)
if (!item.IsDirectory && (regex == null || regex.IsMatch(item.Name)))
{
// Transfer file
string localFilePath = Path.Combine(currLocalDirectoryName, item.Name);
string remoteFilePath = CombineRemotePath(currRemoteDirectoryName, item.Name);
GetFile(remoteFilePath, localFilePath, transferCallback);
}
if (recursive)
foreach (DirectoryListItem item in dirList)
if (item.IsDirectory)
{
// Recursion
string localNextDirPath = Path.Combine(currLocalDirectoryName, item.Name);
string remoteNextDirPath = CombineRemotePath(currRemoteDirectoryName, item.Name);
GetFiles(remoteNextDirPath, localNextDirPath, filePattern, patternStyle, recursive, transferCallback);
}
}
/// <summary>
/// GetFile overload to easily transfer a file from remote to local
/// </summary>
/// <param name="remoteFileName"></param>
/// <param name="localFileName"></param>
/// <param name="transferCallback"></param>
/// <returns>Transferred bytes count.</returns>
public ulong GetFile(string remoteFileName, string localFileName, FileTransferCallback transferCallback)
{
ulong totalBytes = 0;
ulong? fileTransferSize = null;
if (transferCallback != null)
try
{
fileTransferSize = GetFileTransferSize(remoteFileName);
}
catch (FTPCommandException ex)
{
// Give a more detailed description, insteand of, e.g.: "Could not get file size".
if (ex.ErrorCode == 550)
throw new FTPException("Could not get the requested remote file", ex);
else
throw ex;
}
using (Stream s = GetFile(remoteFileName))
{
using (FileStream fs = File.OpenWrite(localFileName))
{
byte[] buf = new byte[1024];
int n = 0;
do
{
CallTransferCallback(transferCallback, ETransferActions.FileDownloadingStatus, localFileName, remoteFileName, totalBytes, fileTransferSize);
n = s.Read(buf, 0, buf.Length);
if (n > 0)
{
fs.Write(buf, 0, n);
totalBytes += (ulong)n;
}
}
while (n > 0);
fs.Close();
}
s.Close();
}
CallTransferCallback(transferCallback, ETransferActions.FileDownloaded, localFileName, remoteFileName, totalBytes, fileTransferSize);
return totalBytes;
}
/// <summary>
/// Check if the given directory exists and create it if it doesn't.
/// </summary>
/// <param name="remoteDirectoryName"></param>
/// <param name="transferCallback"></param>
private void EnsureDir(string remoteDirectoryName, FileTransferCallback transferCallback)
{
try
{
string currDir = GetCurrentDirectory();
SetCurrentDirectory(remoteDirectoryName);
// Ok, the directory exists, set the previous current directory
SetCurrentDirectory(currDir);
}
catch (FTPCommandException ex)
{
if (ex.ErrorCode == 550)
{
MakeDir(remoteDirectoryName);
CallTransferCallback(transferCallback, ETransferActions.RemoteDirectoryCreated, null, remoteDirectoryName, 0, null);
}
else
throw ex;
}
}
private ulong SendFile(string localFileName, string remoteFileName, Stream s, FileTransferCallback transferCallback)
{
ulong totalBytes = 0;
ulong? fileTransferSize = null;
if (transferCallback != null)
fileTransferSize = (ulong)(new FileInfo(localFileName).Length);
using (FileStream fs = File.OpenRead(localFileName))
{
byte[] buf = new byte[1024];
int n = 0;
do
{
CallTransferCallback(transferCallback, ETransferActions.FileUploadingStatus, localFileName, remoteFileName, totalBytes, fileTransferSize);
n = fs.Read(buf, 0, buf.Length);
if (n > 0)
{
s.Write(buf, 0, n);
totalBytes += (ulong)n;
}
}
while (n > 0);
fs.Close();
}
s.Close();
CallTransferCallback(transferCallback, ETransferActions.FileUploaded, localFileName, remoteFileName, totalBytes, fileTransferSize);
return totalBytes;
}
private void CallTransferCallback(FileTransferCallback transferCallback, ETransferActions transferAction,
string localObjectName, string remoteObjectName,
ulong fileTransmittedBytes, ulong? fileTransferSize)
{
if (transferCallback != null)
{
bool cancel = false;
transferCallback(this, transferAction, localObjectName, remoteObjectName, fileTransmittedBytes, fileTransferSize, ref cancel);
if (cancel)
throw new FTPOperationCancelledException("Operation cancelled by the user");
}
}
/// <summary>
/// Transfers all files, matching the given pattern, from the given remote directory. Optionally recursive
/// </summary>
/// <param name="remoteDirectoryName">Absolute or relative remote path, null indicates the current directory</param>
/// <param name="localDirectoryName">Absolute local path</param>
/// <param name="filePattern">May be null to transfer all files</param>
/// <param name="patternStyle"></param>
/// <param name="recursive"></param>
/// <param name="transferCallback"></param>
/// <remarks>
/// </remarks>
public void GetFiles(string remoteDirectoryName, string localDirectoryName,
string filePattern, EPatternStyle patternStyle, bool recursive,
FileTransferCallback transferCallback)
{
GetFiles(remoteDirectoryName, localDirectoryName, filePattern, patternStyle, recursive, transferCallback, new List<string>());
}
public void PutFile(string localFileName, string remoteFilename, FileTransferCallback transferCallback)
{
_client.PutFile(localFileName, remoteFilename, transferCallback);
}
// deletes a remote file (async)
public void DeleteFileAsync(string file, Uri remotePath, FileTransferCallback callback)
{
SendRequestAsync(file, remotePath, callback, new DelegateRequest(DeleteFile));
}
// deletes a remote directory (async)
public void DeleteDirectoryAsync(string directory, Uri remotePath, FileTransferCallback callback)
{
SendRequestAsync(directory, remotePath, callback, new DelegateRequest(DeleteDirectory));
}
// uploads files (async)
public bool UploadFilesAsync(List <TransferFile> files, bool showProgress,
Uri remotePath, string localPath, FileTransferCallback callback)
{
return(TransferFilesAsync(files, showProgress, remotePath, localPath, callback, false));
}
public void PutFiles(string localDirPath, string remotePath, string filePattern, EPatternStyle patternStyle, bool recursive, FileTransferCallback transferCallback)
{
_client.PutFiles(localDirPath, remotePath, filePattern, patternStyle, recursive, transferCallback);
}
private static extern int gci_unregister_file_transfer_notify(FileTransferCallback callback);
