public IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (receiveResult != null)
{
throw new InvalidOperationException("Cannot call BeginReceive twice");
}
receiveResult = new HttpResult(callback, state, buffer, offset, count);
try
{
// BeginReceive has been called *before* we have sent a piece request.
// Wait for a piece request to be sent before allowing this to complete.
if (dataStream == null)
{
return(receiveResult);
}
DoReceive();
return(receiveResult);
}
catch (Exception ex)
{
if (sendResult != null)
{
sendResult.Complete(ex);
}
if (receiveResult != null)
{
receiveResult.Complete(ex);
}
}
return(receiveResult);
}
public IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (receiveResult != null)
throw new InvalidOperationException("Cannot call BeginReceive twice");
receiveResult = new HttpResult(callback, state, buffer, offset, count);
try
{
// BeginReceive has been called *before* we have sent a piece request.
// Wait for a piece request to be sent before allowing this to complete.
if (dataStream == null)
return receiveResult;
DoReceive();
return receiveResult;
}
catch (Exception ex)
{
if (sendResult != null)
sendResult.Complete(ex);
if (receiveResult != null)
receiveResult.Complete(ex);
}
return receiveResult;
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (sendResult != null)
{
throw new InvalidOperationException("Cannot call BeginSend twice");
}
sendResult = new HttpResult(callback, state, buffer, offset, count);
try
{
List <PeerMessage> bundle = DecodeMessages(buffer, offset, count);
if (bundle == null)
{
sendResult.Complete(count);
}
else if (bundle.TrueForAll(delegate(PeerMessage m) { return(m is RequestMessage); }))
{
#if NETSTANDARD1_5
var mesList = bundle.ConvertAll <PeerMessage, RequestMessage>(delegate(PeerMessage m) { return((RequestMessage)m); });
#else
var mesList = bundle.ConvertAll <RequestMessage> (delegate(PeerMessage m) { return((RequestMessage)m); });
#endif
requestMessages.AddRange(mesList);
// The RequestMessages are always sequential
RequestMessage start = (RequestMessage)bundle[0];
RequestMessage end = (RequestMessage)bundle[bundle.Count - 1];
CreateWebRequests(start, end);
KeyValuePair <WebRequest, int> r = webRequests.Dequeue();
totalExpected = r.Value;
BeginGetResponse(r.Key, getResponseCallback, r.Key);
}
else
{
sendResult.Complete(count);
}
}
catch (Exception ex)
{
sendResult.Complete(ex);
}
return(sendResult);
}
private void ReceivedChunk(IAsyncResult result)
{
if (disposed)
{
return;
}
try
{
int received = dataStream.EndRead(result);
if (received == 0)
{
throw new WebException("No futher data is available");
}
receiveResult.BytesTransferred += received;
currentRequest.TotalReceived += received;
// We've received everything for this piece, so null it out
if (currentRequest.Complete)
{
currentRequest = null;
}
totalExpected -= received;
receiveResult.Complete();
}
catch (Exception ex)
{
receiveResult.Complete(ex);
}
finally
{
// If there are no more requests pending, complete the Send call
if (currentRequest == null && requestMessages.Count == 0)
{
RequestCompleted();
}
}
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_sendResult != null)
{
throw new InvalidOperationException("Cannot call BeginSend twice");
}
_sendResult = new HttpResult(callback, state, buffer, offset, count);
try
{
var bundle = DecodeMessages(buffer, offset, count);
if (bundle == null)
{
_sendResult.Complete(count);
}
else if (bundle.TrueForAll(m => m is RequestMessage))
{
_requestMessages.AddRange(bundle.Cast <RequestMessage>());
// The RequestMessages are always sequential
var start = (RequestMessage)bundle[0];
var end = (RequestMessage)bundle[bundle.Count - 1];
CreateWebRequests(start, end);
var r = _webRequests.Dequeue();
_totalExpected = r.Value;
BeginGetResponse(r.Key, _getResponseCallback, r.Key);
}
else
{
_sendResult.Complete(count);
}
}
catch (Exception ex)
{
_sendResult.Complete(ex);
}
return(_sendResult);
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (sendResult != null)
throw new InvalidOperationException("Cannot call BeginSend twice");
sendResult = new HttpResult(callback, state, buffer, offset, count);
try
{
List<PeerMessage> bundle = DecodeMessages(buffer, offset, count);
if (bundle == null)
{
sendResult.Complete(count);
}
else if (bundle.TrueForAll(delegate(PeerMessage m) { return m is RequestMessage; }))
{
requestMessages.AddRange(bundle.ConvertAll<RequestMessage>(delegate(PeerMessage m) { return (RequestMessage)m; }));
// The RequestMessages are always sequential
RequestMessage start = (RequestMessage)bundle[0];
RequestMessage end = (RequestMessage)bundle[bundle.Count - 1];
CreateWebRequests(start, end);
KeyValuePair<WebRequest, int> r = webRequests.Dequeue();
totalExpected = r.Value;
BeginGetResponse(r.Key, getResponseCallback, r.Key);
}
else
{
sendResult.Complete(count);
}
}
catch (Exception ex)
{
sendResult.Complete(ex);
}
return sendResult;
}
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_sendResult != null)
throw new InvalidOperationException("Cannot call BeginSend twice");
_sendResult = new HttpResult(callback, state, buffer, offset, count);
try
{
var bundle = DecodeMessages(buffer, offset, count);
if (bundle == null)
{
_sendResult.Complete(count);
}
else if (bundle.TrueForAll(m => m is RequestMessage))
{
_requestMessages.AddRange(bundle.Cast<RequestMessage>());
// The RequestMessages are always sequential
var start = (RequestMessage) bundle[0];
var end = (RequestMessage) bundle[bundle.Count - 1];
CreateWebRequests(start, end);
var r = _webRequests.Dequeue();
_totalExpected = r.Value;
BeginGetResponse(r.Key, _getResponseCallback, r.Key);
}
else
{
_sendResult.Complete(count);
}
}
catch (Exception ex)
{
_sendResult.Complete(ex);
}
return _sendResult;
}
private void DoReceive()
{
byte[] buffer = receiveResult.Buffer;
int offset = receiveResult.Offset;
int count = receiveResult.Count;
if (currentRequest == null && requestMessages.Count > 0)
{
currentRequest = new HttpRequestData(requestMessages[0]);
requestMessages.RemoveAt(0);
}
if (totalExpected == 0)
{
if (webRequests.Count == 0)
{
sendResult.Complete(sendResult.Count);
}
else
{
KeyValuePair <WebRequest, int> r = webRequests.Dequeue();
totalExpected = r.Value;
BeginGetResponse(r.Key, getResponseCallback, r.Key);
}
return;
}
if (!currentRequest.SentLength)
{
// The message length counts as the first four bytes
currentRequest.SentLength = true;
currentRequest.TotalReceived += 4;
Message.Write(receiveResult.Buffer, receiveResult.Offset, currentRequest.TotalToReceive - currentRequest.TotalReceived);
receiveResult.Complete(4);
return;
}
else if (!currentRequest.SentHeader)
{
currentRequest.SentHeader = true;
// We have *only* written the messageLength to the stream
// Now we need to write the rest of the PieceMessage header
int written = 0;
written += Message.Write(buffer, offset + written, PieceMessage.MessageId);
written += Message.Write(buffer, offset + written, CurrentRequest.Request.PieceIndex);
written += Message.Write(buffer, offset + written, CurrentRequest.Request.StartOffset);
count -= written;
offset += written;
receiveResult.BytesTransferred += written;
currentRequest.TotalReceived += written;
}
int received = dataStream.Read(buffer, offset, count);
if (disposed)
{
return;
}
try
{
if (received == 0)
{
throw new WebException("No futher data is available");
}
receiveResult.BytesTransferred += received;
currentRequest.TotalReceived += received;
// We've received everything for this piece, so null it out
if (currentRequest.Complete)
{
currentRequest = null;
}
totalExpected -= received;
receiveResult.Complete();
}
catch (Exception ex)
{
receiveResult.Complete(ex);
}
finally
{
// If there are no more requests pending, complete the Send call
if (currentRequest == null && requestMessages.Count == 0)
{
RequestCompleted();
}
}
}
