/// <summary>
/// Insert invalid packet
/// </summary>
/// <param name="ip"></param>
public static void FilterInsertInvalidPacket(string ip, int invalidPacket = 0)
{
try
{
if (ListFilterObjects.ContainsKey(ip) && ip != "127.0.0.1") // Increment the total invalid packet.
{
if (invalidPacket == 0)
{
ListFilterObjects[ip].TotalInvalidPacket++;
}
else
{
ListFilterObjects[ip].TotalInvalidPacket = invalidPacket;
}
ListFilterObjects[ip].LastInvalidPacketDate = DateTimeOffset.Now.ToUnixTimeSeconds();
if (ListFilterObjects[ip].TotalInvalidPacket >= MaxInvalidPacket) // Ban if the filter object reach the max invalid packet.
{
ListFilterObjects[ip].LastBanDate = DateTimeOffset.Now.ToUnixTimeSeconds();
ListFilterObjects[ip].Banned = true;
if (Environment.OSVersion.Platform == PlatformID.Unix) // use iptables on linux.
{
switch (FilterSystem)
{
case ClassFilterSystemEnumeration.FilterSystemIptables:
Process.Start("/bin/bash", "-c \"iptables -A " + FilterChainName + " -p tcp -s " + ip + " -j DROP\""); // Add iptables rule.
break;
case ClassFilterSystemEnumeration.FilterSystemPacketFilter:
Process.Start("pfctl", "-t " + FilterChainName + " -T add " + ip + ""); // Add packet filter rule.
break;
default:
ClassLog.Log("Cannot insert a rule of ban, please check your config and set the filter system name.", 7, 3);
break;
}
}
else
{
try
{
using (Process cmd = new Process())
{
cmd.StartInfo.FileName = "cmd.exe";
cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cmd.StartInfo.Arguments = "/c netsh advfirewall firewall add rule name=\"AutoBAN (" + ip + ")\" protocol=TCP dir=in remoteip=" + ip + " action=block"; // Insert Windows rule.
cmd.Start();
}
}
catch
{
}
}
ClassLog.Log("Incoming connection " + ip + " is banned.", 3, 3);
}
}
}
catch
{
}
}
/// <summary>
/// This method permit to get back the real ip behind a proxy and check the list of banned IP.
/// </summary>
private bool GetAndCheckForwardedIp(string packet)
{
var splitPacket = packet.Split(new[] { "\n" }, StringSplitOptions.None);
foreach (var packetEach in splitPacket)
{
if (packetEach != null)
{
if (!string.IsNullOrEmpty(packetEach))
{
if (packetEach.ToLower().Contains("x-forwarded-for: "))
{
string newIp = packetEach.ToLower().Replace("x-forwarded-for: ", "");
_ip = newIp;
ClassLog.Log("HTTP/HTTPS API - X-Forwarded-For ip of the client is: " + newIp, 7, 2);
var checkBanResult = ClassApiBan.FilterCheckIp(_ip);
if (!checkBanResult) // Is Banned
{
return(false);
}
else
{
if (!string.IsNullOrEmpty(newIp))
{
ClassApiBan.FilterInsertIp(newIp);
}
return(true);
}
}
}
}
}
return(true);
}
public static void StartUpdateHashTransactionList()
{
if (!InGenerateTransactionKey)
{
InGenerateTransactionKey = true;
try
{
//ClassRemoteNodeSync.HashTransactionList = Utils.ClassUtilsNode.ConvertStringToSha512(string.Join(string.Empty, ClassRemoteNodeSync.ListOfTransaction.Values()));
string transactionBlock = string.Empty;
string schema = ClassRemoteNodeSync.SchemaHashTransaction;
if (!string.IsNullOrEmpty(schema))
{
var splitSchema = schema.Split(new[] { ";" }, StringSplitOptions.None);
foreach (var transaction in splitSchema)
{
if (transaction != null)
{
if (!string.IsNullOrEmpty(transaction))
{
if (long.TryParse(transaction, out var transactionId))
{
if (ClassRemoteNodeSync.ListOfTransaction.ContainsKey(transactionId))
{
transactionBlock += ClassRemoteNodeSync.ListOfTransaction.GetTransaction(transactionId);
}
}
}
}
}
if (!string.IsNullOrEmpty(transactionBlock))
{
ClassRemoteNodeSync.HashTransactionList = Utils.ClassUtilsNode.ConvertStringToSha512(transactionBlock);
}
}
}
catch
{
}
ClassLog.Log(
"Hash key from transaction list generated: " + ClassRemoteNodeSync.HashTransactionList + " ", 1, 1);
InGenerateTransactionKey = false;
}
}
public static void StartUpdateHashBlockList()
{
if (!InGenerateBlockKey)
{
InGenerateBlockKey = true;
try
{
string blockBLock = string.Empty;
string schema = ClassRemoteNodeSync.SchemaHashBlock;
if (!string.IsNullOrEmpty(schema))
{
var splitSchema = schema.Split(new[] { ";" }, StringSplitOptions.None);
foreach (var block in splitSchema)
{
if (block != null)
{
if (!string.IsNullOrEmpty(block))
{
if (int.TryParse(block, out var blockId))
{
if (ClassRemoteNodeSync.ListOfBlock.ContainsKey(blockId))
{
blockBLock += ClassRemoteNodeSync.ListOfBlock[blockId];
}
}
}
}
}
if (!string.IsNullOrEmpty(blockBLock))
{
ClassRemoteNodeSync.HashBlockList = Utils.ClassUtilsNode.ConvertStringToSha512(blockBLock);
}
}
}
catch
{
}
ClassLog.Log("Hash key from block list generated: " + ClassRemoteNodeSync.HashBlockList + " ", 1, 1);
InGenerateBlockKey = false;
}
}
public static void StartUpdateTrustedKey()
{
_threadUpdateTrustedKey = new Thread(delegate()
{
while (!Program.Closed)
{
try
{
if (ClassRemoteNodeSync.ListOfBlock.Count > 0)
{
ClassRemoteNodeSync.TrustedKey = Utils.ClassUtilsNode.ConvertStringToSha512(
ClassRemoteNodeSync.CoinCirculating + ClassRemoteNodeSync.CoinMaxSupply +
ClassRemoteNodeSync.CurrentDifficulty + ClassRemoteNodeSync.CurrentHashrate +
ClassRemoteNodeSync.TotalBlockMined + ClassRemoteNodeSync.CurrentTotalFee +
ClassRemoteNodeSync.TotalPendingTransaction + ClassRemoteNodeSync
.ListOfBlock[ClassRemoteNodeSync.ListOfBlock.Count - 1]
.Split(new[] { "#" }, StringSplitOptions.None)[6]);
}
else
{
ClassRemoteNodeSync.TrustedKey = Utils.ClassUtilsNode.ConvertStringToSha512(
ClassRemoteNodeSync.CoinCirculating + ClassRemoteNodeSync.CoinMaxSupply +
ClassRemoteNodeSync.CurrentDifficulty + ClassRemoteNodeSync.CurrentHashrate +
ClassRemoteNodeSync.TotalBlockMined + ClassRemoteNodeSync.CurrentTotalFee +
ClassRemoteNodeSync.TotalPendingTransaction);
}
ClassLog.Log("Trusted key generated: " + ClassRemoteNodeSync.TrustedKey + " ", 1, 1);
}
catch (Exception error)
{
ClassLog.Log("Can't generate trusted key, error: " + error.Message, 0, 1);
}
Thread.Sleep(ThreadUpdateTrustedKeyInterval);
}
});
_threadUpdateTrustedKey.Start();
}
/// <summary>
/// Automaticaly check each filter object.
/// </summary>
public static void FilterAutoCheckObject()
{
ThreadFilterObject = new Thread(delegate()
{
while (!Program.Closed)
{
try
{
if (ListFilterObjects.Count > 0)
{
foreach (KeyValuePair <string, ClassApiBanObject> filterObject in ListFilterObjects)
{
if (filterObject.Key != "127.0.0.1")
{
if (!filterObject.Value.Banned) // If not banned
{
if (filterObject.Value.LastInvalidPacketDate + KeepAliveInvalidPacket < DateTimeOffset.Now.ToUnixTimeSeconds()) // Clean accumulated total invalid packet.
{
ListFilterObjects[filterObject.Key].LastInvalidPacketDate = 0;
ListFilterObjects[filterObject.Key].TotalInvalidPacket = 0;
}
else // Just in case:
{
if (filterObject.Value.TotalInvalidPacket >= MaxInvalidPacket) // Ban if the filter object reach the max invalid packet.
{
ListFilterObjects[filterObject.Key].LastBanDate = DateTimeOffset.Now.ToUnixTimeSeconds();
ListFilterObjects[filterObject.Key].Banned = true;
}
}
}
else
{
if (filterObject.Value.LastBanDate + BanDelay < DateTimeOffset.Now.ToUnixTimeSeconds()) // Unban.
{
ListFilterObjects[filterObject.Key].LastInvalidPacketDate = 0;
ListFilterObjects[filterObject.Key].TotalInvalidPacket = 0;
ListFilterObjects[filterObject.Key].LastBanDate = 0;
ListFilterObjects[filterObject.Key].Banned = false;
if (Environment.OSVersion.Platform == PlatformID.Unix) // use iptables on linux.
{
switch (FilterSystem)
{
case ClassFilterSystemEnumeration.FilterSystemIptables:
Process.Start("/bin/bash", "-c \"iptables -D " + FilterChainName + " -p tcp -s " + filterObject.Key + " -j DROP\""); // Remove iptables rule.
break;
case ClassFilterSystemEnumeration.FilterSystemPacketFilter:
Process.Start("pfctl", "-t " + FilterChainName + " -T del " + filterObject.Key + ""); // Remove PF rule.
break;
default:
ClassLog.Log("Cannot remove a rule of ban, please check your config and set the filter system name.", 7, 3);
break;
}
}
else
{
try
{
using (Process cmd = new Process())
{
cmd.StartInfo.FileName = "cmd.exe";
cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cmd.StartInfo.Arguments = "/c netsh advfirewall firewall delete rule name=\"AutoBAN (" + filterObject.Value.Ip + ")\""; // Remove Windows rule.
cmd.Start();
}
}
catch (Exception error)
{
ClassLog.Log("Windows - Unban ip " + filterObject.Value.Ip + " exception: " + error.Message, 0, 2);
}
}
}
}
}
}
}
}
catch
{
}
Thread.Sleep(AutoCheckObjectInterval);
}
});
ThreadFilterObject.Start();
}
/// <summary>
/// Check every remote node object sync connection.
/// </summary>
public static void EnableCheckRemoteNodeSync()
{
ThreadLoopCheckRemoteNode = new Thread(async delegate()
{
while (!Program.Closed)
{
Thread.Sleep(ThreadLoopCheckRemoteNodeInterval); // Make a pause for the next check.
if (!Program.RemoteNodeObjectBlock.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectBlock.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Block disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectBlock.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectBlock.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectBlock.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync block disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectBlock.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectBlock.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectCoinCirculating.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectCoinCirculating.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Coin Circulating disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectCoinCirculating.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCoinCirculating.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectCoinCirculating.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
Thread.Sleep(1000);
if (Program.Closed)
{
break;
}
}
ClassLog.Log("Last packet from Object Coin Circulating more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectCoinCirculating.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCoinCirculating.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectCoinMaxSupply.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectCoinMaxSupply.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Coin Max Supply disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectCoinMaxSupply.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCoinMaxSupply.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectCoinMaxSupply.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Coin Max Supply more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectCoinMaxSupply.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCoinMaxSupply.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectCurrentDifficulty.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectCurrentDifficulty.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Current Difficulty disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectCurrentDifficulty.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCurrentDifficulty.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectCurrentDifficulty.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Current Difficulty more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectCurrentDifficulty.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCurrentDifficulty.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectCurrentRate.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectCurrentRate.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Current Hashrate disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectCurrentRate.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCurrentRate.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectCurrentRate.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Current Hashrate more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectCurrentRate.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectCurrentRate.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectTotalBlockMined.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectTotalBlockMined.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Total Block Mined disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalBlockMined.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalBlockMined.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectTotalBlockMined.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Current Total BlockMined more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalBlockMined.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalBlockMined.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectTotalFee.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectTotalFee.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Total Fee disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalFee.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalFee.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectTotalFee.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Total Fee more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalFee.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalFee.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectTotalPendingTransaction.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectTotalPendingTransaction.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Total Pending Transaction disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalPendingTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalPendingTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectTotalPendingTransaction.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Sync Total Pending Transaction more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalPendingTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalPendingTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectTransaction.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectTransaction.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Transaction disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectTransaction.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Transaction disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (!Program.RemoteNodeObjectTotalTransaction.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectTotalTransaction.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Object Sync Total number of Transaction disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
else
{
var lastPacketReceivedTimeStamp = Program.RemoteNodeObjectTotalTransaction.RemoteNodeObjectLastPacketReceived;
var currentTimestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
if (lastPacketReceivedTimeStamp + ClassConnectorSetting.MaxDelayRemoteNodeWaitResponse < currentTimestamp)
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassLog.Log("Last packet from Object Total number of Transaction more than 10 seconds ago, reconnect now..", 2, 3);
Program.RemoteNodeObjectTotalTransaction.StopConnection();
await Task.Factory.StartNew(() => Program.RemoteNodeObjectTotalTransaction.StartConnectionAsync()).ConfigureAwait(false);
if (Program.Closed)
{
break;
}
}
}
if (ClassRemoteNodeSync.WantToBePublicNode)
{
if (!Program.RemoteNodeObjectToBePublic.RemoteNodeObjectConnectionStatus || !Program.RemoteNodeObjectToBePublic.RemoteNodeObjectTcpClient.ReturnStatus())
{
while (!BlockchainNetworkStatus)
{
if (Program.Closed)
{
break;
}
Thread.Sleep(1000);
}
ClassRemoteNodeSync.ListOfPublicNodes.Clear();
ClassLog.Log("Object Sync Want to be Public disconnected, reconnect now..", 2, 3);
Program.RemoteNodeObjectToBePublic.StopConnection();
await Program.RemoteNodeObjectToBePublic.StartConnectionAsync();
if (Program.Closed)
{
break;
}
}
}
}
});
ThreadLoopCheckRemoteNode.Start();
}
/// <summary>
/// Add a new transaction on the sorted list of transaction per wallet.
/// </summary>
/// <param name="transaction"></param>
public static bool AddNewTransactionSortedPerWallet(string transaction)
{
try
{
if (ClassRemoteNodeSync.ListTransactionPerWallet == null)
{
ClassRemoteNodeSync.ListTransactionPerWallet = new BigDictionaryTransactionSortedPerWallet();
}
var dataTransactionSplit = transaction.Split(new[] { "-" }, StringSplitOptions.None);
float idWalletSender;
if (dataTransactionSplit[0] != "m" && dataTransactionSplit[0] != "r" && dataTransactionSplit[0] != "f")
{
idWalletSender = float.Parse(dataTransactionSplit[0].Replace(".", ","), NumberStyles.Any, Program.GlobalCultureInfo);
}
else
{
if (dataTransactionSplit[3] == "")
{
Console.WriteLine("Id sender for block transaction id: " + ClassRemoteNodeSync.ListTransactionPerWallet.Count + " is missing.");
idWalletSender = -1;
}
else
{
idWalletSender = -1; // Blockchain.
}
}
float idWalletReceiver;
if (dataTransactionSplit[3] == "")
{
idWalletReceiver = -1;
ClassLog.Log("Transaction ID: " + ClassRemoteNodeSync.ListTransactionPerWallet.Count + " is corrupted, data: " + transaction, 0, 3);
}
else
{
idWalletReceiver = float.Parse(dataTransactionSplit[3].Replace(".", ","), NumberStyles.Any, Program.GlobalCultureInfo); // Receiver ID.
string hashTransaction = dataTransactionSplit[5]; // Transaction hash.
if (ClassRemoteNodeSync.ListOfTransactionHash.ContainsKey(hashTransaction) == -1)
{
if (ClassRemoteNodeSync.ListOfTransactionHash.InsertTransactionHash(ClassRemoteNodeSync.ListOfTransactionHash.Count, hashTransaction))
{
#region test data of tx
decimal timestamp = decimal.Parse(dataTransactionSplit[4]); // timestamp CEST.
decimal amount = 0; // Amount.
decimal fee = 0; // Fee.
string timestampRecv = dataTransactionSplit[6];
var splitTransactionInformation = dataTransactionSplit[7].Split(new[] { "#" },
StringSplitOptions.None);
string blockHeight = splitTransactionInformation[0]; // Block height;
// Real crypted fee, amount sender.
string realFeeAmountSend = splitTransactionInformation[1];
// Real crypted fee, amount receiver.
string realFeeAmountRecv = splitTransactionInformation[2];
string dataInformationSend = "SEND#" + amount + "#" + fee + "#" + timestamp + "#" +
hashTransaction + "#" + timestampRecv + "#" + blockHeight + "#" + realFeeAmountSend + "#" +
realFeeAmountRecv + "#";
string dataInformationRecv = "RECV#" + amount + "#" + fee + "#" + timestamp + "#" +
hashTransaction + "#" + timestampRecv + "#" + blockHeight + "#" + realFeeAmountSend + "#" +
realFeeAmountRecv + "#";
#endregion
if (idWalletSender != -1)
{
var tupleTxSender = new Tuple <string, string>(hashTransaction, "SEND");
//ClassRemoteNodeSync.ListTransactionPerWallet.InsertTransactionSorted(idWalletSender, dataInformationSend);
ClassRemoteNodeSync.ListTransactionPerWallet.InsertTransactionSorted(idWalletSender, tupleTxSender);
}
if (idWalletReceiver != -1)
{
var tupleTxReceiver = new Tuple <string, string>(hashTransaction, "RECV");
//ClassRemoteNodeSync.ListTransactionPerWallet.InsertTransactionSorted(idWalletReceiver, dataInformationRecv);
ClassRemoteNodeSync.ListTransactionPerWallet.InsertTransactionSorted(idWalletReceiver, tupleTxReceiver);
}
}
else
{
return(false);
}
}
}
}
catch
{
return(false);
}
return(true);
}
/// <summary>
/// Handle get request received from client.
/// </summary>
/// <param name="packet"></param>
/// <returns></returns>
private async Task HandlePacketHttpAsync(string packet)
{
long selectedIndex = 0;
string selectedHash = string.Empty;
if (packet.Contains("="))
{
var splitPacket = packet.Split(new[] { "=" }, StringSplitOptions.None);
if (!long.TryParse(splitPacket[1], out selectedIndex))
{
selectedHash = splitPacket[1]; // Hash
}
packet = splitPacket[0];
}
switch (packet)
{
case ClassApiHttpRequestEnumeration.GetCoinName:
await BuildAndSendHttpPacketAsync(ClassConnectorSetting.CoinName);
break;
case ClassApiHttpRequestEnumeration.GetCoinMinName:
await BuildAndSendHttpPacketAsync(ClassConnectorSetting.CoinNameMin);
break;
case ClassApiHttpRequestEnumeration.GetCoinMaxSupply:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CoinMaxSupply);
break;
case ClassApiHttpRequestEnumeration.GetCoinCirculating:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CoinCirculating);
break;
case ClassApiHttpRequestEnumeration.GetCoinTotalFee:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CurrentTotalFee);
break;
case ClassApiHttpRequestEnumeration.GetCoinTotalMined:
await BuildAndSendHttpPacketAsync("" + (ClassRemoteNodeSync.ListOfBlock.Count * 10));
break;
case ClassApiHttpRequestEnumeration.GetCoinBlockchainHeight:
await BuildAndSendHttpPacketAsync("" + (ClassRemoteNodeSync.ListOfBlock.Count + 1));
break;
case ClassApiHttpRequestEnumeration.GetCoinTotalBlockMined:
await BuildAndSendHttpPacketAsync("" + (ClassRemoteNodeSync.ListOfBlock.Count));
break;
case ClassApiHttpRequestEnumeration.GetCoinTotalBlockLeft:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CurrentBlockLeft);
break;
case ClassApiHttpRequestEnumeration.GetCoinNetworkDifficulty:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CurrentDifficulty);
break;
case ClassApiHttpRequestEnumeration.GetCoinNetworkHashrate:
await BuildAndSendHttpPacketAsync(ClassRemoteNodeSync.CurrentHashrate);
break;
case ClassApiHttpRequestEnumeration.GetCoinBlockPerId:
if (selectedIndex > 0)
{
selectedIndex -= 1;
if (ClassRemoteNodeSync.ListOfBlock.Count - 1 >= selectedIndex)
{
if (ClassRemoteNodeSync.ListOfBlock.ContainsKey((int)selectedIndex))
{
var splitBlock = ClassRemoteNodeSync.ListOfBlock[(int)selectedIndex].Split(new[] { "#" }, StringSplitOptions.None);
Dictionary <string, string> blockContent = new Dictionary <string, string>
{
{ "block_id", splitBlock[0] },
{ "block_hash", splitBlock[1] },
{ "block_transaction_hash", splitBlock[2] },
{ "block_timestamp_create", splitBlock[3] },
{ "block_timestamp_found", splitBlock[4] },
{ "block_difficulty", splitBlock[5] },
{ "block_reward", splitBlock[6] }
};
await BuildAndSendHttpPacketAsync(null, true, blockContent);
blockContent.Clear();
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
break;
case ClassApiHttpRequestEnumeration.GetCoinBlockPerHash:
if (selectedHash != string.Empty)
{
int selectedBlockIndex = ClassRemoteNodeSync.ListOfBlockHash.GetBlockIdFromHash(selectedHash);
if (selectedBlockIndex != -1)
{
var splitBlock = ClassRemoteNodeSync.ListOfBlock[selectedBlockIndex].Split(new[] { "#" }, StringSplitOptions.None);
Dictionary <string, string> blockContent = new Dictionary <string, string>
{
{ "block_id", splitBlock[0] },
{ "block_hash", splitBlock[1] },
{ "block_transaction_hash", splitBlock[2] },
{ "block_timestamp_create", splitBlock[3] },
{ "block_timestamp_found", splitBlock[4] },
{ "block_difficulty", splitBlock[5] },
{ "block_reward", splitBlock[6] }
};
await BuildAndSendHttpPacketAsync(null, true, blockContent);
blockContent.Clear();
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
break;
case ClassApiHttpRequestEnumeration.GetCoinTransactionPerId:
if (selectedIndex > 0)
{
selectedIndex -= 1;
if (ClassRemoteNodeSync.ListOfTransaction.Count - 1 >= selectedIndex)
{
if (ClassRemoteNodeSync.ListOfTransaction.ContainsKey(selectedIndex))
{
var splitTransaction = ClassRemoteNodeSync.ListOfTransaction.GetTransaction(selectedIndex).Split(new[] { "-" }, StringSplitOptions.None);
Dictionary <string, string> transactionContent = new Dictionary <string, string>
{
{ "transaction_id", "" + (selectedIndex + 1) },
{ "transaction_id_sender", splitTransaction[0] },
{ "transaction_fake_amount", splitTransaction[1] },
{ "transaction_fake_fee", splitTransaction[2] },
{ "transaction_id_receiver", splitTransaction[3] },
{ "transaction_timestamp_sended", splitTransaction[4] },
{ "transaction_hash", splitTransaction[5] },
{ "transaction_timestamp_received", splitTransaction[6] }
};
await BuildAndSendHttpPacketAsync(null, true, transactionContent);
transactionContent.Clear();
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
break;
case ClassApiHttpRequestEnumeration.GetCoinTransactionPerHash:
if (selectedHash != string.Empty)
{
long transactionIndex = ClassRemoteNodeSync.ListOfTransactionHash.ContainsKey(selectedHash);
if (transactionIndex != -1)
{
var splitTransaction = ClassRemoteNodeSync.ListOfTransaction.GetTransaction(transactionIndex).Split(new[] { "-" }, StringSplitOptions.None);
Dictionary <string, string> transactionContent = new Dictionary <string, string>
{
{ "transaction_id", "" + (transactionIndex + 1) },
{ "transaction_id_sender", splitTransaction[0] },
{ "transaction_fake_amount", splitTransaction[1] },
{ "transaction_fake_fee", splitTransaction[2] },
{ "transaction_id_receiver", splitTransaction[3] },
{ "transaction_timestamp_sended", splitTransaction[4] },
{ "transaction_hash", splitTransaction[5] },
{ "transaction_timestamp_received", splitTransaction[6] }
};
await BuildAndSendHttpPacketAsync(null, true, transactionContent);
transactionContent.Clear();
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
}
else
{
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
}
break;
case ClassApiHttpRequestEnumeration.GetCoinNetworkFullStats:
Dictionary <string, string> networkStatsContent = new Dictionary <string, string>
{
{ "coin_name", ClassConnectorSetting.CoinName },
{ "coin_min_name", ClassConnectorSetting.CoinNameMin },
{ "coin_max_supply", ClassRemoteNodeSync.CoinMaxSupply },
{ "coin_circulating", decimal.Parse(ClassRemoteNodeSync.CoinCirculating, NumberStyles.Any, Program.GlobalCultureInfo).ToString() },
{ "coin_total_fee", decimal.Parse(ClassRemoteNodeSync.CurrentTotalFee, NumberStyles.Any, Program.GlobalCultureInfo).ToString() },
{ "coin_total_mined", (ClassRemoteNodeSync.ListOfBlock.Count * ClassConnectorSetting.ConstantBlockReward).ToString() },
{ "coin_blockchain_height", "" + (ClassRemoteNodeSync.ListOfBlock.Count + 1) },
{ "coin_total_block_mined", "" + ClassRemoteNodeSync.ListOfBlock.Count },
{ "coin_total_block_left", ClassRemoteNodeSync.CurrentBlockLeft },
{ "coin_network_difficulty", decimal.Parse(ClassRemoteNodeSync.CurrentDifficulty, NumberStyles.Any, Program.GlobalCultureInfo).ToString() },
{ "coin_network_hashrate", decimal.Parse(ClassRemoteNodeSync.CurrentHashrate, NumberStyles.Any, Program.GlobalCultureInfo).ToString() },
{ "coin_total_transaction", "" + ClassRemoteNodeSync.ListOfTransaction.Count }
};
await BuildAndSendHttpPacketAsync(null, true, networkStatsContent);
networkStatsContent.Clear();
break;
case ClassApiHttpRequestEnumeration.PacketFavicon:
ClassLog.Log("HTTP API - packet received from IP: " + _ip + " - favicon request detected and ignored.", 6, 2);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
break;
default:
ClassApiBan.FilterInsertInvalidPacket(_ip);
await BuildAndSendHttpPacketAsync(ClassApiHttpRequestEnumeration.PacketNotExist);
break;
}
}
/// <summary>
/// Start to listen incoming client.
/// </summary>
/// <returns></returns>
public async Task StartHandleClientHttpAsync()
{
try
{
_ip = ((IPEndPoint)(_client.Client.RemoteEndPoint)).Address.ToString();
}
catch
{
CloseClientConnection();
return;
}
var checkBanResult = true;
if (_ip != "127.0.0.1") // Do not check localhost ip.
{
checkBanResult = ClassApiBan.FilterCheckIp(_ip);
}
int totalWhile = 0;
if (checkBanResult)
{
if (_ip != "127.0.0.1")
{
ClassApiBan.FilterInsertIp(_ip);
}
try
{
while (_clientStatus)
{
try
{
byte[] buffer = new byte[ClassConnectorSetting.MaxNetworkPacketSize];
using (NetworkStream clientHttpReader = new NetworkStream(_client.Client))
{
using (var bufferedStreamNetwork = new BufferedStream(clientHttpReader, ClassConnectorSetting.MaxNetworkPacketSize))
{
int received = await bufferedStreamNetwork.ReadAsync(buffer, 0, buffer.Length);
if (received > 0)
{
string packet = Encoding.UTF8.GetString(buffer, 0, received);
try
{
if (!GetAndCheckForwardedIp(packet))
{
break;
}
}
catch
{
}
packet = ClassUtilsNode.GetStringBetween(packet, "GET", "HTTP");
packet = packet.Replace("/", "");
packet = packet.Replace(" ", "");
ClassLog.Log("HTTP API - packet received from IP: " + _ip + " - " + packet, 6, 2);
await HandlePacketHttpAsync(packet);
break;
}
else
{
totalWhile++;
}
if (totalWhile >= 8)
{
break;
}
}
}
}
catch
{
break;
}
}
}
catch
{
}
CloseClientConnection();
}
}