protected TcpServer(int port)
{
server = new TcpListener(IPAddress.Parse(IpAddr.Mine()), port);
server.Start();
new Thread(new ThreadStart(AwaitConnections)).Start();
}
public Core(string[] args)
{
Log.NewLine("sharpcoin (core) v0.1.1 -- by aal89");
// Configure the ip address to bind on
if (args.Length == 1 && IPAddress.Parse(args[0]) != null)
{
IpAddr.Set(args[0]);
}
Log.NewLine($"Attempting to bind tcp servers to address: {IpAddr.Mine()}.");
// Load blockchain
Log.NewLine($"Initializing blockchain.");
Blockchain = new Blockchain(new Logger("Blockchain"));
// Setup event listeners
Log.Line("Setting up event listeners...");
Blockchain.BlockAdded += Blockchain_BlockAdded;
Blockchain.QueuedTransactionAdded += Blockchain_QueuedTransactionAdded;
Log.Append("Done.");
// Setup api
Log.Line($"Setting up client management...");
_ = new ClientManager(this, new Logger("ClientManager"));
Log.Append("Done.");
// Setup mine operator
Log.Line($"Setting up mine operator...");
Operator = new Operator(Blockchain, new Logger("Miner"));
Log.Append("Done.");
// Setup peer manager (server&client)
Log.NewLine($"Setting up peer manager.");
PeerManager = new PeerManager(this, new Logger("PeerManager"));
}
public static IpAddr make(string str, IPAddress dotnet)
{
IpAddr fan = IpAddr.internalMake();
fan.m_peer.m_str = str;
fan.m_peer.m_dotnet = dotnet;
return(fan);
}
public void send(UdpSocket fan, UdpPacket packet)
{
// map buf bytes to packet
MemBuf data = (MemBuf)packet.data();
byte[] buf = data.m_buf;
int off = data.m_pos;
int len = data.m_size - off;
// map address, port
IpAddr addr = packet.addr();
Long port = packet.port();
if (isConnected(fan))
{
if (addr != null || port != null)
{
throw ArgErr.make("Address and port must be null to send while connected").val;
}
try
{
m_dotnet.Send(buf, off, len, SocketFlags.None);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
else
{
if (addr == null || port == null)
{
throw ArgErr.make("Address or port is null").val;
}
try
{
if (m_dotnet == null)
{
m_dotnet = createSocket();
}
IPEndPoint endPoint = new IPEndPoint(addr.m_peer.m_dotnet, port.intValue());
m_dotnet.SendTo(buf, off, len, SocketFlags.None, endPoint);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
// lastly drain buf
data.m_pos += len;
}
//////////////////////////////////////////////////////////////////////////
// Methods
//////////////////////////////////////////////////////////////////////////
public TcpListener bind(TcpListener fan, IpAddr addr, Long port, long backlog)
{
IPAddress dotnetAddr = (addr == null) ? IPAddress.Any : addr.m_peer.m_dotnet;
int dotnetPort = (port == null) ? 0 : port.intValue();
m_dotnet = new System.Net.Sockets.TcpListener(dotnetAddr, dotnetPort);
m_dotnet.Server.ReceiveBufferSize = (int)m_receiveBufferSize;
m_dotnet.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, m_reuseAddr);
m_dotnet.Start((int)backlog);
m_bound = true;
return fan;
}
public bool Equals(IpAddr fan, object obj)
{
if (obj is IpAddr)
{
return(this.m_dotnet.Equals(((IpAddr)obj).m_peer.m_dotnet));
}
else
{
return(false);
}
}
//////////////////////////////////////////////////////////////////////////
// Methods
//////////////////////////////////////////////////////////////////////////
public TcpListener bind(TcpListener fan, IpAddr addr, Long port, long backlog)
{
IPAddress dotnetAddr = (addr == null) ? IPAddress.Any : addr.m_peer.m_dotnet;
int dotnetPort = (port == null) ? 0 : port.intValue();
m_dotnet = new System.Net.Sockets.TcpListener(dotnetAddr, dotnetPort);
m_dotnet.Server.ReceiveBufferSize = (int)m_receiveBufferSize;
m_dotnet.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, m_reuseAddr);
m_dotnet.Start((int)backlog);
m_bound = true;
return(fan);
}
protected void RequestPeersResponse(byte[] data)
{
string[] peers = Encoding.UTF8.GetString(data)
.Split(",")
.Filter(ip => !String.IsNullOrEmpty(ip))
.Filter(ip => !IpAddr.EqualsMine(ip))
.ToArray();
Log.NewLine($"Peer responded with {peers.Length} peers.");
foreach (string peer in peers)
{
PeerManager.AddPeer(peer);
}
}
public bool Compare(Device dev)
{
var ip1 = IpAddr.GetAddressBytes();
var ip2 = dev.IpAddr.GetAddressBytes();
for (int i = 0; i < 4; i++)
{
if (ip1[i] != ip2[i])
{
return(false);
}
}
return(true);
}
//////////////////////////////////////////////////////////////////////////
// Communication
//////////////////////////////////////////////////////////////////////////
public TcpSocket bind(TcpSocket fan, IpAddr addr, Long port)
{
try
{
IPAddress dotnetAddr = (addr == null) ? IPAddress.Any : addr.m_peer.m_dotnet;
int dotnetPort = (port == null) ? 0 : port.intValue();
m_dotnet.Bind(new IPEndPoint(dotnetAddr, dotnetPort));
return(fan);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
//////////////////////////////////////////////////////////////////////////
// Communication
//////////////////////////////////////////////////////////////////////////
public TcpSocket bind(TcpSocket fan, IpAddr addr, Long port)
{
try
{
IPAddress dotnetAddr = (addr == null) ? IPAddress.Any : addr.m_peer.m_dotnet;
int dotnetPort = (port == null) ? 0 : port.intValue();
m_dotnet.Bind(new IPEndPoint(dotnetAddr, dotnetPort));
return fan;
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
protected void ServeAcceptPeers(byte[] data)
{
string[] peers = Encoding.UTF8.GetString(data)
.Split(",")
.Filter(ip => !String.IsNullOrEmpty(ip))
.Filter(ip => !IpAddr.EqualsMine(ip))
.ToArray();
Log.NewLine($"Accepting {peers.Length} peers.");
foreach (string peer in peers)
{
PeerManager.AddPeer(peer);
}
}
public static bool AddPeer(TcpClient tcpc)
{
lock (addpeers_operation)
{
try
{
return(tcpc.Ip() != "" && !IpAddr.EqualsMine(tcpc.Ip()) && !HasPeer(tcpc.Ip()) && !HasMaximumConnections() && AddPeer(Peer.Create(Core, tcpc)));
}
catch
{
Log.NewLine($"Failed to connect to {tcpc.Ip()}.");
return(false);
}
}
}
public static bool AddPeer(string ip)
{
lock (addpeers_operation)
{
try
{
return(ip != "" && !IpAddr.EqualsMine(ip) && !HasPeer(ip) && !HasMaximumConnections() && AddPeer(Peer.Create(Core, ip)));
}
catch
{
Log.NewLine($"Failed to connect to {ip}.");
return(false);
}
}
}
private IpAddr parseServer(string url)
{
IpAddr addr = new IpAddr();
string data = url.Trim();
string[] arr = data.Split(':');
if (arr.Length == 2)
{
addr.ip = arr[0];
addr.port = arr[1];
return(addr);
}
addr.ip = data;
addr.port = "80";
return(addr);
}
public UdpSocket connect(UdpSocket fan, IpAddr addr, long port)
{
try
{
if (m_dotnet == null)
{
m_dotnet = createSocket();
}
m_dotnet.Connect(addr.m_peer.m_dotnet, (int)port);
IPEndPoint endPoint = m_dotnet.RemoteEndPoint as IPEndPoint;
m_remoteAddr = IpAddrPeer.make(endPoint.Address);
m_remotePort = endPoint.Port;
return(fan);
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
public TcpSocket connect(TcpSocket fan, IpAddr addr, long port, Duration timeout)
{
if (timeout != null)
{
IAsyncResult result = m_dotnet.BeginConnect(addr.m_peer.m_dotnet, (int)port, null, null);
bool success = result.AsyncWaitHandle.WaitOne((int)timeout.millis(), true);
if (!success)
{
m_dotnet.Close();
throw new System.IO.IOException("Connection timed out.");
}
}
else
{
m_dotnet.Connect(addr.m_peer.m_dotnet, (int)port);
}
connected(fan);
return(fan);
}
private void CreateUPnPMapping()
{
try
{
var discoverer = new NatDiscoverer();
var cts = new CancellationTokenSource(3000);
NatDevice device = Task.Run(async() => await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts)).Result;
// set nat device to ipaddr so that we can our external ip elsewhere in the application
IpAddr.Set(device);
// int.MaxValue so that a Session object is created internally in the lib, only session objects
// are properly renewed, lib has bug (10min intervals)...
_ = Task.Run(async() => await device.CreatePortMapAsync(new Mapping(Protocol.Tcp, 18910, 18910, int.MaxValue, "sc.Nat")));
Log.NewLine("Successfully created UPnP port mapping.");
}
catch
{
Log.NewLine("Could not create UPnP port mapping. Decreased network connectivity.");
}
}
public static IpAddr local()
{
if (m_local == null)
{
try
{
string hostName = Dns.GetHostName();
// TODO - not sure the correct behavoir here, but we seem
// to get IPv6 addresses first, so for now at least, lets
// attempt to use the IPv4 address
IPAddress dotnet = null;
IPAddress[] addr = Dns.GetHostAddresses(hostName);
for (int i=0; i<addr.Length; i++)
if (addr[i].AddressFamily == AddressFamily.InterNetwork)
dotnet = addr[i];
m_local = make(hostName, dotnet);
}
catch (Exception)
{
try
{
// fallback to explicit loopback
IPAddress dotnet = new IPAddress(new byte[] {127, 0, 0, 1});
m_local = make(dotnet.ToString(), dotnet);
}
catch (Exception ignore)
{
// should never happen
Err.dumpStack(ignore);
}
}
}
return m_local;
}
public TcpSocket connect(TcpSocket fan, IpAddr addr, long port, Duration timeout)
{
if (timeout != null)
{
IAsyncResult result = m_dotnet.BeginConnect(addr.m_peer.m_dotnet, (int)port, null, null);
bool success = result.AsyncWaitHandle.WaitOne((int)timeout.millis(), true);
if (!success)
{
m_dotnet.Close();
throw new System.IO.IOException("Connection timed out.");
}
}
else
{
m_dotnet.Connect(addr.m_peer.m_dotnet, (int)port);
}
connected(fan);
return fan;
}
public string toStr(IpAddr fan)
{
return m_str;
}
//////////////////////////////////////////////////////////////////////////
// Peer Factory
//////////////////////////////////////////////////////////////////////////
public static IpAddrPeer make(IpAddr fan)
{
return(new IpAddrPeer());
}
public string hostname(IpAddr fan)
{
return(Dns.GetHostEntry(m_dotnet).HostName);
}
public Buf bytes(IpAddr fan)
{
return(new MemBuf(m_dotnet.GetAddressBytes()));
}
public string toStr(IpAddr fan)
{
return(m_str);
}
//////////////////////////////////////////////////////////////////////////
// Identity
//////////////////////////////////////////////////////////////////////////
public long hash(IpAddr fan)
{
return(m_dotnet.GetHashCode());
}
private void ExCmdLogin()
{
if (string.IsNullOrEmpty(UserName))
{
Msg = "用户名为空...";
return;
}
if (string.IsNullOrEmpty(UserPsw))
{
Msg = "密码为空...";
return;
}
if (string.IsNullOrEmpty(IpAddr))
{
Msg = "Ip地址为空...";
return;
}
if (ServerMain)
{
ServerStyle = 1;
if (!Wlst.Sr.PPPandSocketSvr.Server.SocketClient.Connect(IpAddr, IpPort, 3))
{
Msg = "连接服务器失败...<未联网或服务器未开启>";
return;
}
else
{
Msg = "连接服务器成功，正在验证用户名密码...";
}
_bolCanLogin = false;
}
else if (ServerBak)
{
ServerStyle = 2;
if (!Wlst.Sr.PPPandSocketSvr.Server.SocketClient.Connect(IpAddrBak, IpPortBak, 3))
{
Msg = "连接服务器失败...<未联网或服务器未开启>";
return;
}
else
{
Msg = "连接服务器成功，正在验证用户名密码...";
}
_bolCanLogin = false;
}
else
{
ServerStyle = 0;
Msg = "请选择一个服务器连接方式...";
return;
}
// Wlst.Cr.Core.CoreServices.RegionManage.SetLoadInner();
//更新本地数据库的用户名密码地址
if (IpAddr == null)
{
IpAddr = "0.0.0.0";
}
if (IpAddrBak == null)
{
IpAddrBak = "0.0.0.0";
}
UpdateKeyVauleDb("ipAddr", IpAddr.Trim());
UpdateKeyVauleDb("ipPort", IpPort.ToString(CultureInfo.InvariantCulture));
UpdateKeyVauleDb("userName", UserName);
UpdateKeyVauleDb("ipAddrBak", IpAddrBak.Trim());
UpdateKeyVauleDb("ipPortBak", IpPortBak.ToString(CultureInfo.InvariantCulture));
UpdateKeyVauleDb("serverStyle", ServerStyle.ToString(CultureInfo.InvariantCulture));
//在程序加载未显示设备列表时 屏蔽来自服务器端的各种显示信息 信息和选测信息
var lst = new List <string>();
lst.Add("wlst.msg .server_msg");
lst.Add("wlst.rtu.2000");
Wlst.Sr.PPPandSocketSvr.Server.ProtocolServices.ShieldCmd(true, lst);
Thread.Sleep(900);
//请求登录
var xxxinfo = Wlst.Sr.ProtocolPhone.LxLogin.wst_cnt_login; //.ServerPart.wlst_login_clinet_request_login;
xxxinfo.WstLoginCntLogin.UserName = UserName;
xxxinfo.WstLoginCntLogin.UserPassword = UserPsw;
string sttachinfo = "";
if (File.Exists("C:\\Windows\\AdminLogin.txt")) //序列号LvfGay
{
StreamReader rd = File.OpenText("C:\\Windows\\AdminLogin.txt");
sttachinfo = rd.ReadToEnd();
xxxinfo.WstLoginCntLogin.AttachInfo = sttachinfo;
}
SndOrderServer.OrderSnd(xxxinfo, 3, 1);
//线程检测登录
try
{
if (thread.IsAlive)
{
thread.Abort();
}
}
catch (Exception exx)
{
}
thread = new Thread(ThreadRunForOutTime);
thread.Start();
}
public string hostname(IpAddr fan)
{
return Dns.GetHostEntry(m_dotnet).HostName;
}
public bool isIPv6(IpAddr fan)
{
return m_dotnet.AddressFamily == AddressFamily.InterNetworkV6;
}
public string numeric(IpAddr fan)
{
return m_dotnet.ToString();
}
//////////////////////////////////////////////////////////////////////////
// Peer Factory
//////////////////////////////////////////////////////////////////////////
public static IpAddrPeer make(IpAddr fan)
{
return new IpAddrPeer();
}
private void ExCmdLogin()
{
MsgDetail = "";
if (string.IsNullOrEmpty(UserName))
{
Msg = "用户名为空...";
return;
}
if (string.IsNullOrEmpty(UserPsw))
{
Msg = "密码为空...";
return;
}
if (string.IsNullOrEmpty(IpAddr))
{
Msg = "Ip地址为空...";
return;
}
_islogin = true;
if (ServerMain)
{
ServerStyle = 1;
Wlst.Sr.EquipmentInfoHolding.Services.Others.SeverIpAddr = IpAddr + "";
Wlst.Sr.EquipmentInfoHolding.Services.Others.SeverPort = IpPort + "";
if (!Wlst.Sr.PPPandSocketSvr.Server.SocketClient.Connect(IpAddr, IpPort, 3))
{
Msg = "连接服务器失败...<未联网或服务器未开启>";
return;
}
else
{
Msg = "连接服务器成功，正在验证用户名密码...";
}
_bolCanLogin = false;
HttpUrl = IpAddr;
}
else if (ServerBak)
{
ServerStyle = 2;
Wlst.Sr.EquipmentInfoHolding.Services.Others.SeverIpAddr = IpAddrBak + "";
Wlst.Sr.EquipmentInfoHolding.Services.Others.SeverPort = IpPortBak + "";
if (!Wlst.Sr.PPPandSocketSvr.Server.SocketClient.Connect(IpAddrBak, IpPortBak, 3))
{
Msg = "连接服务器失败...<未联网或服务器未开启>";
return;
}
else
{
Msg = "连接服务器成功，正在验证用户名密码...";
}
_bolCanLogin = false;
HttpUrl = IpAddrBak;
}
else
{
ServerStyle = 0;
Msg = "请选择一个服务器连接方式...";
return;
}
// Wlst.Cr.Core.CoreServices.RegionManage.SetLoadInner();
//更新本地数据库的用户名密码地址
if (IpAddr == null)
{
IpAddr = "0.0.0.0";
}
if (IpAddrBak == null)
{
IpAddrBak = "0.0.0.0";
}
UpdateKeyVauleDb("ipAddr", IpAddr.Trim());
UpdateKeyVauleDb("ipPort", IpPort.ToString(CultureInfo.InvariantCulture));
UpdateKeyVauleDb("userName", UserName);
UpdateKeyVauleDb("ipAddrBak", IpAddrBak.Trim());
UpdateKeyVauleDb("ipPortBak", IpPortBak.ToString(CultureInfo.InvariantCulture));
UpdateKeyVauleDb("serverStyle", ServerStyle.ToString(CultureInfo.InvariantCulture));
//在程序加载未显示设备列表时 屏蔽来自服务器端的各种显示信息 信息和选测信息
var lst = new List <string>();
lst.Add("wlst.msg .server_msg");
lst.Add("wlst.rtu.2000");
Wlst.Sr.PPPandSocketSvr.Server.ProtocolServices.ShieldCmd(true, lst);
Thread.Sleep(900);
//请求登录
var xxxinfo = Wlst.Sr.ProtocolPhone.LxLogin.wst_cnt_login; //.ServerPart.wlst_login_clinet_request_login;
xxxinfo.WstLoginCntLogin.UserName = UserName;
xxxinfo.WstLoginCntLogin.UserPassword = UserPsw;
//lvf 如果需要自动登录 记录当前用户密码
string dir = Directory.GetCurrentDirectory() + "\\config";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
string path = dir + "\\login.xml";
if (File.Exists(path))
{
try
{
var dicOp = new Dictionary <string, string>();
dicOp.Add("UserName", UserName);
dicOp.Add("Password", UserPsw);
Wlst.Cr.CoreOne.Services.SystemXmlConfig.Save(dicOp, "login", "\\config");
}
catch (Exception)
{
}
}
string sttachinfo = "";
if (File.Exists("C:\\Windows\\AdminLogin.txt")) //序列号Lvf
{
StreamReader rd = File.OpenText("C:\\Windows\\AdminLogin.txt");
sttachinfo = rd.ReadToEnd();
xxxinfo.WstLoginCntLogin.AttachInfo = sttachinfo;
}
SndOrderServer.OrderSnd(xxxinfo, 3, 1);
//线程检测登录
try
{
if (thread.IsAlive)
{
thread.Abort();
}
}
catch (Exception exx)
{
}
thread = new Thread(ThreadRunForOutTime);
thread.Start();
}
public UdpSocket connect(UdpSocket fan, IpAddr addr, long port)
{
try
{
if (m_dotnet == null) m_dotnet = createSocket();
m_dotnet.Connect(addr.m_peer.m_dotnet, (int)port);
IPEndPoint endPoint = m_dotnet.RemoteEndPoint as IPEndPoint;
m_remoteAddr = IpAddrPeer.make(endPoint.Address);
m_remotePort = endPoint.Port;
return fan;
}
catch (SocketException e)
{
throw IOErr.make(e).val;
}
}
//////////////////////////////////////////////////////////////////////////
// Identity
//////////////////////////////////////////////////////////////////////////
public long hash(IpAddr fan)
{
return m_dotnet.GetHashCode();
}
public UdpSocket disconnect(UdpSocket fan)
{
//m_dotnet.Shutdown(SocketShutdown.Both);
//m_dotnet.Disconnect(true);
m_dotnet.Close();
m_dotnet = null;
m_remoteAddr = null;
m_remotePort = -1;
return fan;
}
public override string ToString()
{
return(string.Format($"{IpAddr.ToString()} -> {HardwareAddrString} -> {(Name == null || Name == "" ? "None" : Name)}"));
}
public bool isIPv6(IpAddr fan)
{
return(m_dotnet.AddressFamily == AddressFamily.InterNetworkV6);
}
public bool Equals(IpAddr fan, object obj)
{
if (obj is IpAddr)
return this.m_dotnet.Equals(((IpAddr)obj).m_peer.m_dotnet);
else
return false;
}
public string numeric(IpAddr fan)
{
return(m_dotnet.ToString());
}
public Buf bytes(IpAddr fan)
{
return new MemBuf(m_dotnet.GetAddressBytes());
}
public Object toNative(IpAddr fan)
{
return(m_dotnet);
}
internal void connected(TcpSocket fan)
{
IPEndPoint endPoint = m_dotnet.RemoteEndPoint as IPEndPoint;
m_remoteAddr = IpAddrPeer.make(endPoint.Address);
m_remotePort = endPoint.Port;
m_in = SysInStream.make(new NetworkStream(m_dotnet), getInBufferSize(fan));
m_out = SysOutStream.make(new NetworkStream(m_dotnet), getOutBufferSize(fan));
}
public static bool HasPeer(string ip)
{
return(peers.Any(peer => IpAddr.Equals(peer.Ip, ip)));
}
public Object toNative(IpAddr fan)
{
return m_dotnet;
}
