public static bool broadcastNewBlock(Block b, RemoteEndpoint skipEndpoint = null, RemoteEndpoint endpoint = null, bool force_broadcast = false)
{
if (!Node.isMasterNode())
{
return(true);
}
if (endpoint != null)
{
if (endpoint.isConnected())
{
endpoint.sendData(ProtocolMessageCode.blockData, b.getBytes(false), BitConverter.GetBytes(b.blockNum));
return(true);
}
return(false);
}
else
{
if (force_broadcast)
{
return(CoreProtocolMessage.broadcastProtocolMessage(new char[] { 'M', 'H' }, ProtocolMessageCode.blockData, b.getBytes(false), BitConverter.GetBytes(b.blockNum), skipEndpoint));
}
else
{
return(CoreProtocolMessage.addToInventory(new char[] { 'M', 'H' }, new InventoryItemBlock(b.blockChecksum, b.blockNum), skipEndpoint, ProtocolMessageCode.blockData, b.getBytes(false), BitConverter.GetBytes(b.blockNum)));
}
}
}
public static void handleKeepAlivesChunk(byte[] data, RemoteEndpoint endpoint)
{
using (MemoryStream m = new MemoryStream(data))
{
using (BinaryReader reader = new BinaryReader(m))
{
int ka_count = (int)reader.ReadIxiVarUInt();
int max_ka_per_chunk = CoreConfig.maximumKeepAlivesPerChunk;
if (ka_count > max_ka_per_chunk)
{
ka_count = max_ka_per_chunk;
}
for (int i = 0; i < ka_count; i++)
{
if (m.Position == m.Length)
{
break;
}
int ka_len = (int)reader.ReadIxiVarUInt();
byte[] ka_bytes = reader.ReadBytes(ka_len);
byte[] hash = Crypto.sha512sqTrunc(ka_bytes);
Node.inventoryCache.setProcessedFlag(InventoryItemTypes.keepAlive, hash, true);
byte[] address;
long last_seen;
byte[] device_id;
bool updated = PresenceList.receiveKeepAlive(ka_bytes, out address, out last_seen, out device_id, endpoint);
// If a presence entry was updated, broadcast this message again
if (updated)
{
CoreProtocolMessage.addToInventory(new char[] { 'M', 'H', 'W' }, new InventoryItemKeepAlive(hash, last_seen, address, device_id), endpoint, ProtocolMessageCode.keepAlivePresence, ka_bytes, address);
// Send this keepalive message to all subscribed clients
CoreProtocolMessage.broadcastEventDataMessage(NetworkEvents.Type.keepAlive, address, ProtocolMessageCode.keepAlivePresence, ka_bytes, address, endpoint);
}
}
}
}
}
public static bool broadcastBlockSignature(byte[] signature, byte[] sig_address, ulong block_num, byte[] block_hash, RemoteEndpoint skipEndpoint = null, RemoteEndpoint endpoint = null)
{
byte[] signature_data = null;
using (MemoryStream m = new MemoryStream(1152))
{
using (BinaryWriter writer = new BinaryWriter(m))
{
writer.WriteIxiVarInt(block_num);
writer.WriteIxiVarInt(block_hash.Length);
writer.Write(block_hash);
writer.WriteIxiVarInt(signature.Length);
writer.Write(signature);
writer.WriteIxiVarInt(sig_address.Length);
writer.Write(sig_address);
#if TRACE_MEMSTREAM_SIZES
Logging.info(String.Format("NetworkProtocol::broadcastNewBlockSignature: {0}", m.Length));
#endif
signature_data = m.ToArray();
}
}
if (endpoint != null)
{
if (endpoint.isConnected())
{
endpoint.sendData(ProtocolMessageCode.blockSignature2, signature_data);
return(true);
}
return(false);
}
else
{
return(CoreProtocolMessage.addToInventory(new char[] { 'M', 'H' }, new InventoryItemSignature(sig_address, block_num, block_hash), skipEndpoint, ProtocolMessageCode.blockSignature2, signature_data, null));
}
}
public static void handleKeepAlivePresence(byte[] data, RemoteEndpoint endpoint)
{
byte[] address = null;
long last_seen = 0;
byte[] device_id = null;
byte[] hash = Crypto.sha512sqTrunc(data);
Node.inventoryCache.setProcessedFlag(InventoryItemTypes.keepAlive, hash, true);
bool updated = PresenceList.receiveKeepAlive(data, out address, out last_seen, out device_id, endpoint);
// If a presence entry was updated, broadcast this message again
if (updated)
{
CoreProtocolMessage.addToInventory(new char[] { 'M', 'H', 'W' }, new InventoryItemKeepAlive(hash, last_seen, address, device_id), endpoint, ProtocolMessageCode.keepAlivePresence, data, address);
// Send this keepalive message to all subscribed clients
CoreProtocolMessage.broadcastEventDataMessage(NetworkEvents.Type.keepAlive, address, ProtocolMessageCode.keepAlivePresence, data, address, endpoint);
}
}