weiai/linker
1
0
Fork 0
mirror of https://github.com/snltty/linker.git synced 2025-12-18 09:26:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

重构穿透

Browse Source
This commit is contained in:
snltty
2025-12-07 18:32:01 +08:00
parent a663974ccc
commit 558b6d0395
43 changed files with 1540 additions and 1486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shells/version.txt
View File

@@ -1,5 +1,5 @@
v1.9.6
2025-12-06 18:24:39
2025-12-07 18:32:01
1. 一些累计更新，一些BUG修复
2. 优化客户端数据同步，减少服务器流量
3. 去除cdkey，改为发电解锁中继速度

3
src/linker.messenger.relay/Entry.cs
View File

@@ -59,8 +59,9 @@ namespace linker.messenger.relay
serviceCollection.AddSingleton<RelayServerMasterTransfer>();
serviceCollection.AddSingleton<RelayServerReportResolver>();
serviceCollection.AddSingleton<RelayServerConnectionResolver>();
serviceCollection.AddSingleton<RelayServerResolver>();
serviceCollection.AddSingleton<RelayServerConnectionResolver>();
serviceCollection.AddSingleton<RelayServerConnectionTransfer>();
serviceCollection.AddSingleton<IRelayServerCaching, RelayServerCachingMemory>();

61
src/linker.messenger.relay/messenger/RelayMessenger.cs
View File

@@ -13,40 +13,10 @@ namespace linker.messenger.relay.messenger
/// </summary>
public class RelayClientMessenger : IMessenger
{
private readonly ISerializer serializer;
private readonly RelayServerNodeReportTransfer relayServerNodeReportTransfer;
public RelayClientMessenger(SignInServerCaching signCaching, ISerializer serializer, RelayServerNodeReportTransfer relayServerNodeReportTransfer)
public RelayClientMessenger()
{
this.serializer = serializer;
this.relayServerNodeReportTransfer = relayServerNodeReportTransfer;
}
[MessengerId((ushort)RelayMessengerIds.Share)]
public async Task Share(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
connection.Write(serializer.Serialize(await relayServerNodeReportTransfer.GetShareKey(masterKey)));
}
[MessengerId((ushort)RelayMessengerIds.Update)]
public async Task Update(IConnection connection)
{
RelayServerNodeStoreInfo info = serializer.Deserialize<RelayServerNodeStoreInfo>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Update(info).ConfigureAwait(false);
}
[MessengerId((ushort)RelayMessengerIds.Upgrade)]
public async Task Upgrade(IConnection connection)
{
KeyValuePair<string, string> info = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Upgrade(info.Key, info.Value).ConfigureAwait(false);
}
[MessengerId((ushort)RelayMessengerIds.Exit)]
public async Task Exit(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Exit(masterKey).ConfigureAwait(false);
}
}
/// <summary>
@@ -165,6 +135,13 @@ namespace linker.messenger.relay.messenger
}
connection.Write(serializer.Serialize(await relayServerNodeReportTransfer.GetShareKeyForward(id)));
}
[MessengerId((ushort)RelayMessengerIds.Share)]
public async Task Share(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
connection.Write(serializer.Serialize(await relayServerNodeReportTransfer.GetShareKey(masterKey)));
}
[MessengerId((ushort)RelayMessengerIds.Import)]
public async Task Import(IConnection connection)
{
@@ -205,6 +182,12 @@ namespace linker.messenger.relay.messenger
bool result = await relayServerNodeReportTransfer.UpdateForward(info).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
[MessengerId((ushort)RelayMessengerIds.Update)]
public async Task Update(IConnection connection)
{
RelayServerNodeStoreInfo info = serializer.Deserialize<RelayServerNodeStoreInfo>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Update(info).ConfigureAwait(false);
}
[MessengerId((ushort)RelayMessengerIds.UpgradeForward)]
public async Task UpgradeForward(IConnection connection)
@@ -219,6 +202,12 @@ namespace linker.messenger.relay.messenger
bool result = await relayServerNodeReportTransfer.UpgradeForward(info.Key, info.Value).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
[MessengerId((ushort)RelayMessengerIds.Upgrade)]
public async Task Upgrade(IConnection connection)
{
KeyValuePair<string, string> info = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Upgrade(info.Key, info.Value).ConfigureAwait(false);
}
[MessengerId((ushort)RelayMessengerIds.ExitForward)]
public async Task ExitForward(IConnection connection)
@@ -233,6 +222,12 @@ namespace linker.messenger.relay.messenger
bool result = await relayServerNodeReportTransfer.ExitForward(nodeid).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
[MessengerId((ushort)RelayMessengerIds.Exit)]
public async Task Exit(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
await relayServerNodeReportTransfer.Exit(masterKey).ConfigureAwait(false);
}
[MessengerId((ushort)RelayMessengerIds.NodeReport)]
@@ -243,7 +238,7 @@ namespace linker.messenger.relay.messenger
relayServerReportResolver.Add(connection.ReceiveRequestWrap.Payload.Length, 0);
RelayServerNodeReportInfoOld info = serializer.Deserialize<RelayServerNodeReportInfoOld>(connection.ReceiveRequestWrap.Payload.Span);
if (info.EndPoint.Address.Equals(IPAddress.Any))
if (info.EndPoint.Address.Equals(IPAddress.Any) || info.EndPoint.Address.Equals(IPAddress.Loopback))
{
info.EndPoint.Address = connection.Address.Address;
}

13
src/linker.messenger.relay/server/IRelayServerConfigStore.cs
View File

@@ -1,5 +1,4 @@
using linker.libs;
using linker.libs.extends;
using linker.libs.extends;
using linker.tunnel.connection;
using System.Net;
using System.Text.Json.Serialization;
@@ -49,6 +48,8 @@ namespace linker.messenger.relay.server
private string name = "default";
public string Name { get => name; set { name = value.SubStr(0, 32); } }
public string Host { get; set; } = string.Empty;
public TunnelProtocolType Protocol { get; set; } = TunnelProtocolType.Tcp;
public int Connections { get; set; }
public int Bandwidth { get; set; }
@@ -67,7 +68,7 @@ namespace linker.messenger.relay.server
public string ShareKey { get; set; } = string.Empty;
public string MasterKey { get; set; } = string.Empty;
public int DataMonth { get; set; }
public string Domain { get; set; } = string.Empty;
}
@@ -79,16 +80,12 @@ namespace linker.messenger.relay.server
public double BandwidthRatio { get; set; }
public IPEndPoint[] Masters { get; set; } = Array.Empty<IPEndPoint>();
public string Domain { get; set; } = string.Empty;
}
public sealed class RelayServerNodeStoreInfo : RelayServerNodeReportInfo
{
public int Id { get; set; }
public string Host { get; set; } = string.Empty;
public int BandwidthEach { get; set; } = 50;
public bool Public { get; set; }
@@ -104,8 +101,8 @@ namespace linker.messenger.relay.server
public class RelayServerNodeShareInfo
{
public string NodeId { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public string SystemId { get; set; } = string.Empty;
}

6
src/linker.messenger.relay/server/RelayServerNodeReportTransfer.cs
View File

@@ -181,7 +181,7 @@ namespace linker.messenger.relay.server
Config.Logo = info.Logo;
Config.Name = info.Name;
Config.Url = info.Url;
Config.Domain = info.Domain;
Config.Host = info.Host;
relayServerConfigStore.Confirm();
@@ -294,7 +294,7 @@ namespace linker.messenger.relay.server
{
try
{
string host = Config.Domain;
string host = Config.Host;
if (string.IsNullOrWhiteSpace(host))
{
using HttpClient httpClient = new HttpClient();
@@ -314,7 +314,7 @@ namespace linker.messenger.relay.server
host = $"{IPAddress.Loopback}:{relayServerConfigStore.ServicePort}";
var node = await relayServerNodeStore.GetByNodeId(relayServerConfigStore.Config.NodeId);
if(node == null || node.ShareKey != shareKey || node.Name != Config.Name || node.Host != host)
if (node == null || node.ShareKey != shareKey || node.Name != Config.Name || node.Host != host)
{
await relayServerNodeStore.Delete(relayServerConfigStore.Config.NodeId);
await relayServerNodeStore.Add(new RelayServerNodeStoreInfo

15
src/linker.messenger.relay/server/RelayServerNodeTransfer.cs
View File

@@ -19,13 +19,14 @@ namespace linker.messenger.relay.server
private readonly ConcurrentDictionary<ulong, RelayTrafficCacheInfo> trafficDict = new();
private readonly ISerializer serializer;
private readonly IRelayServerConfigStore relayServerConfigStore;
private readonly IMessengerSender messengerSender;
private readonly IRelayServerConfigStore relayServerConfigStore;
private readonly RelayServerConnectionTransfer relayServerConnectionTransfer;
private readonly RelayServerNodeReportTransfer relayServerNodeReportTransfer;
public RelayServerNodeTransfer(ISerializer serializer, IRelayServerConfigStore relayServerConfigStore, IMessengerSender messengerSender,
RelayServerConnectionTransfer relayServerConnectionTransfer, RelayServerNodeReportTransfer relayServerNodeReportTransfer)
public RelayServerNodeTransfer(ISerializer serializer, IMessengerSender messengerSender,
IRelayServerConfigStore relayServerConfigStore, RelayServerConnectionTransfer relayServerConnectionTransfer, RelayServerNodeReportTransfer relayServerNodeReportTransfer)
{
this.serializer = serializer;
this.relayServerConfigStore = relayServerConfigStore;
@@ -188,15 +189,15 @@ namespace linker.messenger.relay.server
/// 设置限速
/// </summary>
/// <param name="relayCache"></param>
private void SetLimit(RelayTrafficCacheInfo relayCache)
private void SetLimit(RelayTrafficCacheInfo cache)
{
if (relayCache.Cache.Bandwidth >= 0)
if (cache.Cache.Bandwidth >= 0)
{
relayCache.Limit.SetLimit((uint)Math.Ceiling(relayCache.Cache.Bandwidth * 1024 * 1024 / 8.0));
cache.Limit.SetLimit((uint)Math.Ceiling(cache.Cache.Bandwidth * 1024 * 1024 / 8.0));
return;
}
relayCache.Limit.SetLimit((uint)Math.Ceiling(Config.Bandwidth * 1024 * 1024 / 8.0));
cache.Limit.SetLimit((uint)Math.Ceiling(Config.Bandwidth * 1024 * 1024 / 8.0));
}
private void ResetNodeBytes()

5
src/linker.messenger.serializer.memorypack/Entry.cs
View File

@@ -88,10 +88,7 @@ namespace linker.messenger.serializer.memorypack
MemoryPackFormatterProvider.Register(new SForwardAddForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardRemoveForwardInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardProxyInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardCountInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardServerNodeUpdateInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardServerNodeUpdateWrapInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardServerNodeReportInfoFormatter());
MemoryPackFormatterProvider.Register(new SForwardServerNodeReportInfoOldFormatter());
MemoryPackFormatterProvider.Register(new ForwardInfoFormatter());

40
src/linker.messenger.serializer.memorypack/RelaySerializer.cs
View File

@@ -228,6 +228,8 @@ namespace linker.messenger.serializer.memorypack
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
TunnelProtocolType Protocol => info.Protocol;
[MemoryPackInclude]
int Connections => info.Connections;
@@ -251,12 +253,11 @@ namespace linker.messenger.serializer.memorypack
double BandwidthRatio => info.BandwidthRatio;
[MemoryPackInclude]
IPEndPoint[] Masters => info.Masters;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackConstructor]
SerializableRelayServerNodeReportInfo(string nodeId, string name, TunnelProtocolType protocol, int connections, int bandwidth, int dataEachMonth,
long dataRemain, string url, string logo, string masterKey, string version, int connectionsRatio, double bandwidthRatio, IPEndPoint[] masters, string domain)
SerializableRelayServerNodeReportInfo(string nodeId, string name, string host, TunnelProtocolType protocol, int connections, int bandwidth, int dataEachMonth,
long dataRemain, string url, string logo, string masterKey, string version, int connectionsRatio, double bandwidthRatio, IPEndPoint[] masters)
{
var info = new RelayServerNodeReportInfo
{
@@ -274,7 +275,7 @@ namespace linker.messenger.serializer.memorypack
ConnectionsRatio = connectionsRatio,
BandwidthRatio = bandwidthRatio,
Masters = masters,
Domain = domain
Host = host
};
this.info = info;
}
@@ -310,6 +311,7 @@ namespace linker.messenger.serializer.memorypack
reader.TryReadObjectHeader(out byte count);
value.NodeId = reader.ReadValue<string>();
value.Name = reader.ReadValue<string>();
value.Host = reader.ReadValue<string>();
value.Protocol = reader.ReadValue<TunnelProtocolType>();
value.Connections = reader.ReadValue<int>();
value.Bandwidth = reader.ReadValue<int>();
@@ -322,7 +324,7 @@ namespace linker.messenger.serializer.memorypack
value.ConnectionsRatio = reader.ReadValue<int>();
value.BandwidthRatio = reader.ReadValue<double>();
value.Masters = reader.ReadValue<IPEndPoint[]>();
value.Domain = reader.ReadValue<string>();
}
}
@@ -338,6 +340,8 @@ namespace linker.messenger.serializer.memorypack
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
TunnelProtocolType Protocol => info.Protocol;
[MemoryPackInclude]
int Connections => info.Connections;
@@ -362,15 +366,11 @@ namespace linker.messenger.serializer.memorypack
double BandwidthRatio => info.BandwidthRatio;
[MemoryPackInclude]
IPEndPoint[] Masters => info.Masters;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackInclude]
int Id => info.Id;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
int BandwidthEachConnection => info.BandwidthEach;
[MemoryPackInclude]
bool Public => info.Public;
@@ -381,9 +381,9 @@ namespace linker.messenger.serializer.memorypack
bool Manageable => info.Manageable;
[MemoryPackConstructor]
SerializableRelayServerNodeStoreInfo(string nodeId, string name, TunnelProtocolType protocol, int connections, int bandwidth, int dataEachMonth,
long dataRemain, string url, string logo, string masterKey, string version, int connectionsRatio, double bandwidthRatio, IPEndPoint[] masters, string domain,
int id, string host, int bandwidthEachConnection, bool Public, long lastTicks, bool manageable)
SerializableRelayServerNodeStoreInfo(string nodeId, string name,string host, TunnelProtocolType protocol, int connections, int bandwidth, int dataEachMonth,
long dataRemain, string url, string logo, string masterKey, string version, int connectionsRatio, double bandwidthRatio, IPEndPoint[] masters,
int id, int bandwidthEachConnection, bool Public, long lastTicks, bool manageable)
{
var info = new RelayServerNodeStoreInfo
{
@@ -401,7 +401,6 @@ namespace linker.messenger.serializer.memorypack
ConnectionsRatio = connectionsRatio,
BandwidthRatio = bandwidthRatio,
Masters = masters,
Domain = domain,
Id = id,
Host = host,
BandwidthEach = bandwidthEachConnection,
@@ -443,6 +442,7 @@ namespace linker.messenger.serializer.memorypack
reader.TryReadObjectHeader(out byte count);
value.NodeId = reader.ReadValue<string>();
value.Name = reader.ReadValue<string>();
value.Host = reader.ReadValue<string>();
value.Protocol = reader.ReadValue<TunnelProtocolType>();
value.Connections = reader.ReadValue<int>();
value.Bandwidth = reader.ReadValue<int>();
@@ -455,9 +455,8 @@ namespace linker.messenger.serializer.memorypack
value.ConnectionsRatio = reader.ReadValue<int>();
value.BandwidthRatio = reader.ReadValue<double>();
value.Masters = reader.ReadValue<IPEndPoint[]>();
value.Domain = reader.ReadValue<string>();
value.Id = reader.ReadValue<int>();
value.Host = reader.ReadValue<string>();
value.BandwidthEach = reader.ReadValue<int>();
value.Public = reader.ReadValue<bool>();
value.LastTicks = reader.ReadValue<long>();
@@ -474,15 +473,16 @@ namespace linker.messenger.serializer.memorypack
[MemoryPackInclude]
string NodeId => info.NodeId;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
string SystemId => info.SystemId;
[MemoryPackConstructor]
SerializableRelayServerNodeShareInfo(string nodeId, string host, string name, string systemid)
SerializableRelayServerNodeShareInfo(string nodeId, string name, string host, string systemid)
{
var info = new RelayServerNodeShareInfo
{
@@ -524,8 +524,8 @@ namespace linker.messenger.serializer.memorypack
value = new RelayServerNodeShareInfo();
reader.TryReadObjectHeader(out byte count);
value.NodeId = reader.ReadValue<string>();
value.Host = reader.ReadValue<string>();
value.Name = reader.ReadValue<string>();
value.Host = reader.ReadValue<string>();
value.SystemId = reader.ReadValue<string>();
}
}

221
src/linker.messenger.serializer.memorypack/SForwardSerializer.cs
View File

@@ -183,8 +183,6 @@ namespace linker.messenger.serializer.memorypack
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardProxyInfo
{
@@ -269,65 +267,6 @@ namespace linker.messenger.serializer.memorypack
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardCountInfo
{
[MemoryPackIgnore]
public readonly SForwardCountInfo info;
[MemoryPackInclude]
string MachineId => info.MachineId;
[MemoryPackInclude]
int Count => info.Count;
[MemoryPackConstructor]
SerializableSForwardCountInfo(string machineId, int count)
{
this.info = new SForwardCountInfo
{
MachineId = machineId,
Count = count
};
}
public SerializableSForwardCountInfo(SForwardCountInfo info)
{
this.info = info;
}
}
public class SForwardCountInfoFormatter : MemoryPackFormatter<SForwardCountInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardCountInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardCountInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardCountInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
value = new SForwardCountInfo();
reader.TryReadObjectHeader(out byte count);
value.MachineId = reader.ReadValue<string>();
value.Count = reader.ReadValue<int>();
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardAddInfo
{
@@ -521,150 +460,10 @@ namespace linker.messenger.serializer.memorypack
}
[MemoryPackable]
public readonly partial struct SerializableSForwardServerNodeUpdateInfo
public readonly partial struct SerializableSForwardServerNodeReportInfoOld
{
[MemoryPackIgnore]
public readonly SForwardServerNodeUpdateInfo info;
[MemoryPackInclude]
string Id => info.Id;
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
double MaxBandwidth => info.MaxBandwidth;
[MemoryPackInclude]
double MaxBandwidthTotal => info.MaxBandwidthTotal;
[MemoryPackInclude]
double MaxGbTotal => info.MaxGbTotal;
[MemoryPackInclude]
long MaxGbTotalLastBytes => info.MaxGbTotalLastBytes;
[MemoryPackInclude]
string Domain => info.Domain;
[MemoryPackInclude]
string Host => info.Host;
[MemoryPackInclude]
bool Public => info.Public;
[MemoryPackInclude]
string Url => info.Url;
[MemoryPackInclude]
bool Sync2Server => info.Sync2Server;
[MemoryPackInclude]
int WebPort => info.WebPort;
[MemoryPackInclude]
int[] PortRange => info.PortRange;
[MemoryPackConstructor]
SerializableSForwardServerNodeUpdateInfo(
string id, string name, double maxBandwidth, double maxBandwidthTotal,
double maxGbTotal, long maxGbTotalLastBytes, string domain, string host,
bool Public, string url, bool sync2Server, int webport, int[] portrange)
{
var info = new SForwardServerNodeUpdateInfo
{
Id = id,
Name = name,
MaxBandwidth = maxBandwidth,
MaxBandwidthTotal = maxBandwidthTotal,
MaxGbTotal = maxGbTotal,
MaxGbTotalLastBytes = maxGbTotalLastBytes,
Domain = domain,
Host = host,
Public = Public,
Url = url,
Sync2Server = sync2Server,
WebPort = webport,
PortRange = portrange
};
this.info = info;
}
public SerializableSForwardServerNodeUpdateInfo(SForwardServerNodeUpdateInfo info)
{
this.info = info;
}
}
public class SForwardServerNodeUpdateInfoFormatter : MemoryPackFormatter<SForwardServerNodeUpdateInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardServerNodeUpdateInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardServerNodeUpdateInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardServerNodeUpdateInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardServerNodeUpdateInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardServerNodeUpdateWrapInfo
{
[MemoryPackIgnore]
public readonly SForwardServerNodeUpdateWrapInfo info;
[MemoryPackInclude]
string SecretKey => string.Empty;
[MemoryPackInclude, MemoryPackAllowSerialize]
SForwardServerNodeUpdateInfo Info => info.Info;
[MemoryPackConstructor]
SerializableSForwardServerNodeUpdateWrapInfo(string secretKey, SForwardServerNodeUpdateInfo info)
{
this.info = new SForwardServerNodeUpdateWrapInfo
{
Info = info
};
}
public SerializableSForwardServerNodeUpdateWrapInfo(SForwardServerNodeUpdateWrapInfo info)
{
this.info = info;
}
}
public class SForwardServerNodeUpdateWrapInfoFormatter : MemoryPackFormatter<SForwardServerNodeUpdateWrapInfo>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardServerNodeUpdateWrapInfo value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableSForwardServerNodeUpdateWrapInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardServerNodeUpdateWrapInfo value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardServerNodeUpdateWrapInfo>();
value = wrapped.info;
}
}
[MemoryPackable]
public readonly partial struct SerializableSForwardServerNodeReportInfo
{
[MemoryPackIgnore]
public readonly SForwardServerNodeReportInfo info;
public readonly SForwardServerNodeReportInfoOld info;
[MemoryPackInclude]
string Id => info.Id;
@@ -705,13 +504,13 @@ namespace linker.messenger.serializer.memorypack
[MemoryPackConstructor]
SerializableSForwardServerNodeReportInfo(
SerializableSForwardServerNodeReportInfoOld(
string id, string name, double maxBandwidth, double maxBandwidthTotal,
double maxGbTotal, long maxGbTotalLastBytes, double bandwidthRatio,
bool Public, int delay,
string domain, IPAddress address, long lastTicks, string url, bool sync2Server, string version, int webport, int[] portrange)
{
var info = new SForwardServerNodeReportInfo
var info = new SForwardServerNodeReportInfoOld
{
BandwidthRatio = bandwidthRatio,
MaxBandwidth = maxBandwidth,
@@ -734,14 +533,14 @@ namespace linker.messenger.serializer.memorypack
this.info = info;
}
public SerializableSForwardServerNodeReportInfo(SForwardServerNodeReportInfo info)
public SerializableSForwardServerNodeReportInfoOld(SForwardServerNodeReportInfoOld info)
{
this.info = info;
}
}
public class SForwardServerNodeReportInfoFormatter : MemoryPackFormatter<SForwardServerNodeReportInfo>
public class SForwardServerNodeReportInfoOldFormatter : MemoryPackFormatter<SForwardServerNodeReportInfoOld>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardServerNodeReportInfo value)
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref SForwardServerNodeReportInfoOld value)
{
if (value == null)
{
@@ -749,10 +548,10 @@ namespace linker.messenger.serializer.memorypack
return;
}
writer.WritePackable(new SerializableSForwardServerNodeReportInfo(value));
writer.WritePackable(new SerializableSForwardServerNodeReportInfoOld(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardServerNodeReportInfo value)
public override void Deserialize(ref MemoryPackReader reader, scoped ref SForwardServerNodeReportInfoOld value)
{
if (reader.PeekIsNull())
{
@@ -761,7 +560,7 @@ namespace linker.messenger.serializer.memorypack
return;
}
var wrapped = reader.ReadPackable<SerializableSForwardServerNodeReportInfo>();
var wrapped = reader.ReadPackable<SerializableSForwardServerNodeReportInfoOld>();
value = wrapped.info;
}
}

27
src/linker.messenger.sforward/Config.cs
View File

@@ -61,25 +61,7 @@ namespace linker.messenger.sforward
public string NodeId1 { get; set; } = string.Empty;
}
public sealed class SForwardConfigServerInfo
{
/// <summary>
/// web端口
/// </summary>
public int WebPort { get; set; }
/// <summary>
/// 开放端口范围
/// </summary>
public int[] TunnelPortRange { get; set; } = new int[] { 10000, 60000 };
public DistributedInfo Distributed { get; set; } = new DistributedInfo { };
}
public sealed class DistributedInfo
{
public SForwardServerNodeInfo Node { get; set; } = new SForwardServerNodeInfo { };
public SForwardServerMasterInfo Master { get; set; } = new SForwardServerMasterInfo { };
}
/// <summary>
/// 往服务器添加穿透
/// </summary>
@@ -162,11 +144,4 @@ namespace linker.messenger.sforward
public IPAddress Addr { get; set; }
}
public sealed partial class SForwardCountInfo
{
public string MachineId { get; set; }
public int Count { get; set; }
}
}

20
src/linker.messenger.sforward/Entry.cs
View File

@@ -1,6 +1,5 @@
using linker.libs;
using linker.libs.web;
using linker.messenger.decenter;
using linker.messenger.plan;
using linker.messenger.sforward.client;
using linker.messenger.sforward.messenger;
@@ -61,6 +60,11 @@ namespace linker.messenger.sforward
serviceCollection.AddSingleton<SForwardServerNodeTransfer>();
serviceCollection.AddSingleton<SForwardServerReportResolver>();
serviceCollection.AddSingleton<SForwardServerConnectionResolver>();
serviceCollection.AddSingleton<SForwardServerConnectionTransfer>();
serviceCollection.AddSingleton<SForwardServerNodeReportTransfer>();
serviceCollection.AddSingleton<ISForwardServerWhiteListStore, SForwardServerWhiteListStore>();
return serviceCollection;
@@ -76,15 +80,19 @@ namespace linker.messenger.sforward
ResolverTransfer resolverTransfer = serviceProvider.GetService<ResolverTransfer>();
resolverTransfer.AddResolvers(new List<IResolver>
{
serviceProvider.GetService<SForwardServerReportResolver>()
serviceProvider.GetService<SForwardServerReportResolver>(),
serviceProvider.GetService<SForwardServerConnectionResolver>(),
});
SForwardServerNodeTransfer relayServerNodeTransfer = serviceProvider.GetService<SForwardServerNodeTransfer>();
SForwardServerMasterTransfer relayServerMasterTransfer = serviceProvider.GetService<SForwardServerMasterTransfer>();
SForwardProxy sForwardProxy = serviceProvider.GetService<SForwardProxy>();
ISForwardServerStore sForwardServerStore = serviceProvider.GetService<ISForwardServerStore>();
if (sForwardServerStore.WebPort > 0)
ISForwardServerConfigStore sForwardServerStore = serviceProvider.GetService<ISForwardServerConfigStore>();
if (sForwardServerStore.Config.WebPort > 0)
{
sForwardProxy.StartHttp(sForwardServerStore.WebPort,3 );
LoggerHelper.Instance.Debug($"start web forward in {sForwardServerStore.WebPort}");
sForwardProxy.StartHttp(sForwardServerStore.Config.WebPort, 3 );
LoggerHelper.Instance.Debug($"start web forward in {sForwardServerStore.Config.WebPort}");
}
return serviceProvider;

99
src/linker.messenger.sforward/client/SForwardApiController.cs
View File

@@ -1,5 +1,4 @@
using linker.libs.extends;
using System.Collections.Concurrent;
using linker.messenger.signin;
using linker.libs;
using linker.messenger.api;
@@ -35,7 +34,7 @@ namespace linker.messenger.sforward.client
this.sForwardClientTestTransfer = sForwardClientTestTransfer;
}
public List<SForwardServerNodeReportInfo> Subscribe(ApiControllerParamsInfo param)
public List<SForwardServerNodeStoreInfo> Subscribe(ApiControllerParamsInfo param)
{
sForwardClientTestTransfer.Subscribe();
return sForwardClientTestTransfer.Nodes;
@@ -73,7 +72,7 @@ namespace linker.messenger.sforward.client
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task<bool> Add(ApiControllerParamsInfo param)
public async Task<bool> AddClient(ApiControllerParamsInfo param)
{
SForwardAddForwardInfo info = param.Content.DeJson<SForwardAddForwardInfo>();
if (info.MachineId == signInClientStore.Id)
@@ -85,7 +84,7 @@ namespace linker.messenger.sforward.client
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.AddClientForward191,
MessengerId = (ushort)SForwardMessengerIds.AddClientForward,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
@@ -96,7 +95,7 @@ namespace linker.messenger.sforward.client
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task<bool> Remove(ApiControllerParamsInfo param)
public async Task<bool> RemoveClient(ApiControllerParamsInfo param)
{
SForwardRemoveForwardInfo info = param.Content.DeJson<SForwardRemoveForwardInfo>();
if (info.MachineId == signInClientStore.Id)
@@ -172,32 +171,60 @@ namespace linker.messenger.sforward.client
}
/// <summary>
/// 更新节点
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task<bool> Edit(ApiControllerParamsInfo param)
public async Task<string> Share(ApiControllerParamsInfo param)
{
SForwardServerNodeUpdateInfo info = param.Content.DeJson<SForwardServerNodeUpdateInfo>();
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.EditForward,
Payload = serializer.Serialize(new SForwardServerNodeUpdateWrapInfo
{
Info = info,
})
}).ConfigureAwait(false);
MessengerId = (ushort)SForwardMessengerIds.ShareForward,
Payload = serializer.Serialize(param.Content)
});
return resp.Code == MessageResponeCodes.OK ? serializer.Deserialize<string>(resp.Data.Span) : $"network error:{resp.Code}";
}
public async Task<string> Import(ApiControllerParamsInfo param)
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.Import,
Payload = serializer.Serialize(param.Content)
});
return resp.Code == MessageResponeCodes.OK ? serializer.Deserialize<string>(resp.Data.Span) : $"network error:{resp.Code}";
}
public async Task<string> Remove(ApiControllerParamsInfo param)
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.Remove,
Payload = serializer.Serialize(param.Content)
});
return resp.Code == MessageResponeCodes.OK ? serializer.Deserialize<string>(resp.Data.Span) : $"network error:{resp.Code}";
}
public async Task<bool> Update(ApiControllerParamsInfo param)
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.UpdateForward,
Payload = serializer.Serialize(param.Content.DeJson<SForwardServerNodeStoreInfo>())
});
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
}
/// <summary>
/// 重启节点
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task<bool> Upgrade(ApiControllerParamsInfo param)
{
KeyValueInfo<string, string> info = param.Content.DeJson<KeyValueInfo<string, string>>();
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.UpgradeForward,
Payload = serializer.Serialize(new KeyValuePair<string, string>(info.Key, info.Value))
});
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
}
public async Task<bool> Exit(ApiControllerParamsInfo param)
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
@@ -205,31 +232,9 @@ namespace linker.messenger.sforward.client
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.ExitForward,
Payload = serializer.Serialize(param.Content)
}).ConfigureAwait(false);
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
}
/// <summary>
/// 更新节点
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task<bool> Update(ApiControllerParamsInfo param)
{
KeyValueInfo<string, string> info = param.Content.DeJson<KeyValueInfo<string,string>>();
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.UpdateForward,
Payload = serializer.Serialize(new KeyValuePair<string, string>(info.Key, info.Value))
}).ConfigureAwait(false);
});
return resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray);
}
}
public sealed class SForwardListInfo
{
public ConcurrentDictionary<string, int> List { get; set; }
public ulong HashCode { get; set; }
}
}

12
src/linker.messenger.sforward/client/SForwardClientTestTransfer.cs
View File

@@ -18,7 +18,7 @@ namespace linker.messenger.sforward.client
private readonly IMessengerSender messengerSender;
private readonly ISerializer serializer;
public List<SForwardServerNodeReportInfo> Nodes { get; private set; } = new List<SForwardServerNodeReportInfo>();
public List<SForwardServerNodeStoreInfo> Nodes { get; private set; } = new List<SForwardServerNodeStoreInfo>();
public SForwardClientTestTransfer(SignInClientState signInClientState, ISignInClientStore signInClientStore, IMessengerSender messengerSender, ISerializer serializer)
{
@@ -32,7 +32,7 @@ namespace linker.messenger.sforward.client
public string DefaultId()
{
if (Nodes.Count > 0) return Nodes[0].Id;
if (Nodes.Count > 0) return Nodes[0].NodeId;
return string.Empty;
}
@@ -53,7 +53,7 @@ namespace linker.messenger.sforward.client
});
if(resp.Code == MessageResponeCodes.OK)
{
Nodes = serializer.Deserialize<List<SForwardServerNodeReportInfo>>(resp.Data.Span);
Nodes = serializer.Deserialize<List<SForwardServerNodeStoreInfo>>(resp.Data.Span);
}
}
catch (Exception ex)
@@ -70,10 +70,12 @@ namespace linker.messenger.sforward.client
{
var tasks = Nodes.Select(async (c) =>
{
c.Address = c.Address == null || c.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address.Address : c.Address;
IPEndPoint ep = await NetworkHelper.GetEndPointAsync(c.Host,1802);
ep.Address = ep.Address == null || ep.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address.Address : ep.Address;
using Ping ping = new Ping();
var resp = await ping.SendPingAsync(c.Address, 1000);
var resp = await ping.SendPingAsync(ep.Address, 1000);
c.Delay = resp.Status == IPStatus.Success ? (int)resp.RoundtripTime : -1;
});
await Task.WhenAll(tasks).ConfigureAwait(false);

4
src/linker.messenger.sforward/client/SForwardClientTransfer.cs
View File

@@ -77,7 +77,7 @@ namespace linker.messenger.sforward.client
messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.AddForward191,
MessengerId = (ushort)SForwardMessengerIds.StartForward,
Payload = serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, NodeId = forwardInfo.NodeId1 })
}).ContinueWith((result) =>
{
@@ -119,7 +119,7 @@ namespace linker.messenger.sforward.client
messengerSender.SendReply(new MessageRequestWrap
{
Connection = signInClientState.Connection,
MessengerId = (ushort)SForwardMessengerIds.RemoveForward191,
MessengerId = (ushort)SForwardMessengerIds.StopForward,
Payload = serializer.Serialize(new SForwardAddInfo { Domain = forwardInfo.Domain, RemotePort = forwardInfo.RemotePort, NodeId = forwardInfo.NodeId1 })
}).ContinueWith((result) =>
{

584
src/linker.messenger.sforward/messenger/SForwardMessenger.cs
View File

@@ -25,11 +25,13 @@ namespace linker.messenger.sforward.messenger
private readonly SForwardServerMasterTransfer sForwardServerMasterTransfer;
private readonly SForwardServerNodeTransfer sForwardServerNodeTransfer;
private readonly ISignInServerStore signInServerStore;
private readonly SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer;
private readonly SForwardServerConnectionTransfer sForwardServerConnectionTransfer;
public SForwardServerMessenger(SForwardProxy proxy, ISForwardServerCahing sForwardServerCahing, IMessengerSender sender,
SignInServerCaching signCaching, SForwardValidatorTransfer validator, ISerializer serializer,
SForwardServerMasterTransfer sForwardServerMasterTransfer, SForwardServerNodeTransfer sForwardServerNodeTransfer,
ISignInServerStore signInServerStore)
ISignInServerStore signInServerStore, SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer, SForwardServerConnectionTransfer sForwardServerConnectionTransfer)
{
this.proxy = proxy;
proxy.WebConnect = WebConnect;
@@ -43,10 +45,17 @@ namespace linker.messenger.sforward.messenger
this.sForwardServerMasterTransfer = sForwardServerMasterTransfer;
this.sForwardServerNodeTransfer = sForwardServerNodeTransfer;
this.signInServerStore = signInServerStore;
this.sForwardServerNodeReportTransfer = sForwardServerNodeReportTransfer;
this.sForwardServerConnectionTransfer = sForwardServerConnectionTransfer;
ClearTask();
}
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Nodes)]
public async Task Nodes(IConnection connection)
{
@@ -56,132 +65,53 @@ namespace linker.messenger.sforward.messenger
return;
}
var nodes = await sForwardServerMasterTransfer.GetNodes(cache.Super, cache.UserId, cache.MachineId);
var nodes = await sForwardServerNodeReportTransfer.GetNodes(cache.Super, cache.UserId, cache.MachineId);
connection.Write(serializer.Serialize(nodes));
}
[MessengerId((ushort)SForwardMessengerIds.NodeReport)]
public void NodeReport(IConnection connection)
{
try
{
SForwardServerNodeReportInfo info = serializer.Deserialize<SForwardServerNodeReportInfo>(connection.ReceiveRequestWrap.Payload.Span);
sForwardServerMasterTransfer.SetNodeReport(connection, info);
}
catch (Exception)
{
}
connection.Write(serializer.Serialize(VersionHelper.Version));
}
[MessengerId((ushort)SForwardMessengerIds.Edit)]
public void Edit(IConnection connection)
{
SForwardServerNodeUpdateInfo info = serializer.Deserialize<SForwardServerNodeUpdateInfo>(connection.ReceiveRequestWrap.Payload.Span);
sForwardServerNodeTransfer.Edit(info);
}
[MessengerId((ushort)SForwardMessengerIds.EditForward)]
public async Task EditForward188(IConnection connection)
{
SForwardServerNodeUpdateWrapInfo info = serializer.Deserialize<SForwardServerNodeUpdateWrapInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) && cache.Super)
{
await sForwardServerMasterTransfer.Edit(info.Info).ConfigureAwait(false);
connection.Write(Helper.TrueArray);
}
else
{
connection.Write(Helper.FalseArray);
}
}
[MessengerId((ushort)SForwardMessengerIds.Exit)]
public void Exit(IConnection connection)
{
sForwardServerNodeTransfer.Exit();
}
[MessengerId((ushort)SForwardMessengerIds.ExitForward)]
public async Task ExitForward(IConnection connection)
{
string id = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) && cache.Super)
{
await sForwardServerMasterTransfer.Exit(id).ConfigureAwait(false);
connection.Write(Helper.TrueArray);
}
else
{
connection.Write(Helper.FalseArray);
}
}
[MessengerId((ushort)SForwardMessengerIds.Update)]
public void Update(IConnection connection)
{
sForwardServerNodeTransfer.Update(serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span));
}
[MessengerId((ushort)SForwardMessengerIds.UpdateForward)]
public async Task UpdateForward(IConnection connection)
{
KeyValuePair<string, string> info = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) && cache.Super)
{
await sForwardServerMasterTransfer.Update(info.Key, info.Value).ConfigureAwait(false);
connection.Write(Helper.TrueArray);
}
else
{
connection.Write(Helper.FalseArray);
}
}
/// <summary>
/// 添加穿透
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
[MessengerId((ushort)SForwardMessengerIds.Add)]
public async Task Add(IConnection connection)
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.NodeReport)]
public async Task NodeReport(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = 3 };
try
{
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
SForwardServerNodeReportInfoOld info = serializer.Deserialize<SForwardServerNodeReportInfoOld>(connection.ReceiveRequestWrap.Payload.Span);
if (info.Address.Equals(IPAddress.Any) || info.Address.Equals(IPAddress.Loopback))
{
result.Success = false;
result.Message = "need sign in";
return;
info.Address = connection.Address.Address;
}
SForwardAddInfo SForwardAddInfo = new SForwardAddInfo
{
Domain = sForwardAddInfo.Domain,
RemotePort = sForwardAddInfo.RemotePort,
MachineId = cache.MachineId,
GroupId = cache.GroupId
};
string error = await validator.Validate(cache, SForwardAddInfo).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(error) == false)
{
result.Success = false;
result.Message = error;
return;
}
Add(sForwardAddInfo, cache.MachineId, cache.GroupId, result, SForwardAddInfo.Super, SForwardAddInfo.Bandwidth);
await sForwardServerNodeReportTransfer.Report(info.Id, info.Name, info.Address.ToString()).ConfigureAwait(false);
}
catch (Exception ex)
{
result.Success = false;
result.Message = $"sforward fail : {ex.Message}";
LoggerHelper.Instance.Error(result.Message);
LoggerHelper.Instance.Error(ex);
}
finally
{
connection.Write(serializer.Serialize(result));
}
connection.Write(serializer.Serialize(VersionHelper.Version));
}
[MessengerId((ushort)SForwardMessengerIds.Add191)]
public void Add191(IConnection connection)
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Heart)]
public void Heart(IConnection connection)
{
List<string> ids = serializer.Deserialize<List<string>>(connection.ReceiveRequestWrap.Payload.Span);
connection.Write(serializer.Serialize(ids.Except(signCaching.GetOnline()).ToList()));
}
/// <summary>
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
[MessengerId((ushort)SForwardMessengerIds.Start)]
public void Start(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = 3 };
@@ -201,8 +131,13 @@ namespace linker.messenger.sforward.messenger
}
}
[MessengerId((ushort)SForwardMessengerIds.AddForward191)]
public async Task AddForward191(IConnection connection)
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.StartForward)]
public async Task StartForward(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true, BufferSize = 3 };
@@ -224,7 +159,7 @@ namespace linker.messenger.sforward.messenger
sForwardAddInfo.GroupId = cache.GroupId;
sForwardAddInfo.MachineId = cache.MachineId;
result = await sForwardServerMasterTransfer.Add(sForwardAddInfo, cache);
result = await sForwardServerMasterTransfer.Start(sForwardAddInfo, cache);
}
catch (Exception ex)
{
@@ -238,48 +173,12 @@ namespace linker.messenger.sforward.messenger
}
}
[MessengerId((ushort)SForwardMessengerIds.Heart)]
public void Heart(IConnection connection)
{
List<string> ids = serializer.Deserialize<List<string>>(connection.ReceiveRequestWrap.Payload.Span);
connection.Write(serializer.Serialize(ids.Except(signCaching.GetOnline()).ToList()));
}
[MessengerId((ushort)SForwardMessengerIds.Hosts)]
public void Hosts(IConnection connection)
{
connection.Write(serializer.Serialize(signInServerStore.Hosts));
}
/// <summary>
/// 删除穿透
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
[MessengerId((ushort)SForwardMessengerIds.Remove)]
public void Remove(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true };
try
{
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
{
result.Success = false;
result.Message = "need sign in";
return;
}
Remove(sForwardAddInfo, cache.MachineId, result);
}
catch (Exception)
{
}
finally
{
connection.Write(serializer.Serialize(result));
}
}
[MessengerId((ushort)SForwardMessengerIds.Remove191)]
public void Remove191(IConnection connection)
[MessengerId((ushort)SForwardMessengerIds.Stop)]
public void Stop(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true };
@@ -296,8 +195,13 @@ namespace linker.messenger.sforward.messenger
connection.Write(serializer.Serialize(result));
}
}
[MessengerId((ushort)SForwardMessengerIds.RemoveForward191)]
public async Task RemoveForward191(IConnection connection)
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.StopForward)]
public async Task StopForward(IConnection connection)
{
SForwardAddInfo sForwardAddInfo = serializer.Deserialize<SForwardAddInfo>(connection.ReceiveRequestWrap.Payload.Span);
SForwardAddResultInfo result = new SForwardAddResultInfo { Success = true };
@@ -312,7 +216,7 @@ namespace linker.messenger.sforward.messenger
}
sForwardAddInfo.GroupId = cache.GroupId;
sForwardAddInfo.MachineId = cache.MachineId;
result = await sForwardServerMasterTransfer.Remove(sForwardAddInfo);
result = await sForwardServerMasterTransfer.Stop(sForwardAddInfo);
}
catch (Exception)
{
@@ -324,7 +228,7 @@ namespace linker.messenger.sforward.messenger
}
public void Remove(SForwardAddInfo sForwardAddInfo, string machineId, SForwardAddResultInfo result)
private void Remove(SForwardAddInfo sForwardAddInfo, string machineId, SForwardAddResultInfo result)
{
try
{
@@ -334,7 +238,7 @@ namespace linker.messenger.sforward.messenger
{
for (int port = min; port <= max; port++)
{
if (sForwardServerCahing.TryRemove(port, machineId, out _))
if (sForwardServerCahing.TryRemove(port, machineId, sForwardAddInfo.NodeId, out _))
{
proxy.Stop(port);
}
@@ -342,7 +246,7 @@ namespace linker.messenger.sforward.messenger
}
else
{
sForwardServerCahing.TryRemove(sForwardAddInfo.Domain, machineId, out _);
sForwardServerCahing.TryRemove(sForwardAddInfo.Domain, machineId, sForwardAddInfo.NodeId, out _);
proxy.RemoveHttp(sForwardAddInfo.Domain);
result.Message = $"domain 【{sForwardAddInfo.Domain}】 remove success";
}
@@ -351,7 +255,7 @@ namespace linker.messenger.sforward.messenger
if (sForwardAddInfo.RemotePort > 0)
{
sForwardServerCahing.TryRemove(sForwardAddInfo.RemotePort, machineId, out _);
sForwardServerCahing.TryRemove(sForwardAddInfo.RemotePort, machineId,sForwardAddInfo.NodeId, out _);
proxy.Stop(sForwardAddInfo.RemotePort);
result.Message = $"port 【{sForwardAddInfo.RemotePort}】 remove success";
return;
@@ -363,11 +267,11 @@ namespace linker.messenger.sforward.messenger
result.Message = $"sforward fail : {ex.Message}";
}
}
public void Remove(SForwardAddInfo sForwardAddInfo, SForwardAddResultInfo result)
private void Remove(SForwardAddInfo sForwardAddInfo, SForwardAddResultInfo result)
{
Remove((SForwardAddInfo)sForwardAddInfo, sForwardAddInfo.MachineId, result);
Remove(sForwardAddInfo, sForwardAddInfo.MachineId, result);
}
public void Add(SForwardAddInfo sForwardAddInfo, string machineId, string groupid, SForwardAddResultInfo result, bool super, double bandwidth)
private void Add(SForwardAddInfo sForwardAddInfo, string machineId, string groupid, SForwardAddResultInfo result, bool super, double bandwidth)
{
try
{
@@ -379,7 +283,7 @@ namespace linker.messenger.sforward.messenger
{
for (int port = min; port <= max; port++)
{
if (sForwardServerCahing.TryAdd(port, machineId))
if (sForwardServerCahing.TryAdd(port, machineId, sForwardAddInfo.NodeId))
{
proxy.Stop(port);
result.Message = proxy.Start(port, 3, groupid, super, bandwidth);
@@ -393,7 +297,7 @@ namespace linker.messenger.sforward.messenger
}
else
{
if (sForwardServerCahing.TryAdd(sForwardAddInfo.Domain, machineId) == false)
if (sForwardServerCahing.TryAdd(sForwardAddInfo.Domain, machineId, sForwardAddInfo.NodeId) == false)
{
result.Success = false;
result.Message = $"domain 【{sForwardAddInfo.Domain}】 already exists";
@@ -411,7 +315,7 @@ namespace linker.messenger.sforward.messenger
//如果是端口
if (sForwardAddInfo.RemotePort > 0)
{
if (sForwardServerCahing.TryAdd(sForwardAddInfo.RemotePort, machineId) == false)
if (sForwardServerCahing.TryAdd(sForwardAddInfo.RemotePort, machineId, sForwardAddInfo.NodeId) == false)
{
result.Success = false;
@@ -443,9 +347,9 @@ namespace linker.messenger.sforward.messenger
result.Message = $"sforward fail : {ex.Message}";
}
}
public void Add(SForwardAddInfo sForwardAddInfo, SForwardAddResultInfo result)
private void Add(SForwardAddInfo sForwardAddInfo, SForwardAddResultInfo result)
{
Add((SForwardAddInfo)sForwardAddInfo, sForwardAddInfo.MachineId, sForwardAddInfo.GroupId, result, sForwardAddInfo.Super, sForwardAddInfo.Bandwidth);
Add(sForwardAddInfo, sForwardAddInfo.MachineId, sForwardAddInfo.GroupId, result, sForwardAddInfo.Super, sForwardAddInfo.Bandwidth);
}
private static bool PortRange(string str, out int min, out int max)
{
@@ -456,9 +360,10 @@ namespace linker.messenger.sforward.messenger
/// <summary>
/// 获取对端的穿透记录
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.GetForward)]
public void GetForward(IConnection connection)
{
@@ -487,9 +392,10 @@ namespace linker.messenger.sforward.messenger
}
}
/// <summary>
/// 添加对端的穿透记录
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.AddClientForward)]
public async Task AddClientForward(IConnection connection)
{
@@ -517,38 +423,11 @@ namespace linker.messenger.sforward.messenger
}).ConfigureAwait(false);
}
}
[MessengerId((ushort)SForwardMessengerIds.AddClientForward191)]
public async Task AddClientForward191(IConnection connection)
{
SForwardAddForwardInfo info = serializer.Deserialize<SForwardAddForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, info.MachineId, out SignCacheInfo from, out SignCacheInfo to))
{
uint requestid = connection.ReceiveRequestWrap.RequestId;
await sender.SendReply(new MessageRequestWrap
{
Connection = to.Connection,
MessengerId = (ushort)SForwardMessengerIds.AddClient191,
Payload = serializer.Serialize(info.Data)
}).ContinueWith(async (result) =>
{
if (result.Result.Code == MessageResponeCodes.OK)
{
await sender.ReplyOnly(new MessageResponseWrap
{
Connection = connection,
Code = MessageResponeCodes.OK,
Payload = result.Result.Data,
RequestId = requestid
}, (ushort)SForwardMessengerIds.AddClientForward191).ConfigureAwait(false);
}
}).ConfigureAwait(false);
}
}
/// <summary>
/// 删除对端的穿透记录
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.RemoveClientForward)]
public async Task RemoveClientForward(IConnection connection)
{
@@ -576,7 +455,11 @@ namespace linker.messenger.sforward.messenger
}).ConfigureAwait(false);
}
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.StartClientForward)]
public async Task StartClientForward(IConnection connection)
{
@@ -591,6 +474,11 @@ namespace linker.messenger.sforward.messenger
}).ConfigureAwait(false);
}
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.StopClientForward)]
public async Task StopClientForward(IConnection connection)
{
@@ -605,11 +493,11 @@ namespace linker.messenger.sforward.messenger
}).ConfigureAwait(false);
}
}
/// <summary>
/// 测试对端的穿透记录
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.TestClientForward)]
public async Task TestClientForward(IConnection connection)
{
@@ -625,30 +513,227 @@ namespace linker.messenger.sforward.messenger
}
}
/// <summary>
/// 来自节点的连接
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.ProxyNode)]
[MessengerId((ushort)SForwardMessengerIds.SignIn)]
public async Task SignIn(IConnection connection)
{
KeyValuePair<string, string> kv = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
if (await sForwardServerNodeReportTransfer.SignIn(kv.Key, kv.Value, connection).ConfigureAwait(false))
{
connection.Write(Helper.TrueArray);
}
else
{
connection.Write(Helper.FalseArray);
}
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Report)]
public async Task Report(IConnection connection)
{
SForwardServerNodeReportInfo info = serializer.Deserialize<SForwardServerNodeReportInfo>(connection.ReceiveRequestWrap.Payload.Span);
await sForwardServerNodeReportTransfer.Report(info).ConfigureAwait(false);
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.ShareForward)]
public async Task ShareForward(IConnection connection)
{
string id = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(serializer.Serialize("need super key"));
return;
}
connection.Write(serializer.Serialize(await sForwardServerNodeReportTransfer.GetShareKeyForward(id)));
}
/// <summary>
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Share)]
public async Task Share(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
connection.Write(serializer.Serialize(await sForwardServerNodeReportTransfer.GetShareKey(masterKey)));
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Import)]
public async Task Import(IConnection connection)
{
string sharekey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(serializer.Serialize("need super key"));
return;
}
string result = await sForwardServerNodeReportTransfer.Import(sharekey).ConfigureAwait(false);
connection.Write(serializer.Serialize(result));
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Remove)]
public async Task Remove(IConnection connection)
{
string id = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(serializer.Serialize("need super key"));
return;
}
bool result = await sForwardServerNodeReportTransfer.Remove(id).ConfigureAwait(false);
connection.Write(serializer.Serialize(result ? string.Empty : "remove fail"));
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.UpdateForward)]
public async Task UpdateForward(IConnection connection)
{
SForwardServerNodeStoreInfo info = serializer.Deserialize<SForwardServerNodeStoreInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(Helper.FalseArray);
return;
}
bool result = await sForwardServerNodeReportTransfer.UpdateForward(info).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
/// <summary>
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Update)]
public async Task Update(IConnection connection)
{
SForwardServerNodeStoreInfo info = serializer.Deserialize<SForwardServerNodeStoreInfo>(connection.ReceiveRequestWrap.Payload.Span);
await sForwardServerNodeReportTransfer.Update(info).ConfigureAwait(false);
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.UpgradeForward)]
public async Task UpgradeForward(IConnection connection)
{
KeyValuePair<string, string> info = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(Helper.FalseArray);
return;
}
bool result = await sForwardServerNodeReportTransfer.UpgradeForward(info.Key, info.Value).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
/// <summary>
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Upgrade)]
public async Task Upgrade(IConnection connection)
{
KeyValuePair<string, string> info = serializer.Deserialize<KeyValuePair<string, string>>(connection.ReceiveRequestWrap.Payload.Span);
await sForwardServerNodeReportTransfer.Upgrade(info.Key, info.Value).ConfigureAwait(false);
}
/// <summary>
/// 信标服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.ExitForward)]
public async Task ExitForward(IConnection connection)
{
string nodeid = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
if (signCaching.TryGet(connection.Id, out SignCacheInfo from) == false || from.Super == false)
{
connection.Write(Helper.FalseArray);
return;
}
bool result = await sForwardServerNodeReportTransfer.ExitForward(nodeid).ConfigureAwait(false);
connection.Write(result ? Helper.TrueArray : Helper.FalseArray);
}
/// <summary>
/// 节点服务器
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.Exit)]
public async Task Exit(IConnection connection)
{
string masterKey = serializer.Deserialize<string>(connection.ReceiveRequestWrap.Payload.Span);
await sForwardServerNodeReportTransfer.Exit(masterKey).ConfigureAwait(false);
}
/// <summary>
/// 信标服务器收到来自节点的连接
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
[MessengerId((ushort)SForwardMessengerIds.ProxyForward)]
public async Task ProxyNode(IConnection connection)
{
SForwardProxyInfo info = serializer.Deserialize<SForwardProxyInfo>(connection.ReceiveRequestWrap.Payload.Span);
if (sForwardServerMasterTransfer.GetNode(info.NodeId, out var node) && string.IsNullOrWhiteSpace(info.MachineId) == false && signCaching.TryGet(info.MachineId, out SignCacheInfo sign) && sign.Connected)
var node = await sForwardServerNodeReportTransfer.GetNode(info.NodeId).ConfigureAwait(false);
if (node == null || string.IsNullOrWhiteSpace(info.MachineId) == false)
{
info.Addr = node.Address;
await sender.SendOnly(new MessageRequestWrap
{
Connection = sign.Connection,
MessengerId = (ushort)SForwardMessengerIds.Proxy,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
return;
}
if (signCaching.TryGet(info.MachineId, out SignCacheInfo sign) == false || sign.Connected == false)
{
return;
}
if (sForwardServerConnectionTransfer.TryGet(ConnectionSideType.Master, info.NodeId, out var nodeConnection) == false || nodeConnection.Connected == false)
{
return;
}
info.Addr = nodeConnection.Address.Address;
await sender.SendOnly(new MessageRequestWrap
{
Connection = sign.Connection,
MessengerId = (ushort)SForwardMessengerIds.Proxy,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
}
/// <summary>
/// 服务器收到http连接
/// 节点服务器收到http连接
/// </summary>
/// <param name="host"></param>
/// <param name="port"></param>
@@ -656,14 +741,14 @@ namespace linker.messenger.sforward.messenger
/// <returns></returns>
private async Task<string> WebConnect(string host, int port, ulong id)
{
if (sForwardServerCahing.TryGet(host, out string machineId) == false)
if (sForwardServerCahing.TryGet(host, out string machineId, out string nodeid) == false)
{
if (string.IsNullOrWhiteSpace(sForwardServerNodeTransfer.Node.Domain))
if (string.IsNullOrWhiteSpace(sForwardServerNodeReportTransfer.Config.Domain))
{
return "Node domain not found";
}
host = host.Substring(0, host.Length - sForwardServerNodeTransfer.Node.Domain.Length - 1);
if (sForwardServerCahing.TryGet(host, out machineId) == false)
host = host.Substring(0, host.Length - sForwardServerNodeReportTransfer.Config.Domain.Length - 1);
if (sForwardServerCahing.TryGet(host, out machineId, out nodeid) == false)
{
return "Host to machine not found";
}
@@ -676,47 +761,47 @@ namespace linker.messenger.sforward.messenger
RemotePort = port,
Id = id,
BufferSize = 3,
NodeId = sForwardServerNodeTransfer.Node.Id,
NodeId = nodeid,
ProtocolType = ProtocolType.Tcp,
MachineId = machineId,
});
return result ? string.Empty : "Proxy node fail";
}
/// <summary>
/// 服务器收到tcp连接
/// 节点服务器收到tcp连接
/// </summary>
/// <param name="port"></param>
/// <param name="id"></param>
/// <returns></returns>
private async Task<string> TunnelConnect(int port, ulong id)
{
sForwardServerCahing.TryGet(port, out string machineId);
sForwardServerCahing.TryGet(port, out string machineId, out string nodeid);
bool result = await sForwardServerNodeTransfer.ProxyNode(new SForwardProxyInfo
{
RemotePort = port,
Id = id,
BufferSize = 3,
NodeId = sForwardServerNodeTransfer.Node.Id,
NodeId = nodeid,
ProtocolType = ProtocolType.Tcp,
MachineId = machineId,
});
return result ? string.Empty : "Proxy node fail";
}
/// <summary>
/// 服务器收到udp数据
/// 节点服务器收到udp数据
/// </summary>
/// <param name="port"></param>
/// <param name="id"></param>
/// <returns></returns>
private async Task<bool> UdpConnect(int port, ulong id)
{
sForwardServerCahing.TryGet(port, out string machineId);
sForwardServerCahing.TryGet(port, out string machineId, out string nodeid);
return await sForwardServerNodeTransfer.ProxyNode(new SForwardProxyInfo
{
RemotePort = port,
Id = id,
BufferSize = 3,
NodeId = sForwardServerNodeTransfer.Node.Id,
NodeId = nodeid,
ProtocolType = ProtocolType.Udp,
MachineId = machineId
});
@@ -727,28 +812,33 @@ namespace linker.messenger.sforward.messenger
{
TimerHelper.SetIntervalLong(async () =>
{
var ids = sForwardServerCahing.GetMachineIds();
if (ids.Count > 0)
{
var offIds = await sForwardServerNodeTransfer.Heart(ids);
var dic = sForwardServerCahing.GetMachineIds();
if (dic.Count == 0) return;
if (sForwardServerCahing.TryGet(offIds, out List<string> domains, out List<int> ports))
foreach (var kv in dic)
{
if (kv.Value.Count == 0) continue;
var offIds = await sForwardServerNodeTransfer.Heart(kv.Value, kv.Key);
if (offIds.Count == 0 || sForwardServerCahing.TryGet(offIds, out List<string> domains, out List<int> ports) == false)
{
if (domains.Count != 0)
continue;
}
if (domains.Count != 0)
{
foreach (var domain in domains)
{
foreach (var domain in domains)
{
sForwardServerCahing.TryRemove(domain, out _);
proxy.RemoveHttp(domain);
}
sForwardServerCahing.TryRemove(domain, kv.Key, out _);
proxy.RemoveHttp(domain);
}
if (ports.Count != 0)
}
if (ports.Count != 0)
{
foreach (var port in ports)
{
foreach (var port in ports)
{
sForwardServerCahing.TryRemove(port, out _);
proxy.Stop(port);
}
sForwardServerCahing.TryRemove(port, kv.Key, out _);
proxy.Stop(port);
}
}
}
@@ -788,6 +878,7 @@ namespace linker.messenger.sforward.messenger
/// 添加
/// </summary>
/// <param name="connection"></param>
[MessengerId((ushort)SForwardMessengerIds.AddClient)]
public void AddClient(IConnection connection)
{
@@ -795,13 +886,6 @@ namespace linker.messenger.sforward.messenger
sForwardTransfer.Add(sForwardInfo);
connection.Write(Helper.TrueArray);
}
[MessengerId((ushort)SForwardMessengerIds.AddClient191)]
public void AddClient191(IConnection connection)
{
SForwardInfo sForwardInfo = serializer.Deserialize<SForwardInfo>(connection.ReceiveRequestWrap.Payload.Span);
sForwardTransfer.Add(sForwardInfo);
connection.Write(Helper.TrueArray);
}
// <summary>
/// 删除
/// </summary>

52
src/linker.messenger.sforward/messenger/SForwardMessengerIds.cs
View File

@@ -4,10 +4,6 @@
{
Min = 2300,
Add = 2301,
Remove = 2302,
Proxy = 2303,
GetForward = 2305,
Get = 2306,
@@ -19,40 +15,40 @@
TestClient = 2311,
TestClientForward = 2312,
StartClient = 2313,
StartClientForward = 2314,
StopClient = 2315,
StopClientForward = 2316,
Add191 = 2317,
Remove191 = 2318,
AddClient191 = 2319,
AddClientForward191 = 2320,
NodeReport = 2321,
Exit = 2322,
ExitForward = 2323,
Edit = 2324,
EditForward = 2325,
Update = 2326,
UpdateForward = 2327,
Nodes = 2328,
AddForward191 = 2329,
RemoveForward191 = 2330,
TrafficReport = 2331,
SendLastBytes = 2332,
ProxyNode = 2333,
Heart = 2334,
Hosts = 2335,
SignIn = 2336,
Report = 2337,
Share = 2338,
ShareForward = 2339,
Import = 2340,
Remove = 2341,
UpdateForward = 2342,
Update = 2343,
ExitForward = 2344,
Exit = 2345,
UpgradeForward = 2346,
Upgrade = 2347,
Start = 2348,
StartForward = 2349,
Stop = 2350,
StopForward = 2351,
Proxy = 2352,
ProxyForward = 2353,
Max = 2399
}

8
src/linker.messenger.sforward/proxy/SForwardProxyTcp.cs
View File

@@ -136,7 +136,7 @@ namespace linker.plugins.sforward.proxy
key = token.Host = GetHost(buffer1.Memory.Slice(0, length));
if (string.IsNullOrWhiteSpace(token.Host))
{
if (Write404(token, buffer1.Memory,"Http host not found"))
if (Write404(token, buffer1.Memory, "Http host not found"))
{
return;
}
@@ -215,7 +215,7 @@ namespace linker.plugins.sforward.proxy
}
}
private bool Write404(AsyncUserToken token, Memory<byte> buffer,string error)
private bool Write404(AsyncUserToken token, Memory<byte> buffer, string error)
{
try
{
@@ -248,7 +248,7 @@ namespace linker.plugins.sforward.proxy
{
if (host.Contains('.') == false)
{
host = $"{host}.{sForwardServerNodeTransfer.Node.Domain}";
host = $"{host}.{sForwardServerNodeTransfer.Config.Domain}";
}
SForwardTrafficCacheInfo sForwardTrafficCacheInfo = sForwardServerNodeTransfer.AddTrafficCache(super, bandwidth);
@@ -258,7 +258,7 @@ namespace linker.plugins.sforward.proxy
{
if (host.Contains('.') == false)
{
host = $"{host}.{sForwardServerNodeTransfer.Node.Domain}";
host = $"{host}.{sForwardServerNodeTransfer.Config.Domain}";
}
if (httpCaches.TryRemove(host, out var cache))
{

77
src/linker.messenger.sforward/server/ISForwardServerCahing.cs
View File

@@ -5,19 +5,23 @@ namespace linker.messenger.sforward.server
{
public interface ISForwardServerCahing
{
public bool TryAdd(string domain, string machineId);
public bool TryAdd(int port, string machineId);
public bool TryAdd(string domain, string machineId, string masterNodeId);
public bool TryAdd(int port, string machineId, string masterNodeId);
public bool TryGet(string domain, out string machineId);
public bool TryGet(int port, out string machineId);
public bool TryGet(string domain, out string machineId, out string masterNodeId);
public bool TryGet(int port, out string machineId, out string masterNodeId);
public bool TryGet(List<string> ids, out List<string> domains, out List<int> ports);
public bool TryRemove(string domain, string operMachineId, out string machineId);
public bool TryRemove(string domain, out string machineId);
public bool TryRemove(int port, string operMachineId, out string machineId);
public bool TryRemove(int port, out string machineId);
public bool TryRemove(string domain, string operMachineId, string masterNodeId, out string machineId);
public bool TryRemove(string domain, string masterNodeId, out string machineId);
public bool TryRemove(int port, string operMachineId, string masterNodeId, out string machineId);
public bool TryRemove(int port, string masterNodeId, out string machineId);
public List<string> GetMachineIds();
/// <summary>
/// 信标服务器id，客户端id列表
/// </summary>
/// <returns></returns>
public Dictionary<string, List<string>> GetMachineIds();
}
/// <summary>
@@ -34,7 +38,7 @@ namespace linker.messenger.sforward.server
this.signCaching = signCaching;
}
public bool TryAdd(string domain, string machineId)
public bool TryAdd(string domain, string machineId, string masterNodeId)
{
if (serverDoamins.TryGetValue(domain, out CacheInfo cache) && machineId == cache.MachineId)
{
@@ -45,10 +49,10 @@ namespace linker.messenger.sforward.server
serverDoamins.TryRemove(domain, out _);
}
return serverDoamins.TryAdd(domain, new CacheInfo { MachineId = machineId });
return serverDoamins.TryAdd(domain, new CacheInfo { MachineId = machineId, MasterNodeId = masterNodeId });
}
public bool TryAdd(int port, string machineId)
public bool TryAdd(int port, string machineId, string masterNodeId)
{
if (serverPorts.TryGetValue(port, out CacheInfo cache) && machineId == cache.MachineId)
{
@@ -59,26 +63,30 @@ namespace linker.messenger.sforward.server
serverPorts.TryRemove(port, out _);
}
return serverPorts.TryAdd(port, new CacheInfo { MachineId = machineId });
return serverPorts.TryAdd(port, new CacheInfo { MachineId = machineId, MasterNodeId = masterNodeId });
}
public bool TryGet(string domain, out string machineId)
public bool TryGet(string domain, out string machineId, out string masterNodeId)
{
machineId = string.Empty;
masterNodeId = string.Empty;
if (serverDoamins.TryGetValue(domain, out CacheInfo cache))
{
machineId = cache.MachineId;
masterNodeId = cache.MasterNodeId;
return true;
}
return false;
}
public bool TryGet(int port, out string machineId)
public bool TryGet(int port, out string machineId, out string masterNodeId)
{
machineId = string.Empty;
masterNodeId = string.Empty;
if (serverPorts.TryGetValue(port, out CacheInfo cache))
{
machineId = cache.MachineId;
masterNodeId = cache.MasterNodeId;
return true;
}
return false;
@@ -90,10 +98,10 @@ namespace linker.messenger.sforward.server
return domains.Count > 0 || ports.Count > 0;
}
public bool TryRemove(string domain, string operMachineId, out string machineId)
public bool TryRemove(string domain, string operMachineId, string masterNodeId, out string machineId)
{
machineId = string.Empty;
if (serverDoamins.TryGetValue(domain, out CacheInfo cache) && cache.MachineId == operMachineId)
if (serverDoamins.TryGetValue(domain, out CacheInfo cache) && cache.MachineId == operMachineId && cache.MasterNodeId == masterNodeId)
{
if (serverDoamins.TryRemove(domain, out CacheInfo cache1))
{
@@ -103,21 +111,25 @@ namespace linker.messenger.sforward.server
}
return false;
}
public bool TryRemove(string domain, out string machineId)
public bool TryRemove(string domain, string masterNodeId, out string machineId)
{
machineId = string.Empty;
if (serverDoamins.TryRemove(domain, out CacheInfo cache))
if (serverDoamins.TryGetValue(domain, out CacheInfo cache) && cache.MasterNodeId == masterNodeId)
{
machineId = cache.MachineId;
return true;
if (serverDoamins.TryRemove(domain, out _))
{
machineId = cache.MachineId;
return true;
}
}
return false;
}
public bool TryRemove(int port, string operMachineId, out string machineId)
public bool TryRemove(int port, string operMachineId, string masterNodeId, out string machineId)
{
machineId = string.Empty;
if (serverPorts.TryGetValue(port, out CacheInfo cache) && cache.MachineId == operMachineId)
if (serverPorts.TryGetValue(port, out CacheInfo cache) && cache.MachineId == operMachineId && cache.MasterNodeId == masterNodeId)
{
if (serverPorts.TryRemove(port, out CacheInfo cache1))
{
@@ -127,25 +139,32 @@ namespace linker.messenger.sforward.server
}
return false;
}
public bool TryRemove(int port, out string machineId)
public bool TryRemove(int port, string masterNodeId, out string machineId)
{
machineId = string.Empty;
if (serverPorts.TryRemove(port, out CacheInfo cache1))
if (serverPorts.TryGetValue(port, out CacheInfo cache) && cache.MasterNodeId == masterNodeId)
{
machineId = cache1.MachineId;
return true;
if (serverPorts.TryRemove(port, out _))
{
machineId = cache.MachineId;
return true;
}
}
return false;
}
public List<string> GetMachineIds()
public Dictionary<string, List<string>> GetMachineIds()
{
return serverDoamins.Values.Select(c => c.MachineId).Union(serverPorts.Values.Select(c => c.MachineId)).Distinct().ToList();
return serverDoamins.Values.Select(c => (c.MasterNodeId, c.MachineId))
.Union(serverPorts.Values.Select(c => (c.MasterNodeId, c.MachineId))).Distinct()
.GroupBy(c => c.MasterNodeId).ToDictionary(c => c.Key, d => d.Select(c => c.MachineId).ToList());
}
sealed class CacheInfo
{
public string MachineId { get; set; }
public string MasterNodeId { get; set; }
public long LastTime { get; set; } = Environment.TickCount64;
}
}

167
src/linker.messenger.sforward/server/ISForwardServerConfigStore.cs Normal file
View File

@@ -0,0 +1,167 @@
using linker.libs.extends;
using System.Net;
using System.Text.Json.Serialization;
namespace linker.messenger.sforward.server
{
public interface ISForwardServerConfigStore
{
public int ServicePort { get; }
/// <summary>
/// 节点信息
/// </summary>
public SForwardServerConfigInfo Config { get; }
/// <summary>
/// 设置
/// </summary>
/// <param name="config"></param>
public void SetInfo(SForwardServerConfigInfo config);
/// <summary>
/// 设置月份
/// </summary>
/// <param name="month"></param>
public void SetDataMonth(int month);
/// <summary>
/// 设置剩余流量
/// </summary>
/// <param name="value"></param>
public void SetDataRemain(long value);
public void SetShareKey(string shareKey);
public void SetMasterKey(string masterKey);
/// <summary>
/// 提交保存
/// </summary>
public void Confirm();
}
public class SForwardServerNodeInfo
{
private string nodeId = Guid.NewGuid().ToString().ToUpper();
public string NodeId { get => nodeId; set { nodeId = value.SubStr(0, 36); } }
private string name = "default";
public string Name { get => name; set { name = value.SubStr(0, 32); } }
public string Domain { get; set; } = string.Empty;
public int WebPort { get; set; }
public string TunnelPorts { get; set; } = "1024-65535";
public int Connections { get; set; }
public int Bandwidth { get; set; }
public int DataEachMonth { get; set; }
public long DataRemain { get; set; }
public string Url { get; set; } = "https://linker.snltty.com";
public string Logo { get; set; } = "https://linker.snltty.com/img/logo.png";
}
public sealed class SForwardServerConfigInfo : SForwardServerNodeInfo
{
[SaveJsonIgnore]
public DistributedInfoOld Distributed { get; set; } = new DistributedInfoOld { };
public string ShareKey { get; set; } = string.Empty;
public string MasterKey { get; set; } = string.Empty;
public int DataMonth { get; set; }
public string Host { get; set; } = string.Empty;
}
public class SForwardServerNodeReportInfo : SForwardServerNodeInfo
{
public string MasterKey { get; set; } = string.Empty;
public string Version { get; set; } = string.Empty;
public int ConnectionsRatio { get; set; }
public double BandwidthRatio { get; set; }
public IPEndPoint[] Masters { get; set; } = Array.Empty<IPEndPoint>();
public string Host { get; set; } = string.Empty;
}
public sealed class SForwardServerNodeStoreInfo : SForwardServerNodeReportInfo
{
public int Id { get; set; }
public int BandwidthEach { get; set; } = 50;
public bool Public { get; set; }
public long LastTicks { get; set; }
public int Delay { get; set; }
public bool Manageable { get; set; }
public string ShareKey { get; set; } = string.Empty;
}
public class SForwardServerNodeShareInfo
{
public string NodeId { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string SystemId { get; set; } = string.Empty;
}
public sealed class DistributedInfoOld
{
public SForwardServerNodeInfoOld Node { get; set; } = new SForwardServerNodeInfoOld { };
}
public sealed class SForwardServerNodeInfoOld
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string Domain { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public int MaxGbTotalMonth { get; set; }
public string Url { get; set; } = "https://linker-doc.snltty.com";
}
public partial class SForwardServerNodeReportInfoOld
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public double BandwidthRatio { get; set; }
public bool Public { get; set; }
public int Delay { get; set; }
public string Domain { get; set; }
public IPAddress Address { get; set; }
public long LastTicks { get; set; }
public string Url { get; set; } = "https://linker-doc.snltty.com";
[JsonIgnore]
public IConnection Connection { get; set; }
public string Version { get; set; } = string.Empty;
public bool Sync2Server { get; set; }
public int WebPort { get; set; }
public int[] PortRange { get; set; } = [1025, 65535];
}
}

37
src/linker.messenger.sforward/server/ISForwardServerMasterStore.cs
View File

@@ -1,37 +0,0 @@
using linker.libs;
namespace linker.messenger.sforward.server
{
/// <summary>
/// 穿透主机存储器
/// </summary>
public interface ISForwardServerMasterStore
{
/// <summary>
/// 主服务器信息
/// </summary>
public SForwardServerMasterInfo Master { get; }
/// <summary>
/// 设置
/// </summary>
/// <param name="info"></param>
public void SetInfo(SForwardServerMasterInfo info);
/// <summary>
/// 提交
/// </summary>
/// <returns></returns>
public bool Confirm();
}
public sealed class SForwardServerMasterInfo
{
#if DEBUG
public string SecretKey { get; set; } = Helper.GlobalString;
#else
public string SecretKey { get; set; } = Guid.NewGuid().ToString().ToUpper();
#endif
}
}

142
src/linker.messenger.sforward/server/ISForwardServerNodeStore.cs
View File

@@ -1,140 +1,12 @@
using linker.libs;
using System.Net;
using linker.libs.extends;
using System.Text.Json.Serialization;
namespace linker.messenger.sforward.server
namespace linker.messenger.sforward.server
{
/// <summary>
/// 穿透节点存储器
/// </summary>
public interface ISForwardServerNodeStore
{
/// <summary>
/// 节点信息
/// </summary>
public SForwardServerNodeInfo Node { get; }
public int ServicePort { get; }
/// <summary>
/// 设置
/// </summary>
/// <param name="node"></param>
public void SetInfo(SForwardServerNodeInfo node);
public void UpdateInfo(SForwardServerNodeUpdateInfo update);
public void SetMasterHosts(string[] hosts);
/// <summary>
/// 设置月份
/// </summary>
/// <param name="month"></param>
public void SetMaxGbTotalMonth(int month);
/// <summary>
/// 设置剩余流量
/// </summary>
/// <param name="value"></param>
public void SetMaxGbTotalLastBytes(long value);
/// <summary>
/// <summary>
/// 提交保存
/// </summary>
public void Confirm();
}
public sealed class SForwardServerNodeInfo
{
private string id = Guid.NewGuid().ToString().ToUpper();
public string Id
{
get => id; set
{
id = value.SubStr(0, 36);
}
}
private string name = Dns.GetHostName().SubStr(0, 32);
public string Name
{
get => name; set
{
name = value.SubStr(0, 32);
}
}
public string Domain { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public int MaxGbTotalMonth { get; set; }
public bool Public { get; set; }
public string MasterHost { get; set; } = string.Empty;
#if DEBUG
public string MasterSecretKey { get; set; } = Helper.GlobalString;
#else
public string MasterSecretKey { get; set; } = string.Empty;
#endif
public string Url { get; set; } = "https://linker-doc.snltty.com";
public bool Sync2Server { get; set; }
public string[] MasterHosts { get; set; } = [];
}
public partial class SForwardServerNodeUpdateWrapInfo
{
public SForwardServerNodeUpdateInfo Info { get; set; }
}
public partial class SForwardServerNodeUpdateInfo
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public bool Public { get; set; }
public string Domain { get; set; } = string.Empty;
public string Host { get; set; } = string.Empty;
public string Url { get; set; } = "https://linker-doc.snltty.com";
public bool Sync2Server { get; set; } = false;
public int WebPort { get; set; }
public int[] PortRange { get; set; } = [1025, 65535];
}
public partial class SForwardServerNodeReportInfo
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public double BandwidthRatio { get; set; }
public bool Public { get; set; }
public int Delay { get; set; }
public string Domain { get; set; }
public IPAddress Address { get; set; }
public long LastTicks { get; set; }
public string Url { get; set; } = "https://linker-doc.snltty.com";
[JsonIgnore]
public IConnection Connection { get; set; }
public string Version { get; set; } = string.Empty;
public bool Sync2Server { get; set; }
public int WebPort { get; set; }
public int[] PortRange { get; set; } = [1025, 65535];
public Task<List<SForwardServerNodeStoreInfo>> GetAll();
public Task<SForwardServerNodeStoreInfo> GetByNodeId(string nodeId);
public Task<bool> Add(SForwardServerNodeStoreInfo info);
public Task<bool> Report(SForwardServerNodeReportInfo info);
public Task<bool> Delete(string nodeId);
public Task<bool> Update(SForwardServerNodeStoreInfo info);
}
}

32
src/linker.messenger.sforward/server/ISForwardServerStore.cs
View File

@@ -1,32 +0,0 @@
namespace linker.messenger.sforward.server
{
public interface ISForwardServerStore
{
/// <summary>
/// web端口
/// </summary>
public int WebPort { get; }
/// <summary>
/// 端口隧道范围
/// </summary>
public int[] TunnelPortRange { get; }
/// <summary>
/// web端口
/// </summary>
/// <param name="port"></param>
/// <returns></returns>
public bool SetWebPort(int port);
/// <summary>
/// 端口隧道范围
/// </summary>
/// <param name="ports"></param>
/// <returns></returns>
public bool SetTunnelPortRange(int[] ports);
/// <summary>
/// 提交保存
/// </summary>
/// <returns></returns>
public bool Confirm();
}
}

44
src/linker.messenger.sforward/server/SForwardServerConnectionResolver.cs Normal file
View File

@@ -0,0 +1,44 @@
using linker.libs;
using linker.libs.extends;
using System.Net;
using System.Net.Sockets;
namespace linker.messenger.sforward.server
{
public class SForwardServerConnectionResolver : IResolver
{
public byte Type => (byte)ResolverType.SForwardConnection;
private readonly IMessengerResolver messengerResolver;
public SForwardServerConnectionResolver(IMessengerResolver messengerResolver)
{
this.messengerResolver = messengerResolver;
}
public virtual void Add(long receiveBytes, long sendtBytes)
{
}
public async Task Resolve(Socket socket, Memory<byte> memory)
{
try
{
await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray).ConfigureAwait(false);
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error(ex);
}
socket.SafeClose();
}
}
public async Task Resolve(Socket socket, IPEndPoint ep, Memory<byte> memory)
{
await Task.CompletedTask.ConfigureAwait(false);
}
}
}

41
src/linker.messenger.sforward/server/SForwardServerConnectionTransfer.cs Normal file
View File

@@ -0,0 +1,41 @@
using System.Collections.Concurrent;
namespace linker.messenger.sforward.server
{
public sealed class SForwardServerConnectionTransfer
{
private readonly ConcurrentDictionary<string, IConnection>[] connections = [
new ConcurrentDictionary<string, IConnection>()
,new ConcurrentDictionary<string, IConnection>()
];
public SForwardServerConnectionTransfer()
{
}
public List<IConnection> Get(ConnectionSideType type)
{
return connections[(byte)type].Values.Where(c => c.Connected).ToList();
}
public bool TryGet(ConnectionSideType type, string id, out IConnection connection)
{
return connections[(byte)type].TryGetValue(id, out connection);
}
public bool TryAdd(ConnectionSideType type, string id, IConnection connection)
{
if (connections[(byte)type].TryRemove(id, out IConnection _connection) && _connection.GetHashCode() != connection.GetHashCode())
{
_connection.Disponse();
}
return connections[(byte)type].TryAdd(id, connection);
}
}
public enum ConnectionSideType : byte
{
Node = 0,
Master = 1
}
}

130
src/linker.messenger.sforward/server/SForwardServerMasterTransfer.cs
View File

@@ -1,8 +1,6 @@
using linker.libs;
using linker.messenger.sforward.messenger;
using linker.messenger.signin;
using System.Collections.Concurrent;
using System.Net;
namespace linker.messenger.sforward.server
{
@@ -11,96 +9,37 @@ namespace linker.messenger.sforward.server
/// </summary>
public class SForwardServerMasterTransfer
{
private readonly ConcurrentDictionary<string, SForwardServerNodeReportInfo> reports = new ConcurrentDictionary<string, SForwardServerNodeReportInfo>();
private readonly ISerializer serializer;
private readonly IMessengerSender messengerSender;
private readonly ISForwardServerWhiteListStore sForwardServerWhiteListStore;
private readonly ISForwardServerNodeStore sForwardServerNodeStore;
private readonly SForwardServerConnectionTransfer sForwardServerConnectionTransfer;
private readonly SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer;
public SForwardServerMasterTransfer(ISerializer serializer, IMessengerSender messengerSender, ISForwardServerWhiteListStore sForwardServerWhiteListStore,
ISForwardServerNodeStore sForwardServerNodeStore)
ISForwardServerNodeStore sForwardServerNodeStore, SForwardServerConnectionTransfer sForwardServerConnectionTransfer, SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer)
{
this.serializer = serializer;
this.messengerSender = messengerSender;
this.sForwardServerWhiteListStore = sForwardServerWhiteListStore;
this.sForwardServerNodeStore = sForwardServerNodeStore;
this.sForwardServerConnectionTransfer = sForwardServerConnectionTransfer;
this.sForwardServerNodeReportTransfer = sForwardServerNodeReportTransfer;
}
public void SetNodeReport(IConnection connection, SForwardServerNodeReportInfo info)
{
try
{
if (info.Address.Equals(IPAddress.Any))
{
info.Address = connection.Address.Address;
}
if (info.Address.Equals(IPAddress.Loopback))
{
info.Address = IPAddress.Any;
}
info.LastTicks = Environment.TickCount64;
info.Connection = connection;
reports.AddOrUpdate(info.Id, info, (a, b) => info);
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error(ex);
}
}
}
public async Task Edit(SForwardServerNodeUpdateInfo info)
{
if (reports.TryGetValue(info.Id, out SForwardServerNodeReportInfo cache))
{
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = cache.Connection,
MessengerId = (ushort)SForwardMessengerIds.Edit,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
}
}
public async Task Exit(string id)
{
if (reports.TryGetValue(id, out SForwardServerNodeReportInfo cache))
{
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = cache.Connection,
MessengerId = (ushort)SForwardMessengerIds.Exit,
}).ConfigureAwait(false);
}
}
public async Task Update(string id, string version)
{
if (reports.TryGetValue(id, out SForwardServerNodeReportInfo cache))
{
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = cache.Connection,
MessengerId = (ushort)SForwardMessengerIds.Update,
Payload = serializer.Serialize(version)
}).ConfigureAwait(false);
}
}
public async Task<SForwardAddResultInfo> Add(SForwardAddInfo info, SignCacheInfo from)
public async Task<SForwardAddResultInfo> Start(SForwardAddInfo info, SignCacheInfo from)
{
if (string.IsNullOrWhiteSpace(info.NodeId))
{
var nodes = await GetNodes(from.Super, from.UserId, from.MachineId);
var nodes = await sForwardServerNodeReportTransfer.GetNodes(from.Super, from.UserId, from.MachineId);
if (nodes.Count > 0)
{
info.NodeId = nodes[0].Id;
info.NodeId = nodes[0].NodeId;
}
}
if (GetNode(info.NodeId, out var node) == false)
var node = await sForwardServerNodeReportTransfer.GetNode(info.NodeId).ConfigureAwait(false);
if (node == null)
{
return new SForwardAddResultInfo
{
@@ -127,15 +66,16 @@ namespace linker.messenger.sforward.server
info.Bandwidth = bandwidth.Count > 0
? bandwidth.Any(c => c.Bandwidth == 0) ? 0 : bandwidth.Max(c => c.Bandwidth)
: info.Super ? 0 : node.MaxBandwidth;
: info.Super ? 0 : node.Bandwidth;
if (reports.TryGetValue(info.NodeId, out SForwardServerNodeReportInfo cache))
if (sForwardServerConnectionTransfer.TryGet(ConnectionSideType.Master, info.NodeId, out var connection))
{
info.NodeId = sForwardServerNodeReportTransfer.Config.NodeId;
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = cache.Connection,
MessengerId = (ushort)SForwardMessengerIds.Add191,
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Start,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK)
@@ -150,16 +90,15 @@ namespace linker.messenger.sforward.server
Success = false
};
}
public async Task<SForwardAddResultInfo> Remove(SForwardAddInfo info)
public async Task<SForwardAddResultInfo> Stop(SForwardAddInfo info)
{
if (string.IsNullOrWhiteSpace(info.NodeId)) info.NodeId = sForwardServerNodeStore.Node.Id;
if (reports.TryGetValue(info.NodeId, out SForwardServerNodeReportInfo cache))
if (sForwardServerConnectionTransfer.TryGet(ConnectionSideType.Master, info.NodeId, out var connection))
{
info.NodeId = sForwardServerNodeReportTransfer.Config.NodeId;
MessageResponeInfo resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = cache.Connection,
MessengerId = (ushort)SForwardMessengerIds.Remove191,
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Stop,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK)
@@ -176,33 +115,6 @@ namespace linker.messenger.sforward.server
}
/// <summary>
/// 获取节点列表
/// </summary>
/// <param name="super">是否已认证</param>
/// <returns></returns>
public async Task<List<SForwardServerNodeReportInfo>> GetNodes(bool super, string userid, string machineId)
{
List<string> sforward = (await sForwardServerWhiteListStore.GetNodes(userid, machineId)).Where(c => c.Bandwidth >= 0).SelectMany(c => c.Nodes).ToList();
var result = reports.Values
.Where(c => Environment.TickCount64 - c.LastTicks < 15000)
.Where(c =>
{
return super || c.Public || sforward.Contains(c.Id) || sforward.Contains("*");
})
.OrderByDescending(c => c.LastTicks);
return result.ThenBy(x => x.BandwidthRatio)
.ThenByDescending(x => x.MaxBandwidth == 0 ? double.MaxValue : x.MaxBandwidth)
.ThenByDescending(x => x.MaxBandwidthTotal == 0 ? double.MaxValue : x.MaxBandwidthTotal)
.ThenByDescending(x => x.MaxGbTotal == 0 ? double.MaxValue : x.MaxGbTotal)
.ThenByDescending(x => x.MaxGbTotalLastBytes == 0 ? long.MaxValue : x.MaxGbTotalLastBytes).ToList();
}
public bool GetNode(string id, out SForwardServerNodeReportInfo node)
{
return reports.TryGetValue(id, out node) && node != null && Environment.TickCount64 - node.LastTicks < 15000;
}
}
}

420
src/linker.messenger.sforward/server/SForwardServerNodeReportTransfer.cs Normal file
View File

@@ -0,0 +1,420 @@
using linker.libs;
using linker.libs.extends;
using linker.libs.timer;
using linker.messenger.sforward.messenger;
using System.Net;
using System.Net.Sockets;
namespace linker.messenger.sforward.server
{
public sealed class SForwardServerNodeReportTransfer
{
public SForwardServerConfigInfo Config => SForwardServerConfigStore.Config;
private int connectionNum = 0;
private ulong bytes = 0;
private ulong lastBytes = 0;
private string md5 = string.Empty;
private readonly ICrypto crypto = CryptoFactory.CreateSymmetric(Helper.GlobalString);
public int ConnectionNum => connectionNum;
private readonly SForwardServerConnectionTransfer SForwardServerConnectionTransfer;
private readonly ISForwardServerConfigStore SForwardServerConfigStore;
private readonly ISerializer serializer;
private readonly IMessengerSender messengerSender;
private readonly ISForwardServerNodeStore sForwardServerNodeStore;
private readonly ISForwardServerWhiteListStore sForwardServerWhiteListStore;
private readonly IMessengerResolver messengerResolver;
public SForwardServerNodeReportTransfer(SForwardServerConnectionTransfer SForwardServerConnectionTransfer, ISForwardServerConfigStore SForwardServerConfigStore,
ISerializer serializer, IMessengerSender messengerSender, ISForwardServerNodeStore sForwardServerNodeStore, ISForwardServerWhiteListStore sForwardServerWhiteListStore, IMessengerResolver messengerResolver)
{
this.SForwardServerConnectionTransfer = SForwardServerConnectionTransfer;
this.SForwardServerConfigStore = SForwardServerConfigStore;
this.serializer = serializer;
this.messengerSender = messengerSender;
this.sForwardServerNodeStore = sForwardServerNodeStore;
this.sForwardServerWhiteListStore = sForwardServerWhiteListStore;
this.messengerResolver = messengerResolver;
md5 = Config.NodeId.Md5();
_ = ReportTask();
SignInTask();
}
public void IncrementConnectionNum()
{
Interlocked.Increment(ref connectionNum);
}
public void DecrementConnectionNum()
{
Interlocked.Decrement(ref connectionNum);
}
public void AddBytes(long length)
{
Interlocked.Add(ref bytes, (ulong)length);
}
public async Task<bool> Report(string id, string name, string host)
{
return await sForwardServerNodeStore.Add(new SForwardServerNodeStoreInfo
{
NodeId = id,
Name = name,
Host = host
}).ConfigureAwait(false);
}
public async Task<bool> Report(SForwardServerNodeReportInfo info)
{
if (SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, info.NodeId, out _) == false) return false;
return await sForwardServerNodeStore.Report(info).ConfigureAwait(false);
}
public async Task<bool> SignIn(string serverId, string shareKey, IConnection connection)
{
//未被配置，或默认配置的，设它为管理端
if (string.IsNullOrWhiteSpace(Config.MasterKey) || md5 == Config.MasterKey)
{
SForwardServerConfigStore.SetMasterKey(serverId.Md5());
SForwardServerConfigStore.Confirm();
}
if (shareKey != Config.ShareKey && serverId.Md5() != Config.MasterKey)
{
return false;
}
connection.Id = serverId;
SForwardServerConnectionTransfer.TryAdd(ConnectionSideType.Master, connection.Id, connection);
return true;
}
public async Task<string> GetShareKeyForward(string nodeId)
{
SForwardServerNodeStoreInfo store = await sForwardServerNodeStore.GetByNodeId(nodeId);
if (store != null && store.Manageable && SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, nodeId, out var connection))
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Share,
Payload = serializer.Serialize(store.MasterKey)
});
if (resp.Code == MessageResponeCodes.OK)
{
return serializer.Deserialize<string>(resp.Data.Span);
}
}
return string.Empty;
}
public async Task<string> GetShareKey(string masterKey)
{
if (masterKey != Config.MasterKey) return string.Empty;
return Config.ShareKey;
}
public async Task<string> Import(string shareKey)
{
try
{
SForwardServerNodeShareInfo info = serializer.Deserialize<SForwardServerNodeShareInfo>(crypto.Decode(Convert.FromBase64String(shareKey)).Span);
bool result = await sForwardServerNodeStore.Add(new SForwardServerNodeStoreInfo
{
NodeId = info.NodeId,
Host = info.Host,
Name = info.Name,
LastTicks = Environment.TickCount64,
ShareKey = shareKey
}).ConfigureAwait(false);
if (result == false)
{
return "node already exists";
}
}
catch (Exception ex)
{
return ex.Message;
}
return string.Empty;
}
public async Task<bool> Remove(string nodeId)
{
if (nodeId == Config.NodeId) return false;
return await sForwardServerNodeStore.Delete(nodeId).ConfigureAwait(false);
}
public async Task<bool> UpdateForward(SForwardServerNodeStoreInfo info)
{
SForwardServerNodeStoreInfo store = await sForwardServerNodeStore.GetByNodeId(info.NodeId);
if (store != null && store.Manageable && SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, info.NodeId, out var connection))
{
info.MasterKey = store.MasterKey;
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Update,
Payload = serializer.Serialize(info)
});
}
return await sForwardServerNodeStore.Update(info).ConfigureAwait(false);
}
public async Task<bool> Update(SForwardServerNodeStoreInfo info)
{
if (info.MasterKey != Config.MasterKey) return false;
Config.Connections = info.Connections;
Config.MasterKey = info.MasterKey;
Config.Bandwidth = info.Bandwidth;
Config.DataEachMonth = info.DataEachMonth;
Config.DataRemain = info.DataRemain;
Config.Logo = info.Logo;
Config.Name = info.Name;
Config.Url = info.Url;
Config.Host = info.Host;
SForwardServerConfigStore.Confirm();
return true;
}
public async Task<bool> UpgradeForward(string nodeId, string version)
{
SForwardServerNodeStoreInfo store = await sForwardServerNodeStore.GetByNodeId(nodeId);
if (store != null && store.Manageable && SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, nodeId, out var connection))
{
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Update,
Payload = serializer.Serialize(new KeyValuePair<string, string>(store.MasterKey, version))
});
return true;
}
return false;
}
public async Task<bool> Upgrade(string masterKey, string version)
{
if (masterKey != Config.MasterKey) return false;
Helper.AppUpdate(version);
return true;
}
public async Task<bool> ExitForward(string nodeId)
{
SForwardServerNodeStoreInfo store = await sForwardServerNodeStore.GetByNodeId(nodeId);
if (store != null && store.Manageable && SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, nodeId, out var connection))
{
await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Update,
Payload = serializer.Serialize(new KeyValuePair<string, string>(store.MasterKey, nodeId))
});
return true;
}
return false;
}
public async Task<bool> Exit(string masterKey)
{
if (masterKey != Config.MasterKey) return false;
Helper.AppExit(-1);
return true;
}
/// <summary>
/// 获取节点列表
/// </summary>
/// <param name="super">是否已认证</param>
/// <returns></returns>
public async Task<List<SForwardServerNodeStoreInfo>> GetNodes(bool super, string userid, string machineId)
{
List<string> sforward = (await sForwardServerWhiteListStore.GetNodes(userid, machineId)).Where(c => c.Bandwidth >= 0).SelectMany(c => c.Nodes).ToList();
var result = (await sForwardServerNodeStore.GetAll())
.Where(c => Environment.TickCount64 - c.LastTicks < 15000)
.Where(c =>
{
return super || c.Public || sforward.Contains(c.NodeId) || sforward.Contains("*");
})
.OrderByDescending(c => c.LastTicks);
return result.ThenBy(x => x.BandwidthRatio)
.ThenByDescending(x => x.BandwidthEach == 0 ? double.MaxValue : x.BandwidthEach)
.ThenByDescending(x => x.Bandwidth == 0 ? double.MaxValue : x.Bandwidth)
.ThenByDescending(x => x.DataEachMonth == 0 ? double.MaxValue : x.DataEachMonth)
.ThenByDescending(x => x.DataRemain == 0 ? long.MaxValue : x.DataRemain).ToList();
}
public async Task<SForwardServerNodeStoreInfo> GetNode(string nodeId)
{
SForwardServerNodeStoreInfo node = await sForwardServerNodeStore.GetByNodeId(nodeId).ConfigureAwait(false);
if (node == null || Environment.TickCount64 - node.LastTicks < 15000)
{
return null;
}
return null;
}
private async Task BuildShareKey()
{
try
{
string host = Config.Host;
if (string.IsNullOrWhiteSpace(host))
{
using HttpClient httpClient = new HttpClient();
host = await httpClient.GetStringAsync($"https://ifconfig.me/ip").WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
}
SForwardServerNodeShareInfo shareKeyInfo = new SForwardServerNodeShareInfo
{
NodeId = Config.NodeId,
Host = $"{host}:{SForwardServerConfigStore.ServicePort}",
Name = Config.Name,
SystemId = SystemIdHelper.GetSystemId().Md5()
};
string shareKey = Convert.ToBase64String(crypto.Encode(serializer.Serialize(shareKeyInfo)));
SForwardServerConfigStore.SetShareKey(shareKey);
SForwardServerConfigStore.Confirm();
host = $"{IPAddress.Loopback}:{SForwardServerConfigStore.ServicePort}";
var node = await sForwardServerNodeStore.GetByNodeId(SForwardServerConfigStore.Config.NodeId);
if (node == null || node.ShareKey != shareKey || node.Name != Config.Name || node.Host != host)
{
await sForwardServerNodeStore.Delete(SForwardServerConfigStore.Config.NodeId);
await sForwardServerNodeStore.Add(new SForwardServerNodeStoreInfo
{
NodeId = SForwardServerConfigStore.Config.NodeId,
Name = "default",
Host = $"{IPAddress.Loopback}:{SForwardServerConfigStore.ServicePort}",
ShareKey = shareKey
}).ConfigureAwait(false);
}
LoggerHelper.Instance.Warning($"build SForward share key : {shareKey}");
}
catch (Exception ex)
{
LoggerHelper.Instance.Error($"build SForward share key error : {ex}");
}
}
private async Task ReportTask()
{
await BuildShareKey().ConfigureAwait(false);
TimerHelper.SetIntervalLong(async () =>
{
try
{
var connections = SForwardServerConnectionTransfer.Get(ConnectionSideType.Master);
if (connections.Any())
{
double diff = (bytes - lastBytes) * 8 / 1024.0 / 1024.0;
lastBytes = bytes;
var config = SForwardServerConfigStore.Config;
SForwardServerNodeReportInfo info = new SForwardServerNodeReportInfo
{
Bandwidth = config.Bandwidth,
Connections = config.Connections,
DataEachMonth = config.DataEachMonth,
DataRemain = config.DataRemain,
Logo = config.Logo,
Name = config.Name,
NodeId = config.NodeId,
Url = config.Url,
ConnectionsRatio = connectionNum,
BandwidthRatio = Math.Round(diff / 5, 2),
Version = VersionHelper.Version,
Masters = connections.Select(c => c.Address).ToArray(),
MasterKey = config.MasterKey,
};
byte[] memory = serializer.Serialize(info);
var tasks = connections.Select(c => messengerSender.SendOnly(new MessageRequestWrap
{
Connection = c,
MessengerId = (ushort)SForwardMessengerIds.Report,
Payload = memory,
Timeout = 5000
})).ToList();
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error($"SForward report : {ex}");
}
}
}, 5000);
}
private void SignInTask()
{
TimerHelper.SetIntervalLong(async () =>
{
try
{
var nodes = (await sForwardServerNodeStore.GetAll()).Where(c =>
{
return SForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, c.NodeId, out IConnection connection) == false || connection == null || connection.Connected == false;
}).ToList();
if (nodes.Count != 0)
{
var tasks = nodes.Select(async c =>
{
IPEndPoint remote = await NetworkHelper.GetEndPointAsync(c.Host, 1802).ConfigureAwait(false);
Socket socket = new Socket(remote.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.KeepAlive();
await socket.ConnectAsync(remote).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
var connection = await messengerResolver.BeginReceiveClient(socket, true, (byte)ResolverType.SForwardConnection, Helper.EmptyArray).ConfigureAwait(false);
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.SignIn,
Payload = serializer.Serialize(new KeyValuePair<string, string>(Config.NodeId, c.ShareKey)),
Timeout = 5000
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK && resp.Data.Span.SequenceEqual(Helper.TrueArray))
{
LoggerHelper.Instance.Debug($"SForward sign in to node {c.NodeId} success");
SForwardServerConnectionTransfer.TryAdd(ConnectionSideType.Node, c.NodeId, connection);
}
else
{
connection.Disponse();
}
});
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error($"SForward sign in : {ex}");
}
}
}, 10000);
}
}
}

306
src/linker.messenger.sforward/server/SForwardServerNodeTransfer.cs
View File

@@ -1,11 +1,7 @@
using linker.libs;
using linker.libs.extends;
using linker.libs.timer;
using linker.messenger.sforward.messenger;
using System.Buffers;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
namespace linker.messenger.sforward.server
{
@@ -14,91 +10,64 @@ namespace linker.messenger.sforward.server
/// </summary>
public class SForwardServerNodeTransfer
{
/// <summary>
/// 配置了就用配置的，每配置就用一个默认的
/// </summary>
public SForwardServerNodeInfo Node => sForwardServerNodeStore.Node;
public SForwardServerConfigInfo Config => sForwardServerConfigStore.Config;
private IConnection connection;
public IConnection Connection => connection;
private readonly NumberSpace ns = new NumberSpace(65537);
private long bytes = 0;
private long lastBytes = 0;
private readonly SForwardSpeedLimit limitTotal = new SForwardSpeedLimit();
private readonly ConcurrentDictionary<ulong, SForwardTrafficCacheInfo> trafficDict = new ConcurrentDictionary<ulong, SForwardTrafficCacheInfo>();
private readonly NumberSpace ns = new(65537);
private readonly SForwardSpeedLimit limitTotal = new();
private readonly ConcurrentDictionary<ulong, SForwardTrafficCacheInfo> trafficDict = new();
private readonly ISerializer serializer;
private readonly ISForwardServerNodeStore sForwardServerNodeStore;
private readonly IMessengerResolver messengerResolver;
private readonly IMessengerSender messengerSender;
private readonly ISForwardServerStore sForwardServerStore;
public SForwardServerNodeTransfer(ISerializer serializer, ISForwardServerNodeStore sForwardServerNodeStore, ISForwardServerMasterStore sForwardServerMasterStore, IMessengerResolver messengerResolver, IMessengerSender messengerSender, ISForwardServerStore sForwardServerStore, ICommonStore commonStore)
private readonly ISForwardServerConfigStore sForwardServerConfigStore;
private readonly SForwardServerConnectionTransfer sForwardServerConnectionTransfer;
private readonly SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer;
public SForwardServerNodeTransfer(ISerializer serializer, IMessengerSender messengerSender, ICommonStore commonStore
, ISForwardServerConfigStore sForwardServerConfigStore, SForwardServerConnectionTransfer sForwardServerConnectionTransfer, SForwardServerNodeReportTransfer sForwardServerNodeReportTransfer)
{
this.serializer = serializer;
this.sForwardServerNodeStore = sForwardServerNodeStore;
this.messengerResolver = messengerResolver;
this.messengerSender = messengerSender;
this.sForwardServerStore = sForwardServerStore;
if (string.IsNullOrWhiteSpace(sForwardServerNodeStore.Node.MasterHost))
{
sForwardServerNodeStore.Node.Domain = IPAddress.Any.ToString();
sForwardServerNodeStore.Node.MasterHost = new IPEndPoint(IPAddress.Loopback, sForwardServerNodeStore.ServicePort).ToString();
sForwardServerNodeStore.Node.MasterSecretKey = sForwardServerMasterStore.Master.SecretKey;
sForwardServerNodeStore.Node.Name = "default";
sForwardServerNodeStore.Node.Public = false;
}
this.sForwardServerConfigStore = sForwardServerConfigStore;
this.sForwardServerConnectionTransfer = sForwardServerConnectionTransfer;
this.sForwardServerNodeReportTransfer = sForwardServerNodeReportTransfer;
if ((commonStore.Modes & CommonModes.Server) == CommonModes.Server)
{
limitTotal.SetLimit((uint)Math.Ceiling((Config.Bandwidth * 1024 * 1024) / 8.0));
TrafficTask();
ReportTask();
SignInTask();
}
}
public void Edit(SForwardServerNodeUpdateInfo info)
{
if (info.Id == Node.Id)
{
sForwardServerNodeStore.UpdateInfo(info);
sForwardServerNodeStore.Confirm();
_ = Report();
}
}
public void Exit()
{
Helper.AppExit(1);
}
public void Update(string version)
{
Helper.AppUpdate(version);
}
public async Task<bool> ProxyNode(SForwardProxyInfo info)
{
return await messengerSender.SendOnly(new MessageRequestWrap
if (sForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, info.NodeId, out var connection))
{
Connection = Connection,
MessengerId = (ushort)SForwardMessengerIds.ProxyNode,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
return await messengerSender.SendOnly(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.ProxyForward,
Payload = serializer.Serialize(info)
}).ConfigureAwait(false);
}
return false;
}
public async Task<List<string>> Heart(List<string> ids)
public async Task<List<string>> Heart(List<string> ids, string masterNodeId)
{
var resp = await messengerSender.SendReply(new MessageRequestWrap
if (sForwardServerConnectionTransfer.TryGet(ConnectionSideType.Node, masterNodeId, out var connection))
{
Connection = Connection,
MessengerId = (ushort)SForwardMessengerIds.Heart,
Payload = serializer.Serialize(ids)
}).ConfigureAwait(false);
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = connection,
MessengerId = (ushort)SForwardMessengerIds.Heart,
Payload = serializer.Serialize(ids)
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK)
{
return serializer.Deserialize<List<string>>(resp.Data.Span);
}
if (resp.Code == MessageResponeCodes.OK)
{
return serializer.Deserialize<List<string>>(resp.Data.Span);
}
return [];
@@ -134,14 +103,13 @@ namespace linker.messenger.sforward.server
/// 开始计算流量
/// </summary>
/// <param name="super"></param>
/// <param name="cdkeys"></param>
/// <returns></returns>
public SForwardTrafficCacheInfo AddTrafficCache(bool super, double bandwidth)
{
SForwardTrafficCacheInfo cache = new SForwardTrafficCacheInfo { Cache = new SForwardCacheInfo { FlowId = ns.Increment(), Super = super, Bandwidth = bandwidth }, Limit = new SForwardSpeedLimit(), Sendt = 0, SendtCache = 0 };
if (cache.Cache.Bandwidth < 0)
{
cache.Cache.Bandwidth = Node.MaxBandwidth;
cache.Cache.Bandwidth = Config.Bandwidth;
}
SetLimit(cache);
trafficDict.TryAdd(cache.Cache.FlowId, cache);
@@ -159,13 +127,13 @@ namespace linker.messenger.sforward.server
/// <returns></returns>
public bool AddBytes(SForwardTrafficCacheInfo cache, long length)
{
Interlocked.Add(ref bytes, length);
sForwardServerNodeReportTransfer.AddBytes(length);
if (Node.MaxGbTotal == 0) return true;
if (Config.DataEachMonth == 0) return true;
Interlocked.Add(ref cache.Sendt, length);
return Node.MaxGbTotalLastBytes > 0;
return Config.DataRemain > 0;
}
/// <summary>
@@ -174,44 +142,35 @@ namespace linker.messenger.sforward.server
/// <param name="cache"></param>
private void SetLimit(SForwardTrafficCacheInfo cache)
{
//黑白名单
if (cache.Cache.Bandwidth >= 0)
{
cache.Limit.SetLimit((uint)Math.Ceiling(cache.Cache.Bandwidth * 1024 * 1024 / 8.0));
return;
}
//无限制
if (cache.Cache.Super || Node.MaxBandwidth == 0)
{
cache.Limit.SetLimit(0);
return;
}
cache.Limit.SetLimit((uint)Math.Ceiling(Node.MaxBandwidth * 1024 * 1024 / 8.0));
cache.Limit.SetLimit((uint)Math.Ceiling(Config.Bandwidth * 1024 * 1024 / 8.0));
}
private void ResetNodeBytes()
{
if (Node.MaxGbTotal == 0) return;
if (Config.DataEachMonth == 0) return;
foreach (var cache in trafficDict.Values)
{
long length = Interlocked.Exchange(ref cache.Sendt, 0);
if (Node.MaxGbTotalLastBytes >= length)
sForwardServerNodeStore.SetMaxGbTotalLastBytes(Node.MaxGbTotalLastBytes - length);
else sForwardServerNodeStore.SetMaxGbTotalLastBytes(0);
if (Config.DataRemain >= length)
sForwardServerConfigStore.SetDataRemain(Config.DataRemain - length);
else sForwardServerConfigStore.SetDataRemain(0);
}
if (Node.MaxGbTotalMonth != DateTime.Now.Month)
if (Config.DataMonth != DateTime.Now.Month)
{
sForwardServerNodeStore.SetMaxGbTotalMonth(DateTime.Now.Month);
sForwardServerNodeStore.SetMaxGbTotalLastBytes((long)(Node.MaxGbTotal * 1024 * 1024 * 1024));
sForwardServerConfigStore.SetDataMonth(DateTime.Now.Month);
sForwardServerConfigStore.SetDataRemain((long)(Config.DataEachMonth * 1024 * 1024 * 1024));
}
sForwardServerNodeStore.Confirm();
sForwardServerConfigStore.Confirm();
}
private void TrafficTask()
{
TimerHelper.SetIntervalLong(() =>
@@ -227,175 +186,8 @@ namespace linker.messenger.sforward.server
}, 3000);
}
private void ReportTask()
{
TimerHelper.SetIntervalLong(async () =>
{
await Report();
await MasterHosts();
}, 5000);
}
private async Task Report()
{
try
{
double diff = (bytes - lastBytes) * 8 / 1024.0 / 1024.0;
lastBytes = bytes;
IPAddress address = await NetworkHelper.GetDomainIpAsync(Node.Host).ConfigureAwait(false) ?? IPAddress.Any;
SForwardServerNodeReportInfo sForwardServerNodeReportInfo = new SForwardServerNodeReportInfo
{
Id = Node.Id,
Name = Node.Name,
MaxBandwidth = Node.MaxBandwidth,
BandwidthRatio = Math.Round(diff / 5, 2),
MaxBandwidthTotal = Node.MaxBandwidthTotal,
MaxGbTotal = Node.MaxGbTotal,
MaxGbTotalLastBytes = Node.MaxGbTotalLastBytes,
Public = Node.Public,
Domain = Node.Domain,
Address = address,
Url = Node.Url,
Sync2Server = Node.Sync2Server,
Version = VersionHelper.Version,
WebPort = sForwardServerStore.WebPort,
PortRange = sForwardServerStore.TunnelPortRange
};
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = Connection,
MessengerId = (ushort)SForwardMessengerIds.NodeReport,
Payload = serializer.Serialize(sForwardServerNodeReportInfo)
}).ConfigureAwait(false);
if (Node.Sync2Server && resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
string version = serializer.Deserialize<string>(resp.Data.Span);
if (version != VersionHelper.Version)
{
Helper.AppUpdate(version);
}
}
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error($"sforward report : {ex}");
}
}
}
private async Task MasterHosts()
{
try
{
if (signInHost != Node.MasterHost) return;
var resp = await messengerSender.SendReply(new MessageRequestWrap
{
Connection = Connection,
MessengerId = (ushort)SForwardMessengerIds.Hosts,
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
{
string[] hosts = serializer.Deserialize<string[]>(resp.Data.Span);
sForwardServerNodeStore.SetMasterHosts(hosts);
}
}
catch (Exception)
{
}
}
private string signInHost = string.Empty;
private void SignInTask()
{
TimerHelper.SetIntervalLong(async () =>
{
if (Connection == null || Connection.Connected == false)
{
string[] hosts = [Node.MasterHost, .. Node.MasterHosts];
foreach (var host in hosts.Where(c => string.IsNullOrWhiteSpace(c) == false))
{
connection = await SignIn(host, Node.MasterSecretKey).ConfigureAwait(false);
if (connection != null && connection.Connected)
{
signInHost = host;
break;
}
}
}
else
{
if (await TestHost(Node.MasterHost))
{
connection = await SignIn(Node.MasterHost, Node.MasterSecretKey).ConfigureAwait(false);
if (connection != null && connection.Connected)
{
signInHost = Node.MasterHost;
}
}
}
}, 3000);
}
private async Task<bool> TestHost(string host)
{
if (signInHost == Node.MasterHost) return false;
try
{
IPEndPoint ip = await NetworkHelper.GetEndPointAsync(host, 1802).ConfigureAwait(false);
using Socket socket = new Socket(ip.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.KeepAlive();
await socket.ConnectAsync(ip).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
socket.SafeClose();
return true;
}
catch (Exception)
{
}
return false;
}
private async Task<IConnection> SignIn(string host, string secretKey)
{
byte[] bytes = ArrayPool<byte>.Shared.Rent(1024);
try
{
byte[] secretKeyBytes = secretKey.Sha256().ToBytes();
bytes[0] = (byte)secretKeyBytes.Length;
secretKeyBytes.AsSpan().CopyTo(bytes.AsSpan(1));
IPEndPoint remote = await NetworkHelper.GetEndPointAsync(host, 1802).ConfigureAwait(false);
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Warning($"sforward node sign in to {remote}");
}
Socket socket = new Socket(remote.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.KeepAlive();
await socket.ConnectAsync(remote).WaitAsync(TimeSpan.FromMilliseconds(5000)).ConfigureAwait(false);
return await messengerResolver.BeginReceiveClient(socket, true, (byte)ResolverType.SForwardReport, bytes.AsMemory(0, secretKeyBytes.Length + 1)).ConfigureAwait(false);
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
{
LoggerHelper.Instance.Error(ex);
}
}
finally
{
ArrayPool<byte>.Shared.Return(bytes);
}
return null;
}
}
public sealed partial class SForwardCacheInfo
{
public ulong FlowId { get; set; }

13
src/linker.messenger.sforward/server/SForwardServerReportResolver.cs
View File

@@ -13,12 +13,10 @@ namespace linker.messenger.sforward.server
{
public byte Type => (byte)ResolverType.SForwardReport;
private readonly ISForwardServerMasterStore sForwardServerMasterStore;
private readonly IMessengerResolver messengerResolver;
public SForwardServerReportResolver(ISForwardServerMasterStore sForwardServerMasterStore, IMessengerResolver messengerResolver)
public SForwardServerReportResolver(IMessengerResolver messengerResolver)
{
this.sForwardServerMasterStore = sForwardServerMasterStore;
this.messengerResolver = messengerResolver;
}
@@ -40,14 +38,7 @@ namespace linker.messenger.sforward.server
string key = buffer.AsMemory(0, length).GetString();
if (sForwardServerMasterStore.Master.SecretKey.Sha256() == key)
{
await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray).ConfigureAwait(false);
}
else
{
socket.SafeClose();
}
await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray).ConfigureAwait(false);
}
catch (Exception ex)
{

40
src/linker.messenger.sforward/server/validator/SForwardValidator.cs
View File

@@ -9,26 +9,42 @@ namespace linker.messenger.sforward.server.validator
{
public string Name => "default";
private readonly ISForwardServerStore sForwardServerStore;
private readonly ISForwardServerNodeStore sForwardServerNodeStore;
public SForwardValidator(ISForwardServerStore sForwardServerStore, ISForwardServerNodeStore sForwardServerNodeStore)
private readonly ISForwardServerConfigStore sForwardServerConfigStore;
public SForwardValidator(ISForwardServerConfigStore sForwardServerConfigStore)
{
this.sForwardServerStore = sForwardServerStore;
this.sForwardServerNodeStore = sForwardServerNodeStore;
this.sForwardServerConfigStore = sForwardServerConfigStore;
}
public async Task<string> Validate(SignCacheInfo signCacheInfo, SForwardAddInfo sForwardAddInfo)
{
//if (string.IsNullOrWhiteSpace(sForwardAddInfo.NodeId)) sForwardAddInfo.NodeId = sForwardServerNodeStore.Node.Id;
if (sForwardAddInfo.RemotePort > 0)
if (ValidatePort(sForwardAddInfo.RemotePort) == false)
{
if (sForwardAddInfo.RemotePort < sForwardServerStore.TunnelPortRange[0] || sForwardAddInfo.RemotePort > sForwardServerStore.TunnelPortRange[1])
{
return $"port out of range {string.Join("-", sForwardServerStore.TunnelPortRange)}";
}
return $"port out of range";
}
return await Task.FromResult(string.Empty);
}
private bool ValidatePort(int port)
{
if (port <= 0)
{
return true;
}
string ports = sForwardServerConfigStore.Config.TunnelPorts;
return string.IsNullOrWhiteSpace(ports)
|| $",{ports},".Contains($",{port},")
|| ports.Split(',').Where(c => c.Contains('-')).Any(c =>
{
try
{
int[] p = c.Split('-').Select(c => int.Parse(c)).ToArray();
return p.Length == 2 && port >= p[0] && port <= p[1];
}
catch (Exception)
{
}
return false;
});
}
}
}

4
src/linker.messenger.store.file/ConfigApiController.cs
View File

@@ -78,7 +78,7 @@ namespace linker.messenger.store.file
config.Data.Server.SignIn.SuperKey = info.Server.SuperKey;
config.Data.Server.SignIn.SuperPassword = info.Server.SuperPassword;
config.Data.Server.SForward.WebPort = info.Server.SForward.WebPort;
config.Data.Server.SForward.TunnelPortRange = info.Server.SForward.TunnelPortRange;
config.Data.Server.SForward.TunnelPorts = info.Server.SForward.TunnelPorts;
}
config.Data.Common.Modes = info.Common.Modes;
@@ -358,7 +358,7 @@ namespace linker.messenger.store.file
public sealed class ConfigInstallServerSForwardInfo
{
public int WebPort { get; set; }
public int[] TunnelPortRange { get; set; }
public string TunnelPorts { get; set; }
}
public sealed class ConfigInstallCommonInfo

4
src/linker.messenger.store.file/Entry.cs
View File

@@ -95,9 +95,9 @@ namespace linker.messenger.store.file
serviceCollection.AddSingleton<ISocks5Store, Socks5Store>();
serviceCollection.AddSingleton<ISForwardClientStore, SForwardClientStore>();
serviceCollection.AddSingleton<ISForwardServerStore, SForwardServerStore>();
serviceCollection.AddSingleton<ISForwardServerConfigStore, SForwardServerConfigStore>();
serviceCollection.AddSingleton<ISForwardServerNodeStore, SForwardServerNodeStore>();
serviceCollection.AddSingleton<ISForwardServerNodeStore, SForwardServerNodeStore>();
serviceCollection.AddSingleton<ISForwardServerMasterStore, SForwardServerMasterStore>();
serviceCollection.AddSingleton<ILoggerStore, LoggerStore>();

2
src/linker.messenger.store.file/relay/RelayServerConfigStore.cs
View File

@@ -24,7 +24,7 @@ namespace linker.messenger.store.file.relay
Config.Name = Config.Distributed.Node.Name;
Config.Url = Config.Distributed.Node.Url;
Config.Domain = NetworkHelper.GetEndPoint(Config.Distributed.Node.Host, ServicePort).Address.ToString();
Config.Host = NetworkHelper.GetEndPoint(Config.Distributed.Node.Host, ServicePort).Address.ToString();
Config.Distributed.Node.Id = string.Empty;
config.Data.Update();

11
src/linker.messenger.store.file/sforward/Config.cs
View File

@@ -1,19 +1,12 @@

using linker.messenger.sforward;
using linker.messenger.sforward.server;
namespace linker.messenger.store.file
{
public sealed partial class RunningConfigInfo
{
}
public sealed partial class ConfigClientInfo
{
}
public partial class ConfigServerInfo
{
/// <summary>
/// 服务器穿透配置
/// </summary>
public SForwardConfigServerInfo SForward { get; set; } = new SForwardConfigServerInfo();
public SForwardServerConfigInfo SForward { get; set; } = new SForwardServerConfigInfo();
}
}

7
src/linker.messenger.store.file/sforward/SForwardClientStore.cs
View File

@@ -8,15 +8,10 @@ namespace linker.messenger.store.file.sforward
{
public sealed class SForwardClientStore : ISForwardClientStore
{
private readonly FileConfig fileConfig;
private readonly Storefactory dBfactory;
private readonly ILiteCollection<SForwardInfo> liteCollection;
public SForwardClientStore(FileConfig fileConfig, Storefactory dBfactory)
public SForwardClientStore(Storefactory dBfactory)
{
this.fileConfig = fileConfig;
this.dBfactory = dBfactory;
liteCollection = dBfactory.GetCollection<SForwardInfo>("sforward");
liteCollection.UpdateMany(c => new SForwardInfo { Started = false }, c => c.Started == true);
}

62
src/linker.messenger.store.file/sforward/SForwardServerConfigStore.cs Normal file
View File

@@ -0,0 +1,62 @@
using linker.libs;
using linker.messenger.sforward.server;
namespace linker.messenger.store.file.sforward
{
public sealed class SForwardServerConfigStore : ISForwardServerConfigStore
{
public int ServicePort => config.Data.Server.ServicePort;
public SForwardServerConfigInfo Config => config.Data.Server.SForward;
private readonly FileConfig config;
public SForwardServerConfigStore(FileConfig config)
{
this.config = config;
if (string.IsNullOrWhiteSpace(Config.Distributed.Node.Id) == false)
{
Config.NodeId = Config.Distributed.Node.Id;
Config.DataRemain = Config.Distributed.Node.MaxGbTotalLastBytes;
Config.DataMonth = Config.Distributed.Node.MaxGbTotalMonth;
Config.Bandwidth = (int)Config.Distributed.Node.MaxBandwidthTotal;
Config.DataEachMonth = (int)Config.Distributed.Node.MaxGbTotal;
Config.Name = Config.Distributed.Node.Name;
Config.Url = Config.Distributed.Node.Url;
Config.Host = NetworkHelper.GetEndPoint(Config.Distributed.Node.Host, ServicePort).Address.ToString();
Config.Distributed.Node.Id = string.Empty;
config.Data.Update();
}
}
public void Confirm()
{
config.Data.Update();
}
public void SetInfo(SForwardServerConfigInfo node)
{
config.Data.Server.SForward = node;
}
public void SetDataRemain(long value)
{
config.Data.Server.SForward.DataRemain = value;
}
public void SetDataMonth(int month)
{
config.Data.Server.SForward.DataMonth = month;
}
public void SetShareKey(string shareKey)
{
config.Data.Server.SForward.ShareKey = shareKey;
}
public void SetMasterKey(string masterKey)
{
config.Data.Server.SForward.MasterKey = masterKey;
}
}
}

26
src/linker.messenger.store.file/sforward/SForwardServerMasterStore.cs
View File

@@ -1,26 +0,0 @@
using linker.messenger.sforward.server;
namespace linker.messenger.store.file.sforward
{
public sealed class SForwardServerMasterStore : ISForwardServerMasterStore
{
public SForwardServerMasterInfo Master => config.Data.Server.SForward.Distributed.Master;
private readonly FileConfig config;
public SForwardServerMasterStore(FileConfig config)
{
this.config = config;
}
public void SetInfo(SForwardServerMasterInfo info)
{
config.Data.Server.SForward.Distributed.Master = info;
}
public bool Confirm()
{
config.Data.Update();
return true;
}
}
}

95
src/linker.messenger.store.file/sforward/SForwardServerNodeStore.cs
View File

@@ -1,55 +1,78 @@
using linker.messenger.sforward.server;
using linker.libs.extends;
using linker.messenger.sforward.server;
using LiteDB;
namespace linker.messenger.store.file.sforward
{
public sealed class SForwardServerNodeStore : ISForwardServerNodeStore
{
public int ServicePort => config.Data.Server.ServicePort;
public SForwardServerNodeInfo Node => config.Data.Server.SForward.Distributed.Node;
private readonly ILiteCollection<SForwardServerNodeStoreInfo> liteCollection;
private readonly FileConfig config;
public SForwardServerNodeStore(FileConfig config)
private string md5 = string.Empty;
public SForwardServerNodeStore(Storefactory storefactory, ISForwardServerConfigStore SForwardServerConfigStore)
{
this.config = config;
liteCollection = storefactory.GetCollection<SForwardServerNodeStoreInfo>("SForward_server_master");
md5 = SForwardServerConfigStore.Config.NodeId.Md5();
}
public void Confirm()
public async Task<bool> Add(SForwardServerNodeStoreInfo info)
{
config.Data.Update();
if (liteCollection.FindOne(c => c.NodeId == info.NodeId) != null)
{
return false;
}
liteCollection.Insert(info);
return await Task.FromResult(true).ConfigureAwait(false);
}
public void SetInfo(SForwardServerNodeInfo node)
public async Task<bool> Delete(string nodeId)
{
config.Data.Server.SForward.Distributed.Node = node;
}
public void UpdateInfo(SForwardServerNodeUpdateInfo update)
{
config.Data.Server.SForward.Distributed.Node.Name = update.Name;
config.Data.Server.SForward.Distributed.Node.MaxBandwidth = update.MaxBandwidth;
config.Data.Server.SForward.Distributed.Node.MaxBandwidthTotal = update.MaxBandwidthTotal;
config.Data.Server.SForward.Distributed.Node.MaxGbTotal = update.MaxGbTotal;
config.Data.Server.SForward.Distributed.Node.MaxGbTotalLastBytes = update.MaxGbTotalLastBytes;
config.Data.Server.SForward.Distributed.Node.Public = update.Public;
config.Data.Server.SForward.Distributed.Node.Domain = update.Domain;
config.Data.Server.SForward.Distributed.Node.Host = update.Host;
config.Data.Server.SForward.Distributed.Node.Url = update.Url;
config.Data.Server.SForward.Distributed.Node.Sync2Server = update.Sync2Server;
config.Data.Server.SForward.WebPort = update.WebPort;
config.Data.Server.SForward.TunnelPortRange = update.PortRange;
}
public void SetMasterHosts(string[] hosts)
{
config.Data.Server.SForward.Distributed.Node.MasterHosts = hosts;
}
public void SetMaxGbTotalLastBytes(long value)
{
config.Data.Server.SForward.Distributed.Node.MaxGbTotalLastBytes = value;
return await Task.FromResult(liteCollection.DeleteMany(c => c.NodeId == nodeId) > 0).ConfigureAwait(false);
}
public void SetMaxGbTotalMonth(int month)
public async Task<List<SForwardServerNodeStoreInfo>> GetAll()
{
config.Data.Server.SForward.Distributed.Node.MaxGbTotalMonth = month;
return await Task.FromResult(liteCollection.FindAll().ToList()).ConfigureAwait(false);
}
public async Task<SForwardServerNodeStoreInfo> GetByNodeId(string nodeId)
{
return await Task.FromResult(liteCollection.FindOne(c => c.NodeId == nodeId)).ConfigureAwait(false);
}
public async Task<bool> Report(SForwardServerNodeReportInfo info)
{
int length = liteCollection.UpdateMany(p => new SForwardServerNodeStoreInfo
{
LastTicks = Environment.TickCount64,
Bandwidth = info.Bandwidth,
Connections = info.Connections,
Version = info.Version,
ConnectionsRatio = info.ConnectionsRatio,
BandwidthRatio = info.BandwidthRatio,
Url = info.Url,
Logo = info.Logo,
DataEachMonth = info.DataEachMonth,
DataRemain = info.DataRemain,
Name = info.Name,
MasterKey = info.MasterKey,
Masters = info.Masters,
//是我初始化的，可以管理
Manageable = info.MasterKey == md5
}, c => c.NodeId == info.NodeId);
return await Task.FromResult(length > 0).ConfigureAwait(false);
}
public async Task<bool> Update(SForwardServerNodeStoreInfo info)
{
int length = liteCollection.UpdateMany(p => new SForwardServerNodeStoreInfo
{
DataEachMonth = info.DataEachMonth,
Public = info.Public,
}, c => c.NodeId == info.NodeId);
return await Task.FromResult(length > 0).ConfigureAwait(false); ;
}
}
}

36
src/linker.messenger.store.file/sforward/SForwardServerStore.cs
View File

@@ -1,36 +0,0 @@
using linker.messenger.sforward.server;
namespace linker.messenger.store.file.sforward
{
public sealed class SForwardServerStore : ISForwardServerStore
{
public int WebPort => fileConfig.Data.Server.SForward.WebPort;
public int[] TunnelPortRange => fileConfig.Data.Server.SForward.TunnelPortRange;
private readonly FileConfig fileConfig;
public SForwardServerStore(FileConfig fileConfig)
{
this.fileConfig = fileConfig;
}
public bool SetWebPort(int port)
{
fileConfig.Data.Server.SForward.WebPort = port;
return true;
}
public bool SetTunnelPortRange(int[] ports)
{
if (ports == null || ports.Length != 2) return false;
fileConfig.Data.Server.SForward.TunnelPortRange = ports;
return true;
}
public bool Confirm()
{
fileConfig.Data.Update();
return true;
}
}
}

5
src/linker.messenger/IResolver.cs
View File

@@ -43,6 +43,11 @@ namespace linker.messenger
/// 中继联机
/// </summary>
RelayConnection = 9,
/// <summary>
/// 穿透联机
/// </summary>
SForwardConnection = 10,
}
public interface IResolver
{

37
src/linker.web/src/apis/sforward.js
View File

@@ -1,36 +1,47 @@
import { sendWebsocketMsg } from './request'
export const getSForwardInfo = (data) => {
export const getSForward = (data) => {
return sendWebsocketMsg('sforward/get', data);
}
export const removeSForwardInfo = (data) => {
return sendWebsocketMsg('sforward/remove', data);
export const removeSForward = (data) => {
return sendWebsocketMsg('sforward/removeclient', data);
}
export const addSForwardInfo = (data) => {
return sendWebsocketMsg('sforward/add', data);
export const sforwardAddClient = (data) => {
return sendWebsocketMsg('sforward/addclient', data);
}
export const testLocalSForwardInfo = (data) => {
export const sforwardTestLocal = (data) => {
return sendWebsocketMsg('sforward/TestLocal', data);
}
export const startSForwardInfo = (data) => {
export const sforwardStart = (data) => {
return sendWebsocketMsg('sforward/start', data);
}
export const stopSForwardInfo = (data) => {
export const sforwardStop = (data) => {
return sendWebsocketMsg('sforward/stop', data);
}
export const setSForwardSubscribe = () => {
export const sforwardSubscribe = () => {
return sendWebsocketMsg('sforward/Subscribe');
}
export const sforwardEdit = (data) => {
return sendWebsocketMsg('sforward/edit', data);
export const sforwardUpdate= (data) => {
return sendWebsocketMsg('sforward/update', data);
}
export const sforwardUpgrade= (data) => {
return sendWebsocketMsg('sforward/upgrade', data);
}
export const sforwardExit = (id) => {
return sendWebsocketMsg('sforward/Exit', id);
}
export const sforwardUpdate = (id) => {
return sendWebsocketMsg('sforward/Update', id);
export const sforwardRemove = (id) => {
return sendWebsocketMsg('sforward/Remove', id);
}
export const sforwardImport = (data) => {
return sendWebsocketMsg('sforward/Import', data);
}
export const sforwardShare = (id) => {
return sendWebsocketMsg('sforward/Share', id);
}

12
src/linker.web/src/views/components/forward/Config.vue
View File

@@ -18,7 +18,7 @@ import { computed, onMounted, onUnmounted, provide, reactive, ref } from 'vue'
import { useI18n } from 'vue-i18n';
import WhiteList from '../wlist/Index.vue';
import Nodes from './Nodes.vue';
import { setSForwardSubscribe } from '@/apis/sforward';
import { sforwardSubscribe } from '@/apis/sforward';
import Status from '../wlist/Status.vue';
export default {
@@ -37,18 +37,18 @@ export default {
const nodes = ref([]);
provide('nodes',nodes);
const _setSForwardSubscribe = ()=>{
const _sforwardSubscribe = ()=>{
clearTimeout(state.timer);
setSForwardSubscribe().then((res)=>{
sforwardSubscribe().then((res)=>{
state.nodes = res;
nodes.value = res;
state.timer = setTimeout(_setSForwardSubscribe,1000);
state.timer = setTimeout(_sforwardSubscribe,1000);
}).catch(()=>{
state.timer = setTimeout(_setSForwardSubscribe,1000);
state.timer = setTimeout(_sforwardSubscribe,1000);
});
}
onMounted(()=>{
_setSForwardSubscribe();
_sforwardSubscribe();
});
onUnmounted(()=>{
clearTimeout(state.timer);

56
src/linker.web/src/views/components/forward/SForwardEdit.vue
View File

@@ -113,7 +113,7 @@
</template>
<script>
import { onMounted, onUnmounted, reactive, ref, watch } from 'vue';
import { getSForwardInfo, removeSForwardInfo, addSForwardInfo,testLocalSForwardInfo, stopSForwardInfo, startSForwardInfo, setSForwardSubscribe } from '@/apis/sforward'
import { getSForward, removeSForward, sforwardAddClient,sforwardTestLocal, sforwardStop, sforwardStart, sforwardSubscribe } from '@/apis/sforward'
import { ElMessage } from 'element-plus';
import {WarnTriangleFilled,Delete,Select,CloseBold} from '@element-plus/icons-vue'
import { injectGlobalData } from '@/provide';
@@ -153,18 +153,18 @@ export default {
}, 300);
}
});
const _testLocalSForwardInfo = ()=>{
const _sforwardTestLocal = ()=>{
clearTimeout(state.timer);
testLocalSForwardInfo(sforward.value.machineid).then((res)=>{
state.timer = setTimeout(_testLocalSForwardInfo,1000);
sforwardTestLocal(sforward.value.machineid).then((res)=>{
state.timer = setTimeout(_sforwardTestLocal,1000);
}).catch(()=>{
state.timer = setTimeout(_testLocalSForwardInfo,1000);
state.timer = setTimeout(_sforwardTestLocal,1000);
});
}
const _getSForwardInfo = () => {
const _getSForward = () => {
clearTimeout(state.timer1);
if(state.editing==false){
getSForwardInfo(sforward.value.machineid).then((res) => {
getSForward(sforward.value.machineid).then((res) => {
res.forEach(c=>{
c.Temp = (c.Domain || c.RemotePort).toString();
c.RemotePort = 0;
@@ -172,34 +172,34 @@ export default {
c.NodeId1 = c.NodeId1 || c.NodeId;
});
state.data = res;
state.timer1 = setTimeout(_getSForwardInfo,1000);
state.timer1 = setTimeout(_getSForward,1000);
}).catch(() => {
state.timer1 = setTimeout(_getSForwardInfo,1000);
state.timer1 = setTimeout(_getSForward,1000);
});
}else{
state.timer1 = setTimeout(_getSForwardInfo,1000);
state.timer1 = setTimeout(_getSForward,1000);
}
}
const handleOnShowList = () => {
_getSForwardInfo();
_getSForward();
}
const handleCellClick = (row, column) => {
handleEdit(row, column.property);
}
const handleRefresh = () => {
_getSForwardInfo();
_getSForward();
ElMessage.success('已刷新')
}
const handleAdd = () => {
state.loading = true;
const row = { Id: 0, Name: '', RemotePort: 0, LocalEP: '127.0.0.1:80',Domain:'',Temp:'' };
addSForwardInfo({machineid:sforward.value.machineid,data:row}).then(() => {
sforwardAddClient({machineid:sforward.value.machineid,data:row}).then(() => {
state.loading = false;
setTimeout(()=>{
_getSForwardInfo();
_getSForward();
},100)
}).catch((err) => {
state.loading = false;
@@ -236,10 +236,10 @@ export default {
const handleDel = (id) => {
planDom.value.remove(id,'start');
planDom.value.remove(id,'stop');
removeSForwardInfo({machineid:sforward.value.machineid,id:id})
removeSForward({machineid:sforward.value.machineid,id:id})
.then(() => {
state.loading = false;
_getSForwardInfo();
_getSForward();
}).catch((err) => {
state.loading = false;
ElMessage.error(err);
@@ -248,12 +248,12 @@ export default {
const handleStartChange = (row) => {
state.loading = true;
const func = row.Started
? stopSForwardInfo({machineid:sforward.value.machineid,id:row.Id})
: startSForwardInfo({machineid:sforward.value.machineid,id:row.Id});
? sforwardStop({machineid:sforward.value.machineid,id:row.Id})
: sforwardStart({machineid:sforward.value.machineid,id:row.Id});
func.then(() => {
state.loading = false;
_getSForwardInfo();
_getSForward();
}).catch((err) => {
state.loading = false;
ElMessage.error(err);
@@ -268,12 +268,12 @@ export default {
row.Domain = row.Temp;
}
state.loading = true;
addSForwardInfo({machineid:sforward.value.machineid,data:row}).then((res) => {
sforwardAddClient({machineid:sforward.value.machineid,data:row}).then((res) => {
state.loading = false;
if(res == false){
ElMessage.error('操作失败，可能存在相同值');
}
_getSForwardInfo();
_getSForward();
}).catch((err) => {
state.loading = false;
ElMessage.error(err);
@@ -281,24 +281,24 @@ export default {
}
const _setSForwardSubscribe = ()=>{
const _sforwardSubscribe = ()=>{
clearTimeout(state.timer2);
setSForwardSubscribe().then((res)=>{
sforwardSubscribe().then((res)=>{
res = [{Id:'*',Name:'*'}].concat(res);
state.nodes = res;
state.nodesNames = res.reduce((json,item)=>{ json[item.Id] = item.Name; return json; },{});
state.nodesJson = res.reduce((json,item)=>{ json[item.Id] = item; return json; },{});
state.timer2 = setTimeout(_setSForwardSubscribe,1000);
state.timer2 = setTimeout(_sforwardSubscribe,1000);
}).catch(()=>{
state.timer2 = setTimeout(_setSForwardSubscribe,1000);
state.timer2 = setTimeout(_sforwardSubscribe,1000);
});
}
onMounted(()=>{
_getSForwardInfo();
_testLocalSForwardInfo();
_setSForwardSubscribe();
_getSForward();
_sforwardTestLocal();
_sforwardSubscribe();
});
onUnmounted(()=>{
clearTimeout(state.timer);

48
src/linker.web/src/views/layout/full/install/Server.vue
View File

@@ -15,19 +15,8 @@
</el-col>
</el-row>
</el-form-item>
<el-form-item label="" label-width="0">
<el-row>
<el-col :span="12">
<el-form-item label="开放最小端口" prop="tunnelPort1">
<el-input v-trim v-model="state.form.tunnelPort1" />
</el-form-item>
</el-col>
<el-col :span="12">
<el-form-item label="开放最大端口" prop="tunnelPort2">
<el-input v-trim v-model="state.form.tunnelPort2" />
</el-form-item>
</el-col>
</el-row>
<el-form-item label="穿透端口" prop="TunnelPorts">
<el-input v-trim v-model="state.form.TunnelPorts" />
</el-form-item>
<el-form-item label="" label-width="0">
<el-row>
@@ -74,8 +63,7 @@ export default {
superKey:step.value.form.server.superKey ||globalData.value.config.Server.SignIn.SuperKey,
superPassword:step.value.form.server.superPassword ||globalData.value.config.Server.SignIn.SuperPassword,
webPort:step.value.form.server.webPort ||globalData.value.config.Server.SForward.WebPort,
tunnelPort1:step.value.form.server.tunnelPort1 ||globalData.value.config.Server.SForward.TunnelPortRange[0],
tunnelPort2:step.value.form.server.tunnelPort2 ||globalData.value.config.Server.SForward.TunnelPortRange[1],
TunnelPorts:step.value.form.server.TunnelPorts ||globalData.value.config.Server.SForward.TunnelPorts,
},
rules: {
superKey: [{ required: true, message: "必填", trigger: "blur" }],
@@ -105,33 +93,7 @@ export default {
return Number(value);
},
},
],
tunnelPort1: [
{ required: true, message: "必填", trigger: "blur" },
{
type: "number",
min: 0,
max: 65535,
message: "数字 0-65535",
trigger: "blur",
transform(value) {
return Number(value);
},
},
],
tunnelPort2: [
{ required: true, message: "必填", trigger: "blur" },
{
type: "number",
min: 0,
max: 65535,
message: "数字 0-65535",
trigger: "blur",
transform(value) {
return Number(value);
},
},
],
]
},
});
@@ -152,7 +114,7 @@ export default {
SForward:{
WebPort: +state.form.webPort,
TunnelPortRange: [+state.form.tunnelPort1, +state.form.tunnelPort2]
TunnelPorts:state.form.TunnelPorts
}
}
},