private void OnSessionStart(ITcpSession session)
{
try
{
OnConnected();
}
catch (Exception e)
{
Logger.error($"OnConnect() exception! e={e.Message}");
session.Stop();
}
}
/// <summary>
/// Encrypt PrivateKey to KeyStoreV3 json string with password using Scrypt
/// </summary>
/// <exception cref="KdfException"></exception>
public static string EncryptKeyStoreV3AsJson(PrivateKey key, string password, ScryptParams kdfParams)
{
try
{
return(PbkdfService.EncryptKey(key, password, kdfParams).ToJson());
}
catch (KdfException e)
{
blog.error($"WrongHmacException! e={e.ErrorMessage}");
throw;
}
}
// Send packet to host
// connect -> send -> close
public static bool SendTo(string host, int port, byte[] data, ILoggable Logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
Logger.warning($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(false);
}
System.Net.Sockets.TcpClient tcp_client = null;
try
{
tcp_client = new System.Net.Sockets.TcpClient(host, port);
}
catch (Exception e)
{
Logger.error($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(false);
}
// 전송할 데이터
List <byte> bytes = new List <byte>();
bytes.AddRange(BitConverter.GetBytes(data.Length));
bytes.AddRange(data);
byte[] bytesToSend = bytes.ToArray();
bool ret = false;
try
{
// write data to socket
NetworkStream ns = tcp_client.GetStream();
ns.Write(bytesToSend, 0, bytesToSend.Length);
ret = true;
}
catch (Exception e)
{
Logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
}
finally
{
// 소켓 종료
tcp_client.Close();
}
return(ret);
}
public bool Start(string host, int port, int acceptThreadCount, int backlogs = 32)
{
Host = host;
Port = port;
try
{
// socket
AcceptSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
AcceptSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
AcceptSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, true);
// bind socket
AcceptSocket.Bind(TcpHelper.ToIPEndPoint(host, port));
// listen
AcceptSocket.Listen(acceptThreadCount * backlogs);
// start accept async
BeginAccept(acceptThreadCount);
// start event callback
OnStart?.Invoke(host, port);
_running = true;
return(true);
}
catch (Exception e)
{
Logger.error($"exception! e={e.Message}");
return(false);
}
}
// Send packet to host
// connect -> send -> close
public static bool SendTo(byte[] data, string host, int port, ILoggable logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
logger.error($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(false);
}
// connect to host
TcpClient client = null;
try
{
client = new TcpClient(host, port);
}
catch (Exception e)
{
logger.warning($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(false);
}
// write to host
try
{
byte[] bytesToSend = BitConverter.GetBytes(data.Length).Merge(data);
client.GetStream().Write(bytesToSend, 0, bytesToSend.Length);
return(true);
}
catch (Exception e)
{
logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
}
finally
{
client.Close();
}
return(false);
}
public void OnTcpMessage(ITcpSession session, byte[] data)
{
Message message = Message.Parse(data);
switch (message.Value <string>(ACTION))
{
case ACTION_CLEAR: OnTcpMessageClear(session, message); return;
case ACTION_REGISTER: OnTcpMessageRegister(session, message); return;
case ACTION_UNREGISTER: OnTcpMessageUnregister(session, message); return;
case ACTION_PEEK: OnTcpMessagePeek(session, message); return;
case ACTION_UPDATE: OnTcpMessageUpdate(session, message); return;
case ACTION_SYNC: OnTcpMessageSync(session, message); return;
default: break;
}
Logger.error($"unknown action! '{message.Value<string>(ACTION)}'");
}
private void OnError(string error)
{
Logger.error($"OnError(): remote={RemoteIP}:{RemotePort}, error={error}");
Stop(-1);
}
private void OnElasticMessage(Message message)
{
// routes info
byte ttl = message.TimeToLive();
Elastic3D to = message.To();
ElasticLayout layout = message.Layout();
Elastic3D me = layout.DefineCoordinates(NodeKey.Address);
// message router
Address router = message.Router();
// router permitted?
if (!Peers.Exists(router))
{
Logger.warning("Unauthorized router!");
return;
}
// verify message
if (ShouldVerifyRouter && !message.VerifyRouter(router))
{
Logger.warning("Router signature not verified!");
return;
}
new BConsole.MessageBuilder()
.Append("(-) Received ShouldRoute message(")
.Append(ConsoleColor.DarkCyan, message.ID.Ellipsis())
.Append(") To:")
.Append(to.Mul() == 0 ? ConsoleColor.DarkYellow : ConsoleColor.DarkGreen, to)
//.WriteLine($", message={message}");
.WriteLine();
// broadcast to all cell
if (to.Mul() > 0 && ttl == 1)
{
ElasticAddress[] peers = Peers.ToArray <ElasticAddress>(to, layout);
new BConsole.MessageBuilder()
.Append("(!) Broadcasting message(")
.Append(ConsoleColor.DarkCyan, message.ID.Ellipsis())
.Append("), To=")
.Append(ConsoleColor.DarkGreen, to)
.Append(", nPeers=")
.Append(ConsoleColor.DarkGreen, peers.Length)
//.WriteLine($", message={message}");
.WriteLine();
// 해당 좌표의 모든 노드에 전송한다.
message.RouteTo(0, to, layout, NodeKey);
SendTo(message, peers);
return;
}
// z-axis must be > 0
if (to.Z < 1)
{
Logger.error($"to.z < 1");
return;
}
// y-axis
if (ttl == 3)
{
for (byte y = 1; y <= layout.Y; y++)
{
to.Y = y;
message.RouteTo(2, to, layout, NodeKey);
RouteTo(message, to);
}
}
// x-axis
else if (ttl == 2 && to.Y > 0)
{
for (byte x = 1; x <= layout.X; x++)
{
to.X = x;
message.RouteTo(1, to, layout, NodeKey);
RouteTo(message, to);
}
}
}
// Send packet to host and receive data
// connect -> send -> read -> close
public static byte[] SendToAndReceive(byte[] data, string host, int port, ILoggable logger)
{
Debug.Assert(!string.IsNullOrEmpty(host) && data.Length > 0);
// 패킷 최대 크기
Debug.Assert(data.Length < TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE);
if (data.Length > TcpSession.MAX_PACKET_SIZE - TcpSession.HEADER_SIZE)
{
logger.error($"exceeds MAX_PACKET_SIZE({TcpSession.MAX_PACKET_SIZE})");
return(null);
}
// connect to host
TcpClient client = null;
try
{
client = new TcpClient(host, port);
}
catch (Exception e)
{
logger.warning($"can't connect to Peer! remote={host}:{port}, e={e.Message}");
return(null);
}
// write to host
try
{
byte[] bytesToSend = BitConverter.GetBytes(data.Length).Merge(data);
client.GetStream().Write(bytesToSend, 0, bytesToSend.Length);
}
catch (Exception e)
{
logger.error($"can't write to peer! remote={host}:{port}, data.Length={data.Length}, e={e.Message}");
client.Close();
return(null);
}
// read ack
try
{
List <byte> bytesAck = new List <byte>();
byte[] bytesToRead = new byte[TcpSession.HEADER_SIZE];
byte[] buffer = new byte[8 * 1024];
NetworkStream ns = client.GetStream();
// read header
int reads = ns.Read(bytesToRead, 0, TcpSession.HEADER_SIZE);
Debug.Assert(reads == TcpSession.HEADER_SIZE);
int header = BitConverter.ToInt32(bytesToRead, 0);
Debug.Assert(header > 0 && header < TcpSession.MAX_PACKET_SIZE);
// read data
while (bytesAck.Count < header)
{
reads = ns.Read(buffer, 0, buffer.Length);
if (reads <= 0)
{
break;
}
bytesAck.AddRange(reads == buffer.Length?buffer:buffer.Take(reads).ToArray());
}
return(bytesAck.ToArray());
}
catch (Exception e)
{
logger.error($"can't read from peer! remote={host}:{port}, e={e.Message}");
}
finally
{
client.Close();
}
return(null);
}
