void ThreadEntry()
{
int threadLoopCounter = 0;
while (!_disposing)
{
try
{ // every 100ms (approximately)
if (threadLoopCounter % 10 == 0)
{ // every 1 sec
SendHelloRequestsToPeers();
SharedPeers();
}
if (threadLoopCounter % 100 == 0)
{
CleanObsoleteConnectedPeers();
}
foreach (var ext in _localPeer.Configuration.Extensions)
{
ext.OnTimer100msApprox();
}
_actionsQueue.ExecuteQueued();
}
catch (Exception exc)
{
_localPeer.HandleException(LogModules.GeneralManager, exc);
}
Thread.Sleep(100);
threadLoopCounter++;
}
}
public SocketWithReceiver(LocalPeer localPeer, UdpClient udpSocket)
{
_localPeer = localPeer;
_actionsQueue = new ActionsQueue(exc => _localPeer.HandleException(LogModules.GeneralManager, exc), new ExecutionTimeStatsCollector(() => localPeer.DateTimeNow));
UdpSocket = udpSocket;
_thread = new Thread(ThreadEntry);
_thread.Name = "receiver " + LocalEndPointString;
_thread.Priority = ThreadPriority.Highest;
_thread.Start();
}
public SocketWithReceiver(LocalPeer localPeer, UdpClient udpSocket)
{
_localPeer = localPeer;
_actionsQueue = new ActionsQueue(exc => _localPeer.HandleException(LogModules.GeneralManager, exc));
UdpSocket = udpSocket;
_thread = new Thread(ThreadEntry);
_thread.Name = LocalEndPointString;
_thread.Priority = ThreadPriority.Highest;
_thread.Start();
}
async Task <string> SendHttpRequestAsync(string url)
{
try
{
var httpClient = new HttpClient();
httpClient.Timeout = TimeSpan.FromSeconds(3);
var response = await httpClient.GetAsync(url);
var result = await response.Content.ReadAsStringAsync();
return(result);
}
catch (Exception exc)
{
_localPeer.HandleException(LogModules.IpLocationScraper, exc, $"request to {url} failed: ");
return(null);
}
}
public Manager(LocalPeer localPeer)
{
_localPeer = localPeer;
localPeer.Manager = this;
_actionsQueue = new ActionsQueue(exc => _localPeer.HandleException(LogModules.GeneralManager, exc), new ExecutionTimeStatsCollector(() => localPeer.DateTimeNow));
if (_localPeer.Configuration.Coordinators != null)
{
// connect to coordinator peers
foreach (var serverEP in _localPeer.Configuration.Coordinators)
{
AddToPendingPeers(ConnectedPeerType.toConfiguredServer, serverEP, GetSocketForNewOutgoingStream());
}
}
_thread = new Thread(ThreadEntry);
_thread.Name = "manager thread";
_thread.Start();
}
/// <summary>
/// begins scraping asynchronously
/// </summary>
public IpLocationScraper(string localPublicIp, LocalPeer localPeer)
{
_localPeer = localPeer;
_localPublicIp = localPublicIp;
#if DEBUG
if (_localPublicIp == "127.0.0.1")
{
_localPublicIp = "8.8.8.8";
}
#endif
try
{
SendHttpRequestsAsync();
}
catch (Exception exc)
{
localPeer.HandleException(LogModules.IpLocationScraper, exc);
}
}
void ThreadEntry()
{
IPEndPoint remoteEndpoint = default(IPEndPoint);
while (!_disposing)
{
try
{
_actionsQueue.ExecuteQueued();
var udpData = UdpSocket.Receive(ref remoteEndpoint);
var timestamp32 = _localPeer.Time32;
if (_previousTimestamp32.HasValue)
{
var timePassed32 = unchecked (timestamp32 - _previousTimestamp32.Value);
_pps.Input(1, timePassed32);
_bps.Input((udpData.Length + LocalLogicConfiguration.IpAndUdpHeadersSizeBytes) * 8, timePassed32);
}
_previousTimestamp32 = timestamp32;
var manager = _localPeer.Manager;
if (manager != null && _localPeer.Firewall.PacketIsAllowed(remoteEndpoint) && udpData.Length > 4)
{
if (udpData[0] == (byte)PacketTypes.NatTest1Request)
{
manager.ProcessReceivedNat1TestRequest(this, udpData, remoteEndpoint);
return;
}
var packetType = P2ptpCommon.DecodeHeader(udpData);
if (packetType.HasValue)
{
switch (packetType.Value)
{
case PacketTypes.hello:
manager.ProcessReceivedHello(udpData, remoteEndpoint, this, timestamp32);
break;
case PacketTypes.peersListIpv4:
manager.ProcessReceivedSharedPeers(udpData, remoteEndpoint);
break;
case PacketTypes.extensionSignaling:
manager.ProcessReceivedExtensionSignalingPacket(BinaryProcedures.CreateBinaryReader(udpData, P2ptpCommon.HeaderSize), remoteEndpoint);
break;
}
}
else
{
(var extension, var streamId, var index) = ExtensionProcedures.ParseReceivedExtensionPayloadPacket(udpData, _localPeer.Configuration.Extensions);
if (extension != null)
{
if (_streams.TryGetValue(streamId, out var stream))
{
stream.Extensions.TryGetValue(extension, out var streamExtension);
streamExtension.OnReceivedPayloadPacket(udpData, index);
}
//else _localPeer.WriteToLog(LogModules.Receiver, $"receiver {SocketInfo} got packet from bad stream id {streamId}");
}
}
}
}
// catch (InvalidOperationException)
// {// intentionally ignored (before "connection")
// }
catch (SocketException exc)
{
if (_disposing)
{
return;
}
if (exc.ErrorCode != 10054) // forcibly closed - ICMP port unreachable - it is normal when peer gets down
{
_localPeer.HandleException(LogModules.Receiver, exc);
}
// else ignore it
}
catch (Exception exc)
{
_localPeer.HandleException(LogModules.Receiver, exc);
}
}
}
