1237 lines
41 KiB
JavaScript
1237 lines
41 KiB
JavaScript
/*
|
|
* @project: TERA
|
|
* @version: Development (beta)
|
|
* @license: MIT (not for evil)
|
|
* @copyright: Yuriy Ivanov (Vtools) 2017-2019 [progr76@gmail.com]
|
|
* Web: https://terafoundation.org
|
|
* Twitter: https://twitter.com/terafoundation
|
|
* Telegram: https://web.telegram.org/#/im?p=@terafoundation
|
|
*/
|
|
|
|
"use strict";
|
|
const net = require("net");
|
|
const dgram = require("dgram");
|
|
const crypto = require('crypto');
|
|
require("./library.js");
|
|
require("./crypto-library");
|
|
const HARD_PACKET_PERIOD = 20;
|
|
global.BUF_TYPE = 1;
|
|
global.STR_TYPE = 2;
|
|
global.MAX_STR_BUF_DATA = 200;
|
|
global.MAX_CONNECTION_ACTIVE = 40;
|
|
var MAX_CONNECTION_ANOTHER = 40;
|
|
const TRAFIC_LIMIT_NODE_1S = MAX_BLOCK_SIZE * 1.25;
|
|
const TRAFIC_LIMIT_1S = 8 * TRAFIC_LIMIT_NODE_1S;
|
|
global.STAT_PERIOD = CONSENSUS_PERIOD_TIME / 5;
|
|
const TRAFIC_LIMIT_SEND = TRAFIC_LIMIT_1S * STAT_PERIOD / 1000;
|
|
const TRAFIC_LIMIT_NODE = TRAFIC_LIMIT_NODE_1S * STAT_PERIOD / 1000;
|
|
const BUF_PACKET_SIZE = 32 * 1024;
|
|
global.FORMAT_POW_TO_CLIENT = "{addrArr:hash,HashRND:hash,MIN_POWER_POW_HANDSHAKE:uint,PubKeyType:byte,Sign:arr64,Reserve:arr33}";
|
|
global.FORMAT_POW_TO_SERVER = "{\
|
|
DEF_NETWORK:str15,\
|
|
DEF_VERSION:str9,\
|
|
DEF_CLIENT:str16, \
|
|
addrArr:addres, \
|
|
ToIP:str26,\
|
|
ToPort:uint16, \
|
|
FromIP:str26,\
|
|
FromPort:uint16, \
|
|
nonce:uint,\
|
|
Reconnect:byte,\
|
|
SendBytes:uint,\
|
|
PubKeyType:byte,\
|
|
Sign:arr64,\
|
|
SecretForReconnect:arr20,\
|
|
GrayConnect:byte,\
|
|
Reserve:arr14\
|
|
}";
|
|
const WorkStructPacketSend = {};
|
|
const FORMAT_PACKET_SEND_TCP = "{\
|
|
PacketSize:uint,\
|
|
NumXORRND:uint,\
|
|
Method:str25,\
|
|
NodeTime:time,\
|
|
Length:uint,\
|
|
ContextID:hash,\
|
|
TypeData:byte,\
|
|
Hash:hash,\
|
|
Data:data,\
|
|
}";
|
|
module.exports = class CTransport extends require("./connect")
|
|
{
|
|
constructor(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual)
|
|
{
|
|
super(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual)
|
|
this.UseRNDHeader = UseRNDHeader
|
|
this.BAN_IP = {}
|
|
this.ip = RunIP.trim()
|
|
this.port = RunPort
|
|
this.CanSend = 0
|
|
this.SendFormatMap = {}
|
|
this.ActualNodes = new RBTree(function (a,b)
|
|
{
|
|
if(b.Prioritet !== a.Prioritet)
|
|
return b.Prioritet - a.Prioritet;
|
|
return CompareArr(a.addrArr, b.addrArr);
|
|
})
|
|
this.SendTrafficFree = 0
|
|
this.LoadedPacketNum = 0
|
|
this.LoadedSocketNum = 0
|
|
setInterval(this.DoLoadBuf.bind(this), 1)
|
|
this.LoadBufSocketList = new RBTree(function (a,b)
|
|
{
|
|
if(b.SocketPrioritet !== a.SocketPrioritet)
|
|
return b.SocketPrioritet - a.SocketPrioritet;
|
|
return a.SocketNum - b.SocketNum;
|
|
})
|
|
this.BusyLevel = 0
|
|
this.LastTimeHard = 0
|
|
this.LastTimeHardOK = 0
|
|
setInterval(this.DoHardPacketForSend.bind(this), HARD_PACKET_PERIOD)
|
|
this.HardPacketForSend = new RBTree(function (a,b)
|
|
{
|
|
if(b.BlockProcessCount === a.BlockProcessCount)
|
|
return a.PacketNum - b.PacketNum;
|
|
else
|
|
return b.BlockProcessCount - a.BlockProcessCount;
|
|
})
|
|
setInterval(this.DoSendPacket.bind(this), 2)
|
|
setInterval(this.DoSendBuf.bind(this), 1)
|
|
var Map = {};
|
|
this.MethodTiming = Map
|
|
MethodTiming:
|
|
{
|
|
Map["TRANSFER"] = {Period:700, Hot:1}
|
|
Map["TRANSFERTX"] = {Period:700, Hot:1}
|
|
Map["TIME"] = {Period:2000, LowVersion:1, Hard:1, Immediately:1}
|
|
Map["PING"] = {Period:4000, LowVersion:1, Hard:1, Immediately:1}
|
|
Map["PONG"] = {Period:0, LowVersion:1, Immediately:1}
|
|
Map["ADDLEVELCONNECT"] = {Period:1000, Hard:1}
|
|
Map["RETADDLEVELCONNECT"] = {Period:0}
|
|
Map["DISCONNECTHOT"] = {Period:1000, Hard:1}
|
|
Map["GETMESSAGE"] = {Period:1000, Hard:1}
|
|
Map["MESSAGE"] = {Period:1000, Hard:1}
|
|
Map["TRANSACTION"] = {Period:PERIOD_GET_BLOCK, Hard:1}
|
|
Map["GETBLOCKHEADER"] = {Period:PERIOD_GET_BLOCK, Hard:2, Process:global.STATIC_PROCESS}
|
|
Map["GETBLOCK"] = {Period:PERIOD_GET_BLOCK, Hard:2, Process:global.STATIC_PROCESS}
|
|
Map["GETNODES"] = {Period:1000, Hard:1, LowVersion:1, IsAddrList:1}
|
|
Map["RETGETNODES"] = {Period:0, IsAddrList:1}
|
|
Map["RETGETNODES2"] = {Period:0, IsAddrList:1}
|
|
Map["GETCODE"] = {Period:10000, Hard:1, LowVersion:1, Process:global.STATIC_PROCESS}
|
|
Map["RETBLOCKHEADER"] = {Period:0}
|
|
Map["RETGETBLOCK"] = {Period:0}
|
|
Map["RETCODE"] = {Period:0}
|
|
Map["GETREST"] = {Period:1000, Hard:2, Process:global.STATIC_PROCESS}
|
|
Map["RETREST"] = {Period:0}
|
|
Map["GETSMART"] = {Period:1000, Hard:2, Process:global.STATIC_PROCESS}
|
|
Map["RETSMART"] = {Period:0}
|
|
}
|
|
if(!this.VirtualMode)
|
|
this.StartServer()
|
|
this.CurrentTimeStart = 0
|
|
this.CurrentTimeValues = {}
|
|
this.LoadNodesFromFile()
|
|
}
|
|
GetF(Method, bSend)
|
|
{
|
|
var name = Method + "-" + bSend;
|
|
var format = this.SendFormatMap[name];
|
|
if(!format)
|
|
{
|
|
var F = this.constructor[Method + "_F"];
|
|
if(typeof F === "function")
|
|
{
|
|
format = {struct:F(bSend), length:8096, wrk:{}}
|
|
}
|
|
else
|
|
{
|
|
format = "{}"
|
|
}
|
|
this.SendFormatMap[name] = format
|
|
}
|
|
return format;
|
|
}
|
|
SendF(Node, Info, Length)
|
|
{
|
|
var format = this.GetF(Info.Method, true);
|
|
if(!Length)
|
|
Length = format.length
|
|
Info.Data = BufLib.GetBufferFromObject(Info.Data, format.struct, Length, format.wrk)
|
|
this.Send(Node, Info, 1)
|
|
}
|
|
DataFromF(Info, bSendFormat)
|
|
{
|
|
var format = this.GetF(Info.Method, bSendFormat);
|
|
try
|
|
{
|
|
var Data = BufLib.GetObjectFromBuffer(Info.Data, format.struct, format.wrk);
|
|
return Data;
|
|
}
|
|
catch(e)
|
|
{
|
|
ToLog(e)
|
|
return {};
|
|
}
|
|
}
|
|
ADD_CURRENT_STAT_TIME(Key, Value)
|
|
{
|
|
var TimeNum = Math.floor(Date.now() / STAT_PERIOD);
|
|
if(this.CurrentTimeStart !== TimeNum)
|
|
this.CurrentTimeValues = {}
|
|
this.CurrentTimeStart = TimeNum
|
|
if(!this.CurrentTimeValues[Key])
|
|
this.CurrentTimeValues[Key] = 0
|
|
this.CurrentTimeValues[Key] += Value
|
|
}
|
|
GET_CURRENT_STAT_TIME(Key)
|
|
{
|
|
var TimeNum = Math.floor(Date.now() / STAT_PERIOD);
|
|
if(this.CurrentTimeStart === TimeNum)
|
|
{
|
|
var Value = this.CurrentTimeValues[Key];
|
|
if(Value === undefined)
|
|
return 0;
|
|
else
|
|
return Value;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
RecalcSendStatictic()
|
|
{
|
|
var TimeNum = Math.floor(Date.now() / STAT_PERIOD);
|
|
if(this.SendStatNum === TimeNum)
|
|
return ;
|
|
this.SendStatNum = TimeNum
|
|
var Period = CONSENSUS_PERIOD_TIME / STAT_PERIOD;
|
|
this.SendTrafficFree = TRAFIC_LIMIT_SEND
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
while((Node = it.next()) !== null)
|
|
{
|
|
{
|
|
var arr = Node.TrafficArr;
|
|
arr.push(Node.BufWriteLength)
|
|
Node.BufWriteLength = 0
|
|
if(arr.length > 5 * Period)
|
|
{
|
|
arr.shift()
|
|
}
|
|
else
|
|
{
|
|
if(arr.length < 3 * Period)
|
|
continue;
|
|
}
|
|
var arrAvg = [], arrK = [];
|
|
var valNext = CalcStatArr(arr, arrAvg, arrK, Period);
|
|
valNext = Math.min(valNext, TRAFIC_LIMIT_NODE)
|
|
Node.SendTrafficLimit = Math.min(this.SendTrafficFree, valNext * 1.1)
|
|
this.SendTrafficFree -= Node.SendTrafficLimit
|
|
}
|
|
Node.SendTrafficCurrent = 0
|
|
ADD_TO_STAT("MAX:NODE_TRAFFIC_LIMIT:" + NodeName(Node), 1000 / STAT_PERIOD * Node.SendTrafficLimit / 1024, 1)
|
|
}
|
|
this.SendTrafficFree += TRAFIC_LIMIT_NODE
|
|
ADD_TO_STAT("SEND_TRAFFIC_FREE", this.SendTrafficFree / 1024)
|
|
}
|
|
OnGetMethod(Info, CurTime)
|
|
{
|
|
if(DEBUG_MODE)
|
|
{
|
|
var Str = "";
|
|
if(Info.Data && Info.Data.Length)
|
|
Str = " LENGTH=" + Info.Data.Length
|
|
TO_DEBUG_LOG("GET:" + Info.Method + Str + " from: Node=" + NodeInfo(Info.Node))
|
|
}
|
|
if(global.ADDRLIST_MODE)
|
|
{
|
|
var StrOK = ",HAND,GETNODES,";
|
|
if(StrOK.indexOf("," + Info.Method + ",") === - 1)
|
|
return ;
|
|
}
|
|
Info.Node.LastTime = CurTime - 0
|
|
if(Info.Context && typeof Info.Context.F === "function")
|
|
{
|
|
Info.Context.F(Info, CurTime)
|
|
}
|
|
else
|
|
{
|
|
var F = this[Info.Method.toUpperCase()];
|
|
if(typeof F === "function")
|
|
{
|
|
F.bind(this)(Info, CurTime)
|
|
}
|
|
else
|
|
{
|
|
TO_ERROR_LOG("TRANSPORT", 20, "Method '" + Info.Method + "' not found Socket=*" + Info.Socket.ConnectID, "node", Info.Node)
|
|
this.AddCheckErrCount(Info.Node, 1, "Method not found")
|
|
}
|
|
}
|
|
}
|
|
GetActualNodes()
|
|
{
|
|
var Arr = [];
|
|
var it = this.ActualNodes.iterator(), Item;
|
|
while((Item = it.next()) !== null)
|
|
{
|
|
if(GetSocketStatus(Item.Socket) >= 100)
|
|
Arr.push(Item)
|
|
else
|
|
{
|
|
this.DeleteNodeFromActive(Item)
|
|
}
|
|
}
|
|
return Arr;
|
|
}
|
|
NodeIp(Node)
|
|
{
|
|
if(Node.ip_arrival)
|
|
{
|
|
return {ip:Node.ip_arrival, port:Node.port_arrival};
|
|
}
|
|
else
|
|
{
|
|
return {ip:Node.ip, port:Node.port};
|
|
}
|
|
}
|
|
SetXORHeader(buf, bForce)
|
|
{
|
|
if(this.UseRNDHeader || bForce)
|
|
{
|
|
var HashHashSign = shaarr(buf.slice(buf.length - 32, buf.length));
|
|
for(var i = 0; i < 32; i++)
|
|
buf[i] = HashHashSign[i] ^ buf[i]
|
|
}
|
|
}
|
|
WasBanIP(rinfo)
|
|
{
|
|
if(!rinfo || !rinfo.address)
|
|
return false;
|
|
var Key = "" + rinfo.address.trim();
|
|
var Stat = this.BAN_IP[Key];
|
|
if(Stat)
|
|
{
|
|
if(Stat.TimeTo > (GetCurrentTime(0) - 0))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
NodeInBan(Node)
|
|
{
|
|
return this.WasBanIP({address:Node.ip});
|
|
}
|
|
DeleteNodeFromActiveByIP(ip)
|
|
{
|
|
var Arr = this.GetActualNodes();
|
|
for(var i = 0; i < Arr.length; i++)
|
|
{
|
|
var Node = Arr[i];
|
|
if(Node.ip === ip)
|
|
{
|
|
this.DeleteNodeFromActive(Node)
|
|
}
|
|
}
|
|
}
|
|
AddToBan(Node, Str)
|
|
{
|
|
if(global.NeedRestart)
|
|
return ;
|
|
this.DeleteNodeFromActive(Node)
|
|
if(!Node.ip)
|
|
return ;
|
|
var Key = "" + Node.ip.trim();
|
|
if(!Node.DeltaBan)
|
|
Node.DeltaBan = 300
|
|
if(Node.DeltaBan > 1000000)
|
|
Node.DeltaBan = 1000000
|
|
Node.DeltaBan = Node.DeltaBan * 2
|
|
var TimeTo = (GetCurrentTime(0) - 0) + Node.DeltaBan * 1000;
|
|
this.BAN_IP[Key] = {TimeTo:TimeTo}
|
|
Node.BlockProcessCount = 0
|
|
this.DeleteNodeFromActiveByIP(Node.ip)
|
|
ADD_TO_STAT("AddToBan")
|
|
}
|
|
AddToBanIP(ip, Str, Period)
|
|
{
|
|
if(!Period)
|
|
Period = 600 * 1000
|
|
var Key = "" + ip.trim();
|
|
this.BAN_IP[Key] = {TimeTo:(GetCurrentTime(0) - 0) + Period}
|
|
this.DeleteNodeFromActiveByIP(ip)
|
|
ToLog("ADD TO BAN:: " + Key + " " + Str)
|
|
ADD_TO_STAT("AddToBanIP")
|
|
}
|
|
OnPacketTCP(Meta)
|
|
{
|
|
var startTime = process.hrtime();
|
|
ADD_TO_STAT("USEPACKET")
|
|
var CurTime = GetCurrentTime();
|
|
Meta.Node.LastTime = CurTime - 0
|
|
if(Meta.MethodTiming.Process && Meta.MethodTiming.Process.Worker)
|
|
{
|
|
var Data = this.DataFromF(Meta);
|
|
Meta.MethodTiming.Process.Worker.send({cmd:Meta.Method, Data:Data, addrStr:Meta.Node.addrStr, Context:Meta.Context})
|
|
}
|
|
else
|
|
{
|
|
this.OnGetMethod(Meta, CurTime)
|
|
}
|
|
ADD_TO_STAT_TIME("MAX:TIME_USE_PACKET", startTime)
|
|
ADD_TO_STAT_TIME("TIME_USE_PACKET", startTime)
|
|
ADD_TO_STAT_TIME("MAX:TIME_USE_PACKET:" + Meta.Method, startTime)
|
|
}
|
|
GetBufFromData(Method, Data, TypeData, ContextID)
|
|
{
|
|
var BufData;
|
|
if(TypeData === BUF_TYPE)
|
|
{
|
|
BufData = Data
|
|
}
|
|
else
|
|
if(TypeData === STR_TYPE)
|
|
{
|
|
BufData = Buffer.from(Data.substr(0, MAX_STR_BUF_DATA))
|
|
}
|
|
else
|
|
{
|
|
if(Data === undefined)
|
|
{
|
|
TypeData = BUF_TYPE
|
|
BufData = Buffer.alloc(0)
|
|
}
|
|
else
|
|
{
|
|
throw "ERROR TYPE DATA";
|
|
}
|
|
}
|
|
var BUF = {};
|
|
BUF.PacketSize = 0
|
|
BUF.NumXORRND = 0
|
|
BUF.Method = Method
|
|
BUF.NodeTime = GetCurrentTime()
|
|
BUF.TypeData = TypeData
|
|
BUF.Length = BufData.length
|
|
BUF.Data = BufData
|
|
BUF.ContextID = ContextID
|
|
BUF.Hash = this.GetHashFromData(BUF)
|
|
var BufWrite = BufLib.GetBufferFromObject(BUF, FORMAT_PACKET_SEND_TCP, BufData.length + 300, WorkStructPacketSend);
|
|
BufWrite.len = 0
|
|
BufLib.Write(BufWrite, BufWrite.length, "uint")
|
|
return BufWrite;
|
|
}
|
|
GetDataFromBuf(buf)
|
|
{
|
|
try
|
|
{
|
|
var Meta = BufLib.GetObjectFromBuffer(buf, FORMAT_PACKET_SEND_TCP, WorkStructPacketSend);
|
|
}
|
|
catch(e)
|
|
{
|
|
TO_ERROR_LOG("TRANSPORT", 640, "Error parsing Buffer")
|
|
return undefined;
|
|
}
|
|
var Hash = this.GetHashFromData(Meta);
|
|
if(CompareArr(Hash, Meta.Hash) !== 0)
|
|
{
|
|
if(global.WATCHDOG_DEV)
|
|
TO_ERROR_LOG("TRANSPORT", 645, "Error hash Buffer")
|
|
return undefined;
|
|
}
|
|
if(Meta.TypeData === STR_TYPE)
|
|
{
|
|
Meta.Data = Meta.Data.slice(0, MAX_STR_BUF_DATA).toString()
|
|
}
|
|
return Meta;
|
|
}
|
|
GetHashFromData(Info)
|
|
{
|
|
return shaarr(Info.Method + Info.Length + "-" + (Info.NodeTime - 0));
|
|
}
|
|
OnGetFromTCP(Node, Socket, Buf)
|
|
{
|
|
if(!Node)
|
|
return ;
|
|
if(!Node.Socket)
|
|
Node.Socket = Socket
|
|
if(!Socket.Buf || Socket.Buf.length === 0)
|
|
{
|
|
Socket.Buf = Buf
|
|
}
|
|
else
|
|
{
|
|
Socket.Buf = Buffer.concat([Socket.Buf, Buf])
|
|
}
|
|
if(!Socket.SocketNum)
|
|
{
|
|
this.LoadedSocketNum++
|
|
Socket.SocketNum = this.LoadedSocketNum
|
|
Socket.SocketPrioritet = Node.BlockProcessCount
|
|
}
|
|
this.LoadBufSocketList.insert(Socket)
|
|
}
|
|
DoLoadBuf()
|
|
{
|
|
var Socket = this.LoadBufSocketList.min();
|
|
if(!Socket)
|
|
return ;
|
|
this.LoadBufSocketList.remove(Socket)
|
|
if(Socket.WasClose)
|
|
return ;
|
|
while(true)
|
|
{
|
|
if(Socket.Buf && Socket.Buf.length > 6)
|
|
{
|
|
ADD_TO_STAT("MAX:BUFFE_LOAD_SIZE", Socket.Buf.length / 1024)
|
|
Socket.Buf.len = 0
|
|
var PacketSize = BufLib.Read(Socket.Buf, "uint");
|
|
if(PacketSize > MAX_PACKET_LENGTH)
|
|
{
|
|
this.SendCloseSocket(Socket, "MAX_PACKET_LENGTH")
|
|
break;
|
|
}
|
|
else
|
|
if(Socket.Buf.length >= PacketSize)
|
|
{
|
|
var data = Socket.Buf.slice(0, PacketSize);
|
|
Socket.Buf = Socket.Buf.slice(PacketSize, Socket.Buf.length)
|
|
var Res = this.DoDataFromTCP(Socket, data);
|
|
if(Res)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
DoDataFromTCP(Socket, buf)
|
|
{
|
|
this.LoadedPacketNum++
|
|
var Node = Socket.Node;
|
|
if(!Node)
|
|
return 0;
|
|
var startTime = process.hrtime();
|
|
ADD_TO_STAT("GETDATA(KB)", buf.length / 1024)
|
|
ADD_TO_STAT("GETDATA(KB):" + NodeName(Node), buf.length / 1024, 1)
|
|
if(!Node.TransferSize)
|
|
Node.TransferSize = 0
|
|
Node.TransferSize += buf.length / 1024
|
|
Node.TransferBlockNumFix = this.CurrentBlockNum
|
|
var Buf = this.GetDataFromBuf(buf);
|
|
if(!Buf)
|
|
{
|
|
this.AddCheckErrCount(Node, 1, "Err GetDataFromBuf")
|
|
this.SendCloseSocket(Socket, "FORMAT_PACKET_SEND_TCP")
|
|
return 0;
|
|
}
|
|
ADD_TO_STAT("GET:" + Buf.Method)
|
|
ADD_TO_STAT("GET:(KB)" + Buf.Method, buf.length / 1024)
|
|
ADD_TO_STAT("GET:" + Buf.Method + ":" + NodeName(Node), 1, 1)
|
|
var Param = this.MethodTiming[Buf.Method];
|
|
if(this.StopDoSendPacket(Param, Node, Buf.Method))
|
|
{
|
|
return 1;
|
|
}
|
|
if(!IsZeroArr(Buf.ContextID))
|
|
{
|
|
Buf.Context = global.ContextPackets.LoadValue(Buf.ContextID)
|
|
}
|
|
if(!Buf.Context)
|
|
{
|
|
if(Param && Param.Period === 0 && Buf.Method !== "RETBLOCKHEADER")
|
|
{
|
|
this.AddCheckErrCount(Node, 1)
|
|
return ;
|
|
}
|
|
Buf.Context = {}
|
|
}
|
|
Buf.Context.ContextID = Buf.ContextID
|
|
Buf.Node = Node
|
|
Buf.Socket = Socket
|
|
Buf.MethodTiming = Param
|
|
if(!global.ADDRLIST_MODE || Param.IsAddrList)
|
|
{
|
|
if(Param.Hard)
|
|
{
|
|
if(Param.Immediately && this.HardPacketForSend.size <= 3)
|
|
{
|
|
this.OnPacketTCP(Buf)
|
|
}
|
|
else
|
|
{
|
|
Buf.PacketNum = this.LoadedPacketNum
|
|
Buf.BlockProcessCount = Node.BlockProcessCount
|
|
Buf.TimeLoad = Date.now()
|
|
this.HardPacketForSend.insert(Buf)
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.OnPacketTCP(Buf)
|
|
}
|
|
}
|
|
ADD_TO_STAT_TIME("MAX:TIMEDOGETDATA", startTime)
|
|
return 1;
|
|
}
|
|
StopDoSendPacket(Param, Node, Name)
|
|
{
|
|
var CurTime = GetCurrentTime(0) - 0;
|
|
if(!Param)
|
|
{
|
|
ADD_TO_STAT("STOP_METHOD")
|
|
ADD_TO_STAT("STOP_METHOD:NO")
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 1;
|
|
}
|
|
if(Param.Hot && !Node.Hot)
|
|
{
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 0;
|
|
}
|
|
if(Param.Period && !Node.VersionOK && !Param.LowVersion)
|
|
{
|
|
ADD_TO_STAT("STOP_METHOD")
|
|
ADD_TO_STAT("STOP_METHOD:LOWVERSION:" + Name)
|
|
return 1;
|
|
}
|
|
if(global.STOPGETBLOCK && Param.Hard === 2 && Node.BlockProcessCount < 1000000)
|
|
{
|
|
Node.NextPing = 1 * 1000
|
|
ADD_TO_STAT("STOP_METHOD")
|
|
ADD_TO_STAT("STOP_METHOD:STOPGETBLOCK:" + Name)
|
|
this.AddCheckErrCount(Node, 0.5)
|
|
return 1;
|
|
}
|
|
var ArrTime = Node.TimeMap[Name];
|
|
if(!ArrTime)
|
|
{
|
|
ArrTime = [0, 0, 0]
|
|
Node.TimeMap[Name] = ArrTime
|
|
}
|
|
ArrTime.sort(function (a,b)
|
|
{
|
|
return a - b;
|
|
})
|
|
var Delta = CurTime - ArrTime[0];
|
|
if(Delta < Param.Period)
|
|
{
|
|
ADD_TO_STAT("STOP_METHOD")
|
|
ADD_TO_STAT("STOP_METHOD:" + Name)
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 1;
|
|
}
|
|
ArrTime[0] = CurTime
|
|
return 0;
|
|
}
|
|
DoHardPacketForSend()
|
|
{
|
|
ADD_TO_STAT("MAX:BUSY_LEVEL", this.BusyLevel)
|
|
ADD_TO_STAT("MAX:HARD_PACKET_SIZE", this.HardPacketForSend.size)
|
|
var Delta = Date.now() - this.LastTimeHard;
|
|
this.LastTimeHard = Date.now()
|
|
if(Delta > global.HARD_PACKET_PERIOD120 * HARD_PACKET_PERIOD / 100)
|
|
{
|
|
ADD_TO_STAT("HARD_PACKET_PERIOD120")
|
|
var Delta2 = Date.now() - this.LastTimeHardOK;
|
|
if(Delta2 > 100)
|
|
{
|
|
var Info = this.HardPacketForSend.min();
|
|
this.RiseBusyLevelByInfo(Info)
|
|
}
|
|
return ;
|
|
}
|
|
if(this.BusyLevel)
|
|
this.BusyLevel = this.BusyLevel / 1.1
|
|
this.LastTimeHardOK = Date.now()
|
|
ADD_TO_STAT("HARD_PACKET_PERIOD")
|
|
this.DoHardPacketForSendNext()
|
|
}
|
|
RiseBusyLevelByInfo(Info)
|
|
{
|
|
if(!Info)
|
|
return ;
|
|
if(!this.BusyLevel)
|
|
this.BusyLevel = 1
|
|
if(Info.BlockProcessCount > this.BusyLevel)
|
|
this.BusyLevel = Info.BlockProcessCount + 1
|
|
if(this.BusyLevel <= 0)
|
|
this.BusyLevel = 1
|
|
}
|
|
DropBusyLevelByInfo(Info)
|
|
{
|
|
if(!Info)
|
|
return ;
|
|
if(this.BusyLevel > Info.BlockProcessCount)
|
|
this.BusyLevel = Info.BlockProcessCount - 1
|
|
if(this.BusyLevel < 0)
|
|
this.BusyLevel = 0
|
|
}
|
|
DoHardPacketForSendNext()
|
|
{
|
|
var Info = this.HardPacketForSend.min();
|
|
if(!Info)
|
|
{
|
|
this.BusyLevel = 0
|
|
return ;
|
|
}
|
|
this.DropBusyLevelByInfo(Info)
|
|
this.HardPacketForSend.remove(Info)
|
|
this.OnPacketTCP(Info)
|
|
ADD_TO_STAT("DO_HARD_PACKET")
|
|
ADD_TO_STAT("DO_HARD_PACKET:" + Info.Method)
|
|
var DeltaTime = Date.now() - Info.TimeLoad;
|
|
if(this.HardPacketForSend.size && DeltaTime > PACKET_ALIVE_PERIOD / 2)
|
|
{
|
|
ADD_TO_STAT("DELETE_HARD_PACKET_OLD", this.HardPacketForSend.size)
|
|
this.HardPacketForSend.clear()
|
|
return ;
|
|
}
|
|
var MaxCount = 20;
|
|
while(Info = this.HardPacketForSend.max())
|
|
{
|
|
var DeltaTime = Date.now() - Info.TimeLoad;
|
|
if(DeltaTime > PACKET_ALIVE_PERIOD / 2 || !Info.Node.Socket || Info.Node.Socket.WasClose)
|
|
{
|
|
this.HardPacketForSend.remove(Info)
|
|
if(DeltaTime > PACKET_ALIVE_PERIOD / 2)
|
|
{
|
|
this.RiseBusyLevelByInfo(Info)
|
|
Info.Node.NextPing = 1 * 1000
|
|
this.AddCheckErrCount(Info.Node, 0.2)
|
|
ADD_TO_STAT("DELETE_HARD_PACKET_OLD")
|
|
ADD_TO_STAT("DELETE_HARD_PACKET_OLD:" + Info.Method)
|
|
}
|
|
else
|
|
{
|
|
ADD_TO_STAT("DELETE_HARD_PACKET_NO_ALIVE")
|
|
}
|
|
}
|
|
MaxCount--
|
|
if(MaxCount <= 0)
|
|
break;
|
|
}
|
|
}
|
|
Send(Node, Info, TypeData)
|
|
{
|
|
if(!Node.Socket)
|
|
{
|
|
this.DeleteNodeFromActive(Node)
|
|
return ;
|
|
}
|
|
if(Info.Context)
|
|
{
|
|
Info.ContextID = Info.Context.ContextID
|
|
if(!Info.ContextID)
|
|
{
|
|
Info.ContextID = crypto.randomBytes(32)
|
|
Info.Context.ContextID = Info.ContextID
|
|
}
|
|
global.ContextPackets.SaveValue(Info.ContextID, Info.Context)
|
|
}
|
|
else
|
|
{
|
|
Info.ContextID = []
|
|
}
|
|
Node.SendPacketNum++
|
|
Info.Node = Node
|
|
Info.TypeData = TypeData
|
|
Info.Prioritet = Node.Prioritet
|
|
Info.PacketNum = Node.SendPacketNum
|
|
Info.TimeNum = Date.now()
|
|
Node.SendPacket.insert(Info)
|
|
}
|
|
DoSendPacketNodeAll(Node)
|
|
{
|
|
while(this.DoSendPacketNode(Node) === 1);
|
|
}
|
|
DoSendPacketNode(Node)
|
|
{
|
|
var TimeNum = Date.now();
|
|
var Info = Node.SendPacket.max();
|
|
if(Info && TimeNum - Info.TimeNum > PACKET_ALIVE_PERIOD)
|
|
while(Info = Node.SendPacket.max())
|
|
{
|
|
var DeltaTime = TimeNum - Info.TimeNum;
|
|
if(DeltaTime > PACKET_ALIVE_PERIOD / 2)
|
|
{
|
|
Node.SendPacket.remove(Info)
|
|
ADD_TO_STAT("DELETE_OLD_PACKET")
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
Info = Node.SendPacket.min()
|
|
if(!Info)
|
|
return 0;
|
|
ADD_TO_STAT("MAX:NODE_BUF_WRITE:" + NodeName(Node), Node.BufWrite.length / 1024, 1)
|
|
ADD_TO_STAT("MAX:NODE_SEND_BUF_PACKET_COUNT:" + NodeName(Node), Node.SendPacket.size, 1)
|
|
if(Node.BufWrite.length > 2 * TRAFIC_LIMIT_1S)
|
|
{
|
|
return 2;
|
|
}
|
|
Node.SendPacket.remove(Info)
|
|
if(Info.Context)
|
|
{
|
|
if(!Info.Context.SendCount)
|
|
Info.Context.SendCount = 0
|
|
Info.Context.SendCount++
|
|
}
|
|
var BufWrite = this.GetBufFromData(Info.Method, Info.Data, Info.TypeData, Info.ContextID);
|
|
Node.BufWriteLength += BufWrite.length
|
|
if(Node.BufWrite.length === 0)
|
|
Node.BufWrite = BufWrite
|
|
else
|
|
Node.BufWrite = Buffer.concat([Node.BufWrite, BufWrite])
|
|
ADD_TO_STAT("SEND:" + Info.Method)
|
|
ADD_TO_STAT("SEND:(KB)" + Info.Method, BufWrite.length / 1024)
|
|
ADD_TO_STAT("SEND:" + Info.Method + ":" + NodeName(Node), 1, 1)
|
|
TO_DEBUG_LOG("SEND " + Info.Method + " to " + NodeInfo(Node) + " LENGTH=" + BufWrite.length)
|
|
return 1;
|
|
}
|
|
DoSendPacket()
|
|
{
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
while((Node = it.next()) !== null)
|
|
if(Node.ConnectStatus() === 100)
|
|
{
|
|
this.DoSendPacketNode(Node)
|
|
}
|
|
else
|
|
{
|
|
ADD_TO_STAT("SEND_ERROR")
|
|
this.AddCheckErrCount(Node, 0.005, "NODE STATUS=" + Node.ConnectStatus())
|
|
}
|
|
}
|
|
DoSendBuf()
|
|
{
|
|
this.RecalcSendStatictic()
|
|
var CountNodeSend = 0;
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
NEXT_NODE:
|
|
while((Node = it.next()) !== null)
|
|
if(Node.Socket && Node.ConnectStatus() === 100)
|
|
if(Node.BufWrite.length > 0)
|
|
{
|
|
CountNodeSend++
|
|
var CountSend = Math.min(BUF_PACKET_SIZE, Node.BufWrite.length);
|
|
var Value = CountSend / 1024;
|
|
if(global.LIMIT_SEND_TRAFIC)
|
|
{
|
|
var CanCountSend = Node.SendTrafficLimit - Node.SendTrafficCurrent;
|
|
if(CanCountSend < CountSend)
|
|
{
|
|
if(this.SendTrafficFree < CountSend)
|
|
{
|
|
ADD_TO_STAT("LIMIT_SENDDATA:" + NodeName(Node), Value, 1)
|
|
continue NEXT_NODE;
|
|
}
|
|
this.SendTrafficFree -= CountSend
|
|
}
|
|
}
|
|
Node.write(Node.BufWrite.slice(0, CountSend))
|
|
Node.SendTrafficCurrent += CountSend
|
|
Node.BufWrite = Node.BufWrite.slice(CountSend)
|
|
this.ADD_CURRENT_STAT_TIME("SEND_DATA", Value)
|
|
ADD_TO_STAT("SENDDATA(KB)", Value)
|
|
ADD_TO_STAT("SENDDATA(KB):" + NodeName(Node), Value, 1)
|
|
}
|
|
}
|
|
CheckPOWTicketConnect(Socket, data)
|
|
{
|
|
try
|
|
{
|
|
var Info = BufLib.GetObjectFromBuffer(data, FORMAT_POW_TO_SERVER, {});
|
|
}
|
|
catch(e)
|
|
{
|
|
this.SendCloseSocket(Socket, "FORMAT_POW_TO_SERVER")
|
|
return ;
|
|
}
|
|
if(Info.DEF_NETWORK !== GetNetworkName())
|
|
{
|
|
this.SendCloseSocket(Socket, "DEF_NETWORK=" + Info.DEF_NETWORK + " MUST:" + GetNetworkName())
|
|
return ;
|
|
}
|
|
var Node = this.FindRunNodeContext(Info.addrArr, Info.FromIP, Info.FromPort, true);
|
|
if(CompareArr(Info.addrArr, this.addrArr) === 0)
|
|
{
|
|
AddNodeInfo(Node, "SERV: GET SELF")
|
|
this.SendCloseSocket(Socket, "SELF")
|
|
return ;
|
|
}
|
|
var Hash = shaarr2(this.addrArr, Socket.HashRND);
|
|
var hashInfo = GetHashWithValues(Hash, Info.nonce, 0);
|
|
var power = GetPowPower(hashInfo);
|
|
if(Info.Reconnect)
|
|
{
|
|
if((Node.SecretForReconnect && Node.WaitConnectFromServer && CompareArr(Node.SecretForReconnect, Info.SecretForReconnect) === 0) || Info.Reconnect === 255)
|
|
{
|
|
var Result = 1;
|
|
if(Info.Reconnect === 255)
|
|
{
|
|
Result = CheckDevelopSign(Hash, Info.Sign)
|
|
}
|
|
if(Result)
|
|
{
|
|
Node.NextConnectDelta = 1000
|
|
Node.WaitConnectFromServer = 0
|
|
Node.GrayConnect = 0
|
|
AddNodeInfo(Node, "3. SERVER OK CONNECT for client node " + SocketInfo(Socket))
|
|
this.AddNodeToActive(Node)
|
|
Node.Socket = Socket
|
|
SetSocketStatus(Socket, 3)
|
|
SetSocketStatus(Socket, 100)
|
|
Socket.Node = Node
|
|
Socket.write(this.GetBufFromData("POW_CONNECT0", "OK", 2))
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
Node.NextConnectDelta = 60 * 1000
|
|
ToLog("Error Sign Node from " + NodeInfo(Node))
|
|
this.AddCheckErrCount(Node, 10, "Error Sign Node")
|
|
}
|
|
}
|
|
AddNodeInfo(Node, "SERV: ERROR_RECONNECT")
|
|
Socket.end(this.GetBufFromData("POW_CONNEC11", "ERROR_RECONNECT", 2))
|
|
CloseSocket(Socket, "ERROR_RECONNECT")
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
if(power < MIN_POWER_POW_HANDSHAKE)
|
|
{
|
|
ToLog("END: MIN_POWER_POW_HANDSHAKE")
|
|
AddNodeInfo(Node, "SERV: ERR MIN_POWER_POW_HANDSHAKE")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT2", "MIN_POWER_POW_HANDSHAKE", 2))
|
|
CloseSocket(Socket, "MIN_POWER_POW_HANDSHAKE")
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
if(!Node.BlockProcessCount)
|
|
Node.BlockProcessCount = 0
|
|
if(this.ActualNodes.size >= MAX_CONNECTIONS_COUNT && Node.BlockProcessCount < global.TRUST_PROCESS_COUNT)
|
|
{
|
|
AddNodeInfo(Node, "SERV: ERROR_MAX_CLIENTS")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT8", "ERROR_MAX_CLIENTS", 2))
|
|
CloseSocket(Socket, "ERROR_MAX_CLIENTS")
|
|
return ;
|
|
}
|
|
var Result = false;
|
|
if(Info.PubKeyType === 2 || Info.PubKeyType === 3)
|
|
Result = secp256k1.verify(Buffer.from(Hash), Buffer.from(Info.Sign), Buffer.from([Info.PubKeyType].concat(Info.addrArr)))
|
|
if(!Result)
|
|
{
|
|
AddNodeInfo(Node, "SERV: ERROR_SIGN_CLIENT")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT8", "ERROR_SIGN_CLIENT", 2))
|
|
CloseSocket(Socket, "ERROR_SIGN_CLIENT")
|
|
this.AddToBanIP(Socket.remoteAddress, "ERROR_SIGN_CLIENT")
|
|
return ;
|
|
}
|
|
AddNodeInfo(Node, "1. SERVER OK POW for client node " + SocketInfo(Socket))
|
|
Node.FromIP = Info.FromIP
|
|
Node.FromPort = Info.FromPort
|
|
Node.SecretForReconnect = crypto.randomBytes(20)
|
|
Node.PubKey = Buffer.from([Info.PubKeyType].concat(Info.addrArr))
|
|
if(Info.GrayConnect)
|
|
{
|
|
Node.NextConnectDelta = 1000
|
|
Node.WaitConnectFromServer = 0
|
|
Node.GrayConnect = 1
|
|
AddNodeInfo(Node, "5. CLIENT OK GRAY CONNECT " + SocketInfo(Socket))
|
|
this.AddNodeToActive(Node)
|
|
Node.Socket = Socket
|
|
SetSocketStatus(Socket, 3)
|
|
SetSocketStatus(Socket, 100)
|
|
Socket.Node = Node
|
|
Socket.write(this.GetBufFromData("POW_CONNECT0", "OK", 2))
|
|
return ;
|
|
}
|
|
if(!Node.WasAddToReconnect)
|
|
{
|
|
Node.WasAddToReconnect = 1
|
|
Node.ReconnectFromServer = 1
|
|
global.ArrReconnect.push(Node)
|
|
}
|
|
Socket.write(this.GetBufFromData("POW_CONNECT4", "WAIT_CONNECT_FROM_SERVER:" + GetHexFromArr(Node.SecretForReconnect), 2))
|
|
}
|
|
}
|
|
}
|
|
StopServer()
|
|
{
|
|
if(this.Server)
|
|
this.Server.close()
|
|
}
|
|
StartServer()
|
|
{
|
|
if(GrayConnect())
|
|
{
|
|
this.CanSend++
|
|
return ;
|
|
}
|
|
let SELF = this;
|
|
this.Server = net.createServer(function (sock)
|
|
{
|
|
if(SELF.WasBanIP({address:sock.remoteAddress}))
|
|
{
|
|
sock.ConnectID = "new"
|
|
CloseSocket(sock, "WAS BAN", true)
|
|
return ;
|
|
}
|
|
let SOCKET = sock;
|
|
socketInit(SOCKET, "c")
|
|
SetSocketStatus(SOCKET, 0)
|
|
AddNodeInfo(SOCKET, "Client *" + SOCKET.ConnectID + " connected from " + SOCKET.remoteAddress + ":" + SOCKET.remotePort, 1)
|
|
ADD_TO_STAT("ClientConnected")
|
|
SOCKET.HashRND = crypto.randomBytes(32)
|
|
var Data = {addrArr:SELF.addrArr, HashRND:SOCKET.HashRND, MIN_POWER_POW_HANDSHAKE:MIN_POWER_POW_HANDSHAKE, PubKeyType:SELF.PubKeyType,
|
|
Sign:SELF.ServerSign, Reserve:[]};
|
|
var BufData = BufLib.GetBufferFromObject(Data, FORMAT_POW_TO_CLIENT, 300, {});
|
|
var BufWrite = SELF.GetBufFromData("POW_CONNECT5", BufData, 1);
|
|
try
|
|
{
|
|
SOCKET.write(BufWrite)
|
|
}
|
|
catch(e)
|
|
{
|
|
ToError(e)
|
|
SOCKET = undefined
|
|
return ;
|
|
}
|
|
SOCKET.on('data', function (data)
|
|
{
|
|
if(SOCKET.WasClose)
|
|
{
|
|
return ;
|
|
}
|
|
if(!SOCKET.Node)
|
|
{
|
|
var Buf = SELF.GetDataFromBuf(data);
|
|
if(Buf)
|
|
{
|
|
SELF.CheckPOWTicketConnect(SOCKET, Buf.Data)
|
|
SOCKET.ConnectToServer = 0
|
|
return ;
|
|
}
|
|
CloseSocket(SOCKET, "=SERVER ON DATA=")
|
|
}
|
|
else
|
|
{
|
|
socketRead(SOCKET, data)
|
|
SELF.OnGetFromTCP(SOCKET.Node, SOCKET, data)
|
|
}
|
|
})
|
|
SOCKET.on('end', function ()
|
|
{
|
|
ADD_TO_STAT("ClientEnd")
|
|
var Node = SOCKET.Node;
|
|
var Status = GetSocketStatus(SOCKET);
|
|
if(Status)
|
|
AddNodeInfo(Node, "Get socket end *" + SOCKET.ConnectID + " from client Stat: " + SocketStatistic(SOCKET))
|
|
if(Node && Status === 200)
|
|
{
|
|
Node.SwapSockets()
|
|
SOCKET.WasClose = 1
|
|
}
|
|
})
|
|
SOCKET.on('close', function (err)
|
|
{
|
|
ADD_TO_STAT("ClientClose")
|
|
if(SOCKET.ConnectID && GetSocketStatus(SOCKET))
|
|
AddNodeInfo(SOCKET.Node, "Get socket close *" + SOCKET.ConnectID + " from client Stat: " + SocketStatistic(SOCKET))
|
|
if(!SOCKET.WasClose && SOCKET.Node)
|
|
{
|
|
CloseSocket(SOCKET, "GET CLOSE")
|
|
}
|
|
SetSocketStatus(SOCKET, 0)
|
|
})
|
|
SOCKET.on('error', function (err)
|
|
{
|
|
ADD_TO_STAT("ERRORS")
|
|
CloseSocket(SOCKET, "ERRORS")
|
|
if(SOCKET.Node)
|
|
SELF.AddCheckErrCount(SOCKET.Node, 1, "ERR##2 : socket")
|
|
})
|
|
})
|
|
this.Server.on('close', function ()
|
|
{
|
|
})
|
|
this.Server.on('error', function (err)
|
|
{
|
|
if(err.code === 'EADDRINUSE')
|
|
{
|
|
ToLogClient('Port ' + SELF.port + ' in use, retrying...')
|
|
if(SELF.Server)
|
|
SELF.Server.close()
|
|
setTimeout(function ()
|
|
{
|
|
SELF.RunListenServer()
|
|
}, 5000)
|
|
return ;
|
|
}
|
|
ADD_TO_STAT("ERRORS")
|
|
ToError("ERR##3")
|
|
})
|
|
if(!SELF.ip)
|
|
{
|
|
this.FindInternetIP()
|
|
}
|
|
else
|
|
{
|
|
this.CanSend++
|
|
this.RunListenServer()
|
|
}
|
|
}
|
|
RunListenServer()
|
|
{
|
|
if(!START_PORT_NUMBER || START_PORT_NUMBER === "undefined")
|
|
START_PORT_NUMBER = 30000
|
|
let SELF = this;
|
|
SELF.port = START_PORT_NUMBER
|
|
ToLogClient("Prepare to run TCP server on port: " + SELF.port)
|
|
this.Server.listen(SELF.port, '0.0.0.0', function ()
|
|
{
|
|
if(SELF.CanSend < 2)
|
|
ToLogClient("Run TCP server on " + SELF.ip + ":" + SELF.port)
|
|
SELF.CanSend++
|
|
var Hash = shaarr(SELF.addrStr);
|
|
SELF.ServerSign = secp256k1.sign(Buffer.from(Hash), SELF.KeyPair.getPrivateKey('')).signature
|
|
})
|
|
}
|
|
FindInternetIP()
|
|
{
|
|
let SELF = this;
|
|
let server = Stun.createServer(this.Net4);
|
|
const request = Stun.createMessage(Stun.constants.STUN_BINDING_REQUEST);
|
|
server.on('error', function (err)
|
|
{
|
|
SELF.CanSend++
|
|
})
|
|
server.once('bindingResponse', function (stunMsg)
|
|
{
|
|
var value = stunMsg.getAttribute(Stun.constants.STUN_ATTR_XOR_MAPPED_ADDRESS).value;
|
|
ToLog("INTERNET IP:" + value.address)
|
|
SELF.CanSend++
|
|
global.INTERNET_IP_FROM_STUN = value.address
|
|
if(!SELF.ip)
|
|
SELF.ip = INTERNET_IP_FROM_STUN
|
|
if(server)
|
|
server.close()
|
|
SELF.RunListenServer()
|
|
})
|
|
var StrStunAddr = 'stun.l.google.com';
|
|
const dns = require('dns');
|
|
dns.lookup(StrStunAddr, function (err,address,family)
|
|
{
|
|
if(!err)
|
|
server.send(request, 19302, StrStunAddr)
|
|
else
|
|
SELF.CanSend++
|
|
})
|
|
}
|
|
CLOSE_SOCKET(Context, CurTime)
|
|
{
|
|
AddNodeInfo(Context.Socket.Node, "GET CLOSE_SOCKET *" + Context.Socket.ConnectID + ": " + Context.Data.toString())
|
|
CloseSocket(Context.Socket, "CLOSE_SOCKET")
|
|
}
|
|
SendCloseSocket(Socket, Str)
|
|
{
|
|
AddNodeInfo(Socket.Node, "CLOSE_SOCKET " + SocketInfo(Socket) + " - " + Str)
|
|
if(Socket.WasClose)
|
|
{
|
|
return ;
|
|
}
|
|
this.AddCheckErrCount(Socket.Node, 1, "SendCloseSocket")
|
|
if(Socket.Node && Socket.Node.BufWrite && Socket.Node.BufWrite.length > 0)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
AddNodeInfo(Socket.Node, "END *" + Socket.ConnectID + ": " + Str)
|
|
Socket.end(this.GetBufFromData("CLOSE_SOCKET", Str, 2))
|
|
}
|
|
CloseSocket(Socket, Str)
|
|
}
|
|
AddCheckErrCount(Node, Count, StrErr)
|
|
{
|
|
if(!Node)
|
|
return ;
|
|
if(!Count)
|
|
Count = 1
|
|
var Delta = Date.now() - Node.LastTimeError;
|
|
if(Delta > 10 * 1000)
|
|
{
|
|
Node.ErrCount = 0
|
|
}
|
|
Node.LastTimeError = Date.now()
|
|
Node.ErrCountAll += Count
|
|
Node.ErrCount += Count
|
|
if(Node.ErrCount >= 5)
|
|
{
|
|
Node.ErrCount = 0
|
|
ADD_TO_STAT("ERRORS")
|
|
Node.BlockProcessCount--
|
|
if(Node.BlockProcessCount < - 30)
|
|
{
|
|
if(!StrErr)
|
|
StrErr = ""
|
|
this.AddToBan(Node, StrErr + " BlockProcess:" + Node.BlockProcessCount)
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
}
|
|
};
|
|
global.ContextPackets = new STreeBuffer(10 * 1000, CompareItemHash32, "object");
|
|
|
|
function CalcStatArr(arr,arrAvg,arrNext,Period)
|
|
{
|
|
var arrSum = [arr[0]];
|
|
for(var i = 1; i < arr.length; i++)
|
|
{
|
|
arrSum[i] = arrSum[i - 1] + arr[i];
|
|
}
|
|
for(var i = 0; i < arrSum.length; i++)
|
|
{
|
|
if(i < Period)
|
|
arrAvg[i] = Math.floor(arrSum[i] / (i + 1));
|
|
else
|
|
{
|
|
arrAvg[i] = Math.floor((arrSum[i] - arrSum[i - Period]) / Period);
|
|
}
|
|
}
|
|
arrNext[0] = 0;
|
|
for(var i = 1; i < arrAvg.length; i++)
|
|
{
|
|
var Avg = arrSum[i] / (i + 1);
|
|
var minValue = Avg / 20;
|
|
var Value1 = arrAvg[i - 1];
|
|
var Value2 = arrAvg[i];
|
|
if(Value1 < minValue)
|
|
Value1 = minValue;
|
|
if(Value2 < minValue)
|
|
Value2 = minValue;
|
|
var KLast = Math.floor(100 * (Value2 - Value1) / Value1) / 100;
|
|
var AvgLast = arrAvg[i];
|
|
if(Avg > AvgLast)
|
|
AvgLast = Avg;
|
|
if(KLast > 2.0)
|
|
KLast = 2.0;
|
|
if(KLast < - 0.0)
|
|
KLast = - 0.0;
|
|
arrNext[i] = AvgLast * (1 + KLast);
|
|
var AvgMax = 0;
|
|
if(0)
|
|
if(i > 1 * Period)
|
|
{
|
|
for(var j = i - Period / 2; j <= i; j++)
|
|
if(arrAvg[j] > AvgMax)
|
|
AvgMax = arrAvg[j];
|
|
}
|
|
}
|
|
return arrNext[arrNext.length - 1];
|
|
};
|