static async Task Main(string[] args)
{
var encoder = new ProxyPackageEncoder();
var decoder = new ProxyPackageDecoder();
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var endpoint = new IPEndPoint(IPAddress.Any, 9091);
socket.Bind(endpoint);
socket.Listen(10);
Console.WriteLine($"开始监听：{endpoint}");
var factory = new LoggerFactory();
var logger = factory.CreateLogger("");
while (true)
{
var nscoket = await socket.AcceptAsync();
Console.WriteLine($"连接成功：{nscoket.RemoteEndPoint}");
var channel = new ProxyChannel <ProxyPackage>(nscoket, encoder, decoder, logger, new ChannelOptions());
channel.PackageReceived += async(channl, package) =>
{
Console.WriteLine($"接收到一个数据包：{package},内容：{Encoding.UTF8.GetString(package.Data)}");
var reply = new ProxyPackage
{
Data = Encoding.UTF8.GetBytes("你好呀")
};
await channel.SendAsync(package);
};
await channel.StartAsync();
}
}
private async Task ProcessTransfer(IChannel <ProxyPackage> channel, ProxyPackage package)
{
IChannel targetChannel;
if (!serverChannelHolder.ContainsKey(package.ConnectionId))
{
var targetEp = new IPEndPoint(IPAddress.Parse(channelConfig.FrontendIp), channelConfig.FrontendPort);
var wrapper = new TimeoutSocketWrapper(targetEp);
var nsocket = wrapper.Connect(channelOptions.ConnectTimeout);
if (nsocket == null)
{
await SendDisconnectPackage(channel, package.ConnectionId);
return;
}
var connectionId = package.ConnectionId;
targetChannel = new MarkedProxyChannel(connectionId, nsocket, logger, channelOptions);
targetChannel.DataReceived += OnDataReceived;
serverChannelHolder[package.ConnectionId] = targetChannel;
_ = targetChannel.StartAsync();
}
else
{
targetChannel = serverChannelHolder[package.ConnectionId];
}
await targetChannel.SendAsync(package.Data);
}
private async Task ProcessAuthentication(IChannel <ProxyPackage> channel, ProxyPackage package)
{
var model = package.Data.BytesToObject <AuthenticationModel>();
var pass = await configHelper.CheckClientAsync(model.ClientId, model.SecretKey);
if (!pass)
{
await channel.SendAsync(new ProxyPackage
{
Data = new AuthenticationResult
{
Success = false,
Message = "ClientId not exits or SecretKey not correct"
}.ObjectToBytes(),
Type = PackageType.Authentication
});
}
else
{
var channels = await configHelper.GetChannelsAsync(model.ClientId);
await channel.SendAsync(new ProxyPackage
{
Data = new AuthenticationResult
{
Success = true,
Channels = channels
}.ObjectToBytes(),
Type = PackageType.Authentication
});
}
}
private async Task ProcessDisconnect(IChannel <ProxyPackage> channel, ProxyPackage package)
{
var existsChannel = clientChannelHolder[package.ConnectionId];
await existsChannel?.Close();
await Task.CompletedTask;
}
private async Task ProcessDisconect(IChannel <ProxyPackage> channel, ProxyPackage package)
{
if (serverChannelHolder.ContainsKey(package.ConnectionId))
{
//logger.LogInformation("收到服务端发送的断开连接");
await serverChannelHolder[package.ConnectionId].Close();
serverChannelHolder.Remove(package.ConnectionId);
}
await Task.CompletedTask;
}
private async Task TransferAsync(long connectionId, byte[] data)
{
var package = new ProxyPackage
{
ChannelId = channelConfig.ChannelId,
ConnectionId = connectionId,
Data = data,
Type = PackageType.Transfer
};
await proxyChannel.SendAsync(package);
}
private async Task OnPackageReceived(IChannel <ProxyPackage> channel, ProxyPackage package)
{
switch (package.Type)
{
case PackageType.Transfer:
await ProcessTransfer(channel, package);
break;
case PackageType.Disconnect:
await ProcessDisconect(channel, package);
break;
}
}
private async Task OnPackageReceived(IChannel <ProxyPackage> channel, ProxyPackage package)
{
switch (package.Type)
{
case PackageType.Connect:
await ProcessConnect(channel, package);
break;
case PackageType.Authentication:
await ProcessAuthentication(channel, package);
break;
}
}
private async Task ProcessConnect(IChannel <ProxyPackage> channel, ProxyPackage package)
{
var channelConfig = await configHelper.GetChannelAsync(package.ChannelId);
var connection = new ProxyServerConnection(package.ChannelId, channel, channelConfig.BackendPort, logger, idGenerator);
if (proxyServerConnectionHolder.ContainsKey(package.ChannelId))
{
await proxyServerConnectionHolder[package.ChannelId].StopAsync();
proxyServerConnectionHolder.Remove(package.ChannelId);
}
proxyServerConnectionHolder[package.ChannelId] = connection;
await connection.StartAsync();
}
static async Task Main(string[] args)
{
var encoder = new ProxyPackageEncoder();
var decoder = new ProxyPackageDecoder();
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var endpoint = new IPEndPoint(IPAddress.Loopback, 9091);
await socket.ConnectAsync(endpoint);
var factory = new LoggerFactory();
var logger = factory.CreateLogger("");
var options = new ChannelOptions();
var channel = new ProxyChannel <ProxyPackage>(socket, encoder, decoder, logger, options);
channel.PackageReceived += async(channl, package) =>
{
Console.WriteLine($"接收到一个数据包：{package},内容：{Encoding.UTF8.GetString(package.Data)}");
await Task.CompletedTask;
};
_ = channel.StartAsync();
var c = 0;
while (c < 100000)
{
var package = new ProxyPackage
{
ChannelId = 1,
ConnectionId = 100,
Type = PackageType.Transfer,
Data = Encoding.UTF8.GetBytes(c.ToString())
};
await channel.SendAsync(package);
c++;
}
Console.ReadKey();
}
private async Task OnAuthPackageReceived(IChannel <ProxyPackage> authChannel, ProxyPackage package)
{
var result = package.Data.BytesToObject <AuthenticationResult>();
if (!result.Success)
{
logger.LogInformation($"Authentication fail,message:{result.Message}");
return;
}
var channels = result.Channels;
if (channels.Count == 0)
{
logger.LogInformation("Not channel in config");
return;
}
foreach (var channel in channels)
{
var connection = new ProxyClientConnection(logger, IPAddress.Parse(options.ServerAddress), options.ServerPort, channel, encoder, decoder);
var task = connection.StartAsync();
channelTaskList.Add(task);
clientConnectionHolder.Add(channel.ChannelId, connection);
logger.LogInformation($"Start channel:{channel.ChannelId},targetIp:{channel.FrontendIp},targetPort:{channel.FrontendPort},serverPort:{channel.BackendPort}");
}
await authChannel.Close();
await Task.CompletedTask;
}
private async Task ProcessTransfer(IChannel <ProxyPackage> channel, ProxyPackage package)
{
var existsChannel = clientChannelHolder[package.ConnectionId];
await existsChannel.SendAsync(package.Data);
}
