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); }