private bool ConnectCallback(IAsyncResult ar)
{
UdpTrackerAsyncState trackerState = (UdpTrackerAsyncState)ar;
try
{
UdpTrackerMessage msg = Receive(trackerState, trackerState.Data);
if (msg == null)
{
return(false);//bad transaction id
}
ConnectResponseMessage rsp = msg as ConnectResponseMessage;
if (rsp == null)
{
//is there a possibility to have a message which is not error message or connect rsp but udp msg
FailureMessage = ((ErrorMessage)msg).Error;
return(false);//error message
}
connectionId = rsp.ConnectionId;
hasConnected = true;
amConnecting = false;
return(true);
}
catch
{
return(false);
}
}
private void Connect(UdpTrackerAsyncState connectState)
{
connectState.Message = new ConnectMessage();
#if NETSTANDARD1_5
#else
tracker.Connect(Uri.Host, Uri.Port);
#endif
SendAndReceive(connectState);
}
private UdpTrackerMessage Receive(UdpTrackerAsyncState trackerState, byte[] receivedMessage)
{
timeout = 0;//we have receive so unactive the timeout
byte[] data = receivedMessage;
UdpTrackerMessage rsp = UdpTrackerMessage.DecodeMessage(data, 0, data.Length, MessageType.Response);
if (trackerState.Message.TransactionId != rsp.TransactionId)
{
FailureMessage = "Invalid transaction Id in response from udp tracker!";
return(null);//to raise event fail outside
}
return(rsp);
}
private void EndReceiveMessage(IAsyncResult result)
{
UdpTrackerAsyncState trackerState = (UdpTrackerAsyncState)result.AsyncState;
try
{
IPEndPoint endpoint = null;
trackerState.Data = tracker.EndReceive(result, ref endpoint);
trackerState.Callback(trackerState);
}
catch (Exception ex)
{
trackerState.Complete(ex);
}
}
private void SendRequest(UdpTrackerAsyncState requestState)
{
//TODO BeginSend
byte[] buffer = requestState.Message.Encode();
#if NETSTANDARD1_5
tracker.SendAsync(buffer, buffer.Length, endpoint);
#else
tracker.Send(buffer, buffer.Length);
#endif
//response timeout: we try 4 times every 15 sec
ClientEngine.MainLoop.QueueTimeout(RetryDelay, delegate
{
if (timeout == 0)//we receive data
{
return(false);
}
if (timeout <= 4)
{
timeout++;
try
{
#if NETSTANDARD1_5
tracker.SendAsync(buffer, buffer.Length, endpoint);
#else
tracker.Send(buffer, buffer.Length);
#endif
}
catch (Exception ex)
{
timeout = 0;
requestState.Complete(ex);
return(false);
}
}
else
{
timeout = 0;
requestState.Complete(new Exception("Tracker did not respond to the connect requests"));
return(false);
}
return(true);
});
}
private void SendRequest(UdpTrackerAsyncState requestState)
{
Logger.Log(null, "Sending request to udp tracker {0}", Uri);
//TODO BeginSend
byte[] buffer = requestState.Message.Encode();
var sent = tracker.Send(buffer, buffer.Length);
//response timeout: we try 2 times every 10 sec
ClientEngine.MainLoop.QueueTimeout(RetryDelay, delegate
{
if (timeout == 0)//we receive data
{
return(false);
}
if (timeout <= 2)
{
timeout++;
try
{
Logger.Log(null, "Repeating udp tracker request {0}", Uri);
tracker.Send(buffer, buffer.Length);
}
catch (Exception ex)
{
timeout = 0;
requestState.Complete(ex);
return(false);
}
}
else
{
timeout = 0;
Logger.Log(null, "Tracker did not respond to the connect requests {0}", Uri);
requestState.Complete(new Exception("Tracker did not respond to the connect requests"));
return(false);
}
return(true);
});
}
private UdpTrackerMessage Receive(UdpTrackerAsyncState trackerState, byte[] receivedMessage)
{
timeout = 0; //we have receive so unactive the timeout
var data = receivedMessage;
var rsp = UdpTrackerMessage.DecodeMessage(data, 0, data.Length, MessageType.Response);
if (trackerState.Message.TransactionId != rsp.TransactionId)
{
FailureMessage = "Invalid transaction Id in response from udp tracker!";
return null; //to raise event fail outside
}
return rsp;
}
private void SendRequest(UdpTrackerAsyncState requestState)
{
//TODO BeginSend
var buffer = requestState.Message.Encode();
tracker.Send(buffer, buffer.Length);
//response timeout: we try 4 times every 15 sec
ClientEngine.MainLoop.QueueTimeout(RetryDelay, delegate
{
if (timeout == 0) //we receive data
return false;
if (timeout <= 4)
{
timeout++;
try
{
tracker.Send(buffer, buffer.Length);
}
catch (Exception ex)
{
timeout = 0;
requestState.Complete(ex);
return false;
}
}
else
{
timeout = 0;
requestState.Complete(new Exception("Tracker did not respond to the connect requests"));
return false;
}
return true;
});
}
private void SendAndReceive(UdpTrackerAsyncState messageState)
{
timeout = 1;
SendRequest(messageState);
tracker.BeginReceive(EndReceiveMessage, messageState);
}
private void Connect(UdpTrackerAsyncState connectState)
{
connectState.Message = new ConnectMessage();
tracker.Connect(Uri.Host, Uri.Port);
SendAndReceive(connectState);
}
private void SendAndReceive(UdpTrackerAsyncState messageState)
{
timeout = 1;
SendRequest(messageState);
ReceiveAsyncResult = tracker.BeginReceive(EndReceiveMessage, messageState);
}
private void Connect(UdpTrackerAsyncState connectState)
{
connectState.Message = new ConnectMessage();
tracker.Connect(Uri.Host, Uri.Port);
SendAndReceive(connectState);
}
private void SendRequest(UdpTrackerAsyncState requestState)
{
Logger.Info("Sending request to udp tracker {0}", Uri);
//TODO BeginSend
byte[] buffer = requestState.Message.Encode();
var sent = tracker.Send(buffer, buffer.Length);
//response timeout: we try 2 times every 10 sec
ClientEngine.MainLoop.QueueTimeout(RetryDelay, delegate
{
if (timeout == 0)//we receive data
return false;
if (timeout <= 2)
{
timeout++;
try
{
Logger.Warn("Repeating udp tracker request {0}", Uri);
tracker.Send(buffer, buffer.Length);
}
catch (Exception ex)
{
timeout = 0;
requestState.Complete(ex);
return false;
}
}
else
{
timeout = 0;
Logger.Error("Tracker did not respond to the connect requests {0}", Uri);
requestState.Complete(new Exception("Tracker did not respond to the connect requests"));
return false;
}
return true;
});
}
