internal void RunDTPStream(int timeout, DTPStream stream)
{
CheckDisposed();
//------------------------------------------
//Validate input
DTPStreamType dtpType = ValidateInputStream(stream);
//-------------------------------------------
//Allocate data buffer
_wholeTransfered = 0;
if (null == _workBuffer)
{
_workBuffer = new byte[_bufferSize];
}
//--------------------------------------------
//Prevent simultaneous usage
SetProgress(true);
_manuallyClosed = false;
try
{
SetTimeout(timeout);
if (DTPStreamType.ForWriting == dtpType)
{
RunDownloadingStream(stream);
}
else //if(DTPStreamType.ForReading == dtpType)
{
RunUploadingStream(stream);
}
}
catch (SocketException e)
{
if (_aborted)
{
throw new FtpAbortedException();
}
CheckDisposed();
CheckTimeoutException(e);
throw;
}
catch
{
if (_aborted)
{
throw new FtpAbortedException();
}
CheckDisposed();
throw;
//string msg = "Data transfering was unexpectedly interrupted.";
//throw new FtpIOException(msg, e);
}
finally
{
Dispose();
SetProgress(false);
}
}
IAsyncResult BeginRunUploadingStream(DTPStream userStream, AsyncCallback cb, object state)
{
TransStateObjectStream stateObj = new TransStateObjectStream(userStream, cb, state);
userStream.BeginRead(_workBuffer,
0,
_workBuffer.Length,
new AsyncCallback(this.UserStreamRead_End),
stateObj);
return(stateObj);
}
void DataStreamRead_End(IAsyncResult ar)
{
TransStateObjectStream stateObj = (TransStateObjectStream)ar.AsyncState;
try
{
stateObj.UpdateContext();
int num = DataStream.EndRead(ar);
DTPStream userStream = (DTPStream)stateObj.UserStream;
if (num > 0)
{
long require = userStream.AvailableSpace;
if (num > require)
{
num = (int)require;
}
stateObj.Transfered += num;
OnDataTransfered(_workBuffer, num);
//write received data to user stream
userStream.BeginWrite(_workBuffer,
0,
num,
new AsyncCallback(this.UserStreamWrite_End),
stateObj);
}
else
{
userStream.Flush();
OnCompleted();
stateObj.SetCompleted();
}
}
catch (Exception e)
{
stateObj.Exception = e;
stateObj.SetCompleted();
}
catch
{
NSTrace.WriteLineError("Non-CLS exception at: " + Environment.StackTrace);
throw;
}
}
void UserStreamWrite_End(IAsyncResult ar)
{
TransStateObjectStream stateObj = (TransStateObjectStream)ar.AsyncState;
try
{
stateObj.UpdateContext();
DTPStream userStream = (DTPStream)stateObj.UserStream;
userStream.EndWrite(ar);
if (_aborted)
{
throw new FtpAbortedException();
}
if (userStream.AvailableSpace > 0)
{
DataStream.BeginRead(_workBuffer,
0,
_workBuffer.Length,
new AsyncCallback(this.DataStreamRead_End),
stateObj);
}
else
{
_manuallyClosed = true;
userStream.Flush();
OnCompleted();
stateObj.SetCompleted();
}
}
catch (Exception e)
{
stateObj.Exception = e;
stateObj.SetCompleted();
}
catch
{
NSTrace.WriteLineError("Non-CLS exception at: " + Environment.StackTrace);
throw;
}
}
void RunDownloadingStream(DTPStream userStream)
{
bool needMoreData = true;
while (true)
{
int num = DataStream.Read(_workBuffer, 0, _workBuffer.Length);
if (num > 0)
{
long require = userStream.AvailableSpace;
if (num > require)
{
num = (int)require;
needMoreData = false;
}
OnDataTransfered(_workBuffer, num);
userStream.Write(_workBuffer, 0, num);
}
if ((0 == num) || (false == needMoreData))
{
//Determine wether we had read enough information.
//We need to know it, because usually server
//should close connection by him self,
//and if we will do this instead, server will
//return errorneous response later
if (num > 0)
{
_manuallyClosed = true;
}
userStream.Flush();
OnCompleted();
break;
}
else if (_aborted)
{
throw new FtpAbortedException();
}
}
}
DTPStreamType ValidateInputStream(DTPStream stream)
{
//------------------------------------------
//Validate input
if (null == stream)
{
throw new ArgumentNullException("steam", "The value cannot be null.");
}
DTPStreamType dtpType = stream.Type;
if ((DTPStreamType.ForWriting != dtpType) &&
(DTPStreamType.ForReading != dtpType))
{
string msg = string.Format("Unknown DTP type ({0})", stream.Type.ToString());
NSTrace.WriteLineError(msg);
throw new ArgumentException(msg, "type");
}
return(dtpType);
}
void RunUploadingStream(DTPStream userStream)
{
try
{
while (true)
{
if (_aborted)
{
throw new FtpAbortedException();
}
int count = userStream.Read(_workBuffer, 0, _workBuffer.Length);
if (0 == count)
{
OnDataTransfered(null, 0);
OnCompleted();
break;
}
DataStream.Write(_workBuffer, 0, count);
OnDataTransfered(null, count);
if (userStream.AvailableSpace == 0)
{
OnCompleted();
break;
}
}
FinishTransferingStream(DataStream);
}
finally
{
//we need to dispose here to signal server
//about the end of data
Dispose();
}
}
internal TransStateObjectStream(DTPStream stream, AsyncCallback cb, object callerState) : base(cb, callerState)
{
_stream = stream;
}
internal IAsyncResult BeginRunDTPStream(int timeout, DTPStream stream, AsyncCallback cb, object state)
{
CheckDisposed();
//------------------------------------------
//Validate input
DTPStreamType dtpType = ValidateInputStream(stream);
//-------------------------------------------
//Allocate data buffer
_wholeTransfered = 0;
if (null == _workBuffer)
{
_workBuffer = new byte[_bufferSize];
}
//--------------------------------------------
//Prevent simultaneous usage
SetProgress(true);
RunDTPStateObjectStream stateObj = null;
_manuallyClosed = false;
try
{
SetTimeout(timeout);
if (DTPStreamType.ForWriting == dtpType)
{
stateObj = new RunDTPStateObjectStream(true, cb, state);
BeginRunDownloadingStream(stream,
new AsyncCallback(this.DTPFinishedStream),
stateObj);
}
else //if(DTPStreamType.ForReading == stream.Type)
{
stateObj = new RunDTPStateObjectStream(false, cb, state);
BeginRunUploadingStream(stream,
new AsyncCallback(this.DTPFinishedStream),
stateObj);
}
}
catch (SocketException e)
{
SetProgress(false);
if (_aborted)
{
throw new FtpAbortedException();
}
CheckDisposed();
CheckTimeoutException(e);
throw;
}
catch
{
SetProgress(false);
if (_aborted)
{
throw new FtpAbortedException();
}
CheckDisposed();
throw;
}
return(stateObj);
}
