private void Announce(BinaryNumber[] networkIDs, NetworkInfo[] networks, int times)
{
for (int i = 0; i < times; i++)
{
foreach (BinaryNumber networkID in networkIDs)
{
DiscoveryPacket queryPacket = DiscoveryPacket.CreateQueryPacket();
lock (_queryPacketCache)
{
_queryPacketCache.Add(queryPacket);
}
byte[] packet = queryPacket.ToArray(networkID);
if (networks == null)
{
_listener.Broadcast(packet, 0, packet.Length);
}
else
{
foreach (NetworkInfo network in networks)
{
_listener.BroadcastTo(packet, 0, packet.Length, network);
}
}
}
if (i < times - 1)
{
Thread.Sleep(ANNOUNCEMENT_RETRY_INTERVAL);
}
}
}
private void SendResponse(DiscoveryPacket receivedQueryPacket, BinaryNumber networkID, IPAddress remotePeerIP)
{
NetworkInfo network = NetUtilities.GetNetworkInfo(remotePeerIP);
DiscoveryPacket responsePacket = DiscoveryPacket.CreateResponsePacket(_announcePort, receivedQueryPacket.Challenge);
byte[] packet = responsePacket.ToArray(networkID, network.LocalIP);
_listener.SendTo(packet, 0, packet.Length, remotePeerIP);
}
private void HandleAnswer(UdpReceiveResult answer, List <DiscoveredServerInfo> liResults, String strSource)
{
DiscoveryPacket recvPacket = DiscoveryPacket.ReadPacket(answer.Buffer);
if (recvPacket.IsValid)
{
if (recvPacket.IsAnswer() && recvPacket is DiscoveryPacket_Answer recvAnswer)
{
m_bRemoteMinVersionError = recvAnswer.MinProtocolVer > BBProtocol.CURRENT_PROTOCOL_VERSION;
m_bLocalMinVersionError = recvAnswer.MaxProtocolVer < BBProtocol.MIN_PROTOCOL_VERSION;
if (!m_bLocalMinVersionError && !m_bRemoteMinVersionError)
{
DiscoveredServerInfo info = new DiscoveredServerInfo(recvAnswer, answer.RemoteEndPoint.Address);
if (!liResults.Contains(info))
{
liResults.Add(info);
// Only return the server as First Result (to be connected to) if it's the Default Server or no Default has been set
if (Properties.Settings.Default.DefaultServer == 0 || info.ServerGUID == Properties.Settings.Default.DefaultServer)
{
m_wbFirstResult.Post(info);
}
AddFoundServer(info);
Log.d(TAG, "Recveid answer from " + strSource + " - " + info.getDebugString());
}
else
{
Log.d(TAG, "Ignored duplicate answer from " + strSource + " - " + info.getDebugString());
}
}
else
{
Log.d(TAG, "Protocolversion not supported in answer from " + strSource);
}
}
else
{
Log.e(TAG, "Unknown/unexpected packet received from " + answer.RemoteEndPoint);
}
}
else
{
Log.e(TAG, "Invalid packet received from " + answer.RemoteEndPoint + " - " + recvPacket.ParseError);
}
}
public bool Equals(DiscoveryPacket obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
if (!_challenge.Equals(obj._challenge))
{
return(false);
}
return(true);
}
public void PacketDecoder()
{
Device device = new Device()
{
Firmware = "XM.ar7240.v5.5.3.14763.121012.1716",
Hostname = "hostnamehostnam",
Platform = "N5N",
SSID = "ssidssidssi",
Uptime = new TimeSpan(5, 3, 11, 25)
};
device.Addresses.Add(new DeviceAddress(IPAddress.Parse("54.55.56.57"), PhysicalAddress.Parse("303132333435")));
DiscoveryPacket dpack = new DiscoveryPacket(SamplePacket);
Device device2 = dpack.DecodePacket();
Assert.AreEqual(device.Firmware, device2.Firmware);
Assert.AreEqual(device.Hostname, device2.Hostname);
Assert.AreEqual(device.FirstAddress, device.FirstAddress);
Assert.AreEqual(device.Platform, device2.Platform);
Assert.AreEqual(device.SSID, device2.SSID);
Assert.AreEqual(device.Uptime, device2.Uptime);
}
private void listener_ReceivedPacket(DiscoveryPacket packet, IPAddress remotePeerIP)
{
if (packet.IsResponse)
{
#region response process
lock (_queryPacketCache)
{
int i = _queryPacketCache.IndexOf(packet);
if (i < 0)
{
return;
}
DiscoveryPacket queryPacket = _queryPacketCache[i];
if (queryPacket.IsExpired())
{
return;
}
}
BinaryNumber foundNetworkID = null;
lock (_announceNetworkIDs)
{
foreach (BinaryNumber networkID in _announceNetworkIDs)
{
if (packet.IsResponseValid(networkID, remotePeerIP))
{
foundNetworkID = networkID;
break;
}
}
}
if (foundNetworkID != null)
{
IPEndPoint peerEP = new IPEndPoint(remotePeerIP, packet.ServicePort);
PeerInfo peerInfo = new PeerInfo(peerEP, foundNetworkID);
bool peerInCache;
lock (_peerInfoCache)
{
if (_peerInfoCache.Contains(peerInfo))
{
PeerInfo existingPeerInfo = _peerInfoCache[_peerInfoCache.IndexOf(peerInfo)];
if (existingPeerInfo.IsExpired())
{
peerInCache = false;
_peerInfoCache.Remove(existingPeerInfo);
}
else
{
peerInCache = true;
}
}
else
{
peerInCache = false;
}
}
if (!peerInCache)
{
lock (_peerInfoCache)
{
_peerInfoCache.Add(peerInfo);
}
PeerDiscovered(this, peerEP, foundNetworkID);
}
}
#endregion
}
else
{
#region query process
BinaryNumber foundNetworkID = null;
lock (_trackedNetworkIDs)
{
foreach (BinaryNumber networkID in _trackedNetworkIDs)
{
if (packet.IsThisNetwork(networkID))
{
foundNetworkID = networkID;
break;
}
}
}
if (foundNetworkID != null)
{
SendResponse(packet, foundNetworkID, remotePeerIP);
}
#endregion
}
}