protected virtual async Task DispatchRequestAsync(
string server,
ushort serverPort,
IDictionary <string, string> headers,
NetworkStream clientStream)
{
//
// Send response.
//
var response = Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\n\r\n");
clientStream.Write(response, 0, response.Length);
clientStream.Flush();
//
// Relay streams.
//
using (var client = new TcpClient(server, serverPort))
{
var serverStream = client.GetStream();
await Task.WhenAll(
clientStream.CopyToAsync(serverStream),
serverStream.CopyToAsync(clientStream));
}
}
private async Task HandleControlConnection(Socket controlClientSocket)
{
Trace.WriteLine("New control client " + controlClientSocket.RemoteEndPoint);
using (var controlClientStream = new NetworkStream(controlClientSocket, ownsSocket: true))
{
using (primaryControl = new TcpClient())
{
await primaryControl.ConnectAsync(PrimaryControlEndpoint);
Trace.WriteLine("Connected to control " + PrimaryControlEndpoint);
using (var primaryControlStream = primaryControl.GetStream())
{
Action <Task> close = task =>
{
if (task.IsFaulted)
{
Trace.WriteLine(task.Exception);
}
TryCatch(primaryControl.Close);
TryCatch(controlClientSocket.Dispose);
};
var forwardCommands = controlClientStream.CopyToAsync(primaryControlStream, DefaultReadSize).ContinueWith(close, TaskContinuationOptions.ExecuteSynchronously);
var forwardResponses = primaryControlStream.CopyToAsync(controlClientStream, DefaultReadSize).ContinueWith(close, TaskContinuationOptions.ExecuteSynchronously);
await Task.WhenAll(forwardCommands, forwardResponses);
}
}
primaryControl = null;
}
}
public async Task BindProxies(
int listenPort,
CancellationToken cancellationToken = default(CancellationToken))
{
while (!cancellationToken.IsCancellationRequested)
{
var tcpClient = new TcpClient();
#pragma warning disable PC001 // API not supported on all platforms
tcpClient.Connect(new IPEndPoint(IPAddress.Loopback, listenPort));
#pragma warning restore PC001
NetworkStream localStream = tcpClient.GetStream();
NetworkStream turnStream = await AcceptRelayedStreamAsync(cancellationToken);
#pragma warning disable CS4014
const int bufferSize = 8042;
Task.WhenAny(
turnStream.CopyToAsync(localStream, bufferSize, cancellationToken),
localStream.CopyToAsync(turnStream, bufferSize, cancellationToken)
).ContinueWith(
t =>
{
turnStream.Dispose();
localStream.Dispose();
tcpClient.Dispose();
},
cancellationToken
);
#pragma warning restore CS4014
}
}
public async Task Response()
{
try
{
// 建立新连接
Log.Information("connect to upstream: {0}:{1}", host, port);
tcpClient = new TcpClient();
await tcpClient.ConnectAsync(host, port);
upstream = tcpClient.GetStream();
upstream.ReadTimeout = 3000;
// 独立线程，完成自己的任务后消失
var thread = new Thread(CopyTo);
thread.Start();
await upstream.CopyToAsync(clientStream);
Close();
}
catch (IOException e)
{
Close();
Log.Information("connect to upstream {0}:{1} error: ", host, port, e.Message);
}
}
private async Task ToStaticTransfer(CancellationToken ct, NetworkStream fromStream, NetworkStream toStream, string clientApp)
{
using (fromStream)
{
await fromStream.CopyToAsync(toStream, ct);
}
Server.Logger.Debug($"{clientApp}对客户端传输关闭。");
}
private async Task ToStaticTransfer(CancellationToken ct, NetworkStream fromStream, NetworkStream toStream, string epString)
{
using (fromStream)
{
await fromStream.CopyToAsync(toStream, 4096, ct);
}
Router.Logger.Debug($"{epString}反向链接传输关闭。");
}
private async Task AcceptTunnelConnectionAsync()
{
try
{
_tunnelSocket = await _tunnelListener.AcceptAsync().WithTimeout(TUNNEL_WAIT_TIMEOUT);
_tunnelListener.Dispose();
Stream remoteStream = new NetworkStream(_remoteSocket);
if (_enableSsl)
{
SslStream sslStream;
if (_ignoreCertificateErrors)
{
sslStream = new SslStream(remoteStream, false, delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return(true); //ignore cert errors
});
}
else
{
sslStream = new SslStream(remoteStream);
}
string targetHost;
switch (_remoteEP.AddressFamily)
{
case AddressFamily.InterNetwork:
case AddressFamily.InterNetworkV6:
targetHost = (_remoteEP as IPEndPoint).Address.ToString();
break;
case AddressFamily.Unspecified:
targetHost = (_remoteEP as DomainEndPoint).Address;
break;
default:
throw new NotSupportedException("AddressFamily not supported.");
}
await sslStream.AuthenticateAsClientAsync(targetHost).WithTimeout(TUNNEL_WAIT_TIMEOUT);
remoteStream = sslStream;
}
Stream tunnelStream = new NetworkStream(_tunnelSocket);
_ = remoteStream.CopyToAsync(tunnelStream).ContinueWith(delegate(Task prevTask) { Dispose(); });
_ = tunnelStream.CopyToAsync(remoteStream).ContinueWith(delegate(Task prevTask) { Dispose(); });
}
catch
{
Dispose();
}
}
/// <summary>
/// Приём файла.
/// </summary>
/// <param name="socket">Сокет.</param>
private void ReceiveFile(Socket socket)
{
// Генерируем уникальное имя для файла.
var tmp_file_name = string.Format("{0}_{1}", DateTime.Now.Ticks, _fileCount);
_fileCount++;
var ns = new NetworkStream(socket);
var remote_address = (socket.RemoteEndPoint as IPEndPoint).Address.ToString();
var message_type = (MesasageType)ns.ReadByte();
if (message_type == MesasageType.Text)
{
byte[] buffer = new byte[256];
socket.Receive(buffer);
Console.WriteLine("Принято сообщение: {0}", Encoding.Unicode.GetString(buffer));
return;
}
var fs = new FileStream(tmp_file_name, FileMode.CreateNew);
ns.CopyToAsync(fs).ContinueWith((ar) =>
{
fs.Close();
fs.Dispose();
ns.Close();
ns.Dispose();
FileInfo file = new FileInfo(tmp_file_name);
if (FileSize.HasValue)
{
if (FileSize == file.Length)
{
ReceviceFileCount++;
}
else
{
Console.WriteLine("Размер принятого файла не соответствует отправленному ({0} != {1}).", FileSize, file.Length);
}
}
Console.WriteLine("Получен файл");
if (message_type == MesasageType.ReveiveFileAndExecProc)
{
ExecProcAndSendFile(tmp_file_name, remote_address, _remotePort);
}
else
{
if (IsDeleteFiles)
{
File.Delete(tmp_file_name);
}
}
});
}
public static void SocketTransfer(string server, int port, Stream dataStreamTo, Stream dataStreamFrom)
{
if (server is null)
{
throw new ArgumentNullException("server");
}
if (port < 1)
{
throw new ArgumentOutOfRangeException("port");
}
if (dataStreamTo is null && dataStreamFrom is null)
{
throw new ArgumentNullException("dataStreamIn, dataStreamOut");
}
// Create a TcpClient.
TcpClient client = new TcpClient(server, port);
// Get a client stream for reading and writing.
NetworkStream socketStream = client.GetStream();
// Copy the stream data into dataStream
Task transferFrom = null;
if (!(dataStreamFrom is null))
{
transferFrom = socketStream.CopyToAsync(dataStreamFrom);
}
// Copy dataStream into the stream data
Task transferTo = null;
if (!(dataStreamTo is null))
{
transferTo = dataStreamTo.CopyToAsync(socketStream);
}
// Wait for the streams to finish
try {
transferFrom.Wait();
}
catch { }
try {
transferTo.Wait();
}
catch { }
// Close everything.
socketStream.Close();
client.Close();
}
private void Listen(Socket client)
{
try
{
using var clientStream = new NetworkStream(client);
string request = ReceiveMessage(clientStream);
while (true)
{
var host = DefineHost(request);
if (settings.BlockedSite(host.Ip))
{
byte[] wrongPageBytes = GetWrongPage();
clientStream.Write(wrongPageBytes, 0, wrongPageBytes.Length);
output($"Host: {host.Ip}; Code: 403 Forbidden.\n");
return;
}
using var server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var ipHost = Dns.GetHostEntry(host.Ip);
var remoteEp = new IPEndPoint(ipHost.AddressList[0], host.Port);
server.Connect(remoteEp);
using var serverStream = new NetworkStream(server);
request = ConvertingAdress(request);
byte[] bytesRequest = Encoding.UTF8.GetBytes(request);
serverStream.Write(bytesRequest, 0, bytesRequest.Length);
string response = ReceiveMessage(serverStream);
byte[] bytesResponse = Encoding.UTF8.GetBytes(response);
clientStream.Write(bytesResponse, 0, bytesResponse.Length);
var code = ExtractResponseCode(response);
output($"Host: {host.Ip}; Code: {code}.\n");
serverStream.CopyToAsync(clientStream);
request = ReceiveMessage(clientStream);
if (string.IsNullOrEmpty(request))
{
return;
}
}
}
finally
{
client.Close();
}
}
public void Start()
{
cts?.Cancel();
cts = new CancellationTokenSource();
//大于等于10毫秒时，才批量发送
if (packageSendInterval >= 10)
{
beginSendPackage(cts.Token);
}
handler.PackageReceived += Handler_PackageReceived;
stream.CopyToAsync(this).ContinueWith(t => Stop());
}
public async Task Test()
{
// create the server
var server = new WsServer();
await server.StartAsync(new IPEndPoint(IPAddress.Loopback, 8080), async stream =>
{
//await stream.EncryptAsync();
Console.WriteLine($"Tunnel Opened: remote => localhost:12345");
var sock = new Socket(SocketType.Stream, ProtocolType.Tcp);
await sock.ConnectAsync("localhost", 12345);
var ns = new NetworkStream(sock);
var t1 = ns.CopyToAsync(stream, 62000);
var t2 = stream.CopyToAsync(ns, 62000);
await Task.WhenAny(t1, t2);
sock.Dispose();
await stream.DisposeAsync();
Console.WriteLine($"Tunnel Closed: remote => localhost:25565");
});
Socket lSock = new Socket(SocketType.Stream, ProtocolType.Tcp);
lSock.Bind(new IPEndPoint(IPAddress.Loopback, 1234));
lSock.Listen(10);
var cts = new CancellationTokenSource();
Console.WriteLine($"Started... Listening to localhost:1234. Press ctrl + c to exit");
Console.CancelKeyPress += (q, e) =>
{
cts.Cancel();
};
while (!cts.Token.IsCancellationRequested)
{
var ksock = await lSock.AcceptAsync();
Task.Run(async() =>
{
// start client
var client = new WsClient();
var connection = await client.ConnectAsync(new Uri("ws://localhost:8080"));
//await connection.EncryptAsync();
var ns = new NetworkStream(ksock);
var t1 = ns.CopyToAsync(connection, 62000);
var t2 = connection.CopyToAsync(ns, 62000);
await Task.WhenAny(t1, t2);
ksock.Dispose();
await connection.DisposeAsync();
client.Dispose();
});
}
// cleanup
server.Dispose();
}
async void ReceiveJSONFromMediator(object argument)
{
if (((IList)argument)[0].GetType() != typeof(string))
{
return;
}
else if ((string)((IList)argument)[0] != "")
{
return;
}
ArrayList tempList = (ArrayList)argument;
try
{
TcpListener listener = null;
listener = new TcpListener(mdl.GetMediatorAddress());
listener.Start();
while (mdl.GetReadDataJSON().Length == 0)
{
int temp = (int)tempList[1];
if
(
!writethreads[temp].IsAlive &&
threadEndingFlag[temp]
)
{
return;
}
await Task.Delay(100);
TcpClient tcpClient = await listener.AcceptTcpClientAsync();
NetworkStream ns = tcpClient.GetStream();
SetVisibilityWarningIcon(false);
using (MemoryStream ms = new MemoryStream())
{
await ns.CopyToAsync(ms);
argument = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
catch (SocketException /*ex*/)
{
SetVisibilityWarningIcon(true);
}
}
public static async Task DoComunicationWithServerAsync(ServerInfo speechServerInfo, NetworkStream clientRequest)
{
using (var TcpClientForServer = new TcpClient())
{
TcpClientForServer.Connect(ServerInfo.LocalHostIP, speechServerInfo.Port);
using (var serverStream = TcpClientForServer.GetStream())
{
await clientRequest.CopyToAsync(serverStream);
await serverStream.CopyToAsync(clientRequest);
}
}
}
private static async Task SendResponse(NetworkStream stream)
{
var packet = new PeerPacket <Vote>();
Vote vote = new Vote()
{
Ogranization = OrganizationType.Country,
VoteType = (int)CountryVoteType.President
};
packet.Payload = vote;
await stream.CopyToAsync(packet.SerializePeerPacket());
await stream.FlushAsync();
}
public async Task Connect()
{
//var ip = await Dns.GetHostAddressesAsync(WebSocketUrl);
_tcpClient = new TcpClient();
await _tcpClient.ConnectAsync(WebSocketUrl, Port);
_stream = _tcpClient.GetStream();
var updrageRequest = Encoding.ASCII.GetBytes(HttpUpgradeRequestString());
await _stream.WriteAsync(updrageRequest, 0, updrageRequest.Length);
using (var responseStream = new MemoryStream())
{
await _stream.CopyToAsync(responseStream);
responseStream.Position = 0;
var data = responseStream.ToArray();
var response = Encoding.ASCII.GetString(data);
}
}
private async Task DialToRemote(NetworkStream clientStream, string remoteHost, byte[] clientHello)
{
var remote = new TcpClient();
NetworkStream remoteStream;
if (_proxyHost == null || _proxyPort == null)
{
var remoteIpAddresses = await Dns.GetHostAddressesAsync(remoteHost); // 直接连接
await remote.ConnectAsync(remoteIpAddresses[0], 443);
remoteStream = remote.GetStream();
}
else
{
// 使用 HTTP 代理
var httpProxyIpAddresses = await Dns.GetHostAddressesAsync(_proxyHost);
await remote.ConnectAsync(httpProxyIpAddresses[0], _proxyPort.Value);
remoteStream = remote.GetStream();
var sb = new StringBuilder();
sb.Append($"CONNECT {remoteHost}:443 HTTP/1.0\r\n");
sb.AppendFormat("User-Agent: Acceler/{0}\r\n", Assembly.GetExecutingAssembly().GetName().Version);
sb.Append("\r\n");
var buf = Encoding.ASCII.GetBytes(sb.ToString());
await remoteStream.WriteAsync(buf, 0, buf.Length);
var receive = await ReceiveUntil(remoteStream, Encoding.ASCII.GetBytes("\r\n\r\n"));
Console.WriteLine(Encoding.Default.GetString(receive));
}
await remoteStream.WriteAsync(clientHello, 0, clientHello.Length);
remoteStream.CopyToAsync(clientStream);
await clientStream.CopyToAsync(remoteStream);
remoteStream.Close();
remote.Close();
}
static async Task SocketNetworkStreamPerf()
{
using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listener.Listen(1);
Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
using (Socket server = listener.Accept())
{
await connectTask;
using (var serverStream = new NetworkStream(server))
using (var clientStream = new NetworkStream(client))
{
Task serverCopyAll = serverStream.CopyToAsync(Stream.Null);
byte[] data = new byte[PacketLength];
new Random().NextBytes(data);
var sw = new Stopwatch();
int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
sw.Start();
var requestCount = 1_000_000;
for (int i = 0; i < requestCount; i++)
{
await clientStream.WriteAsync(data, 0, data.Length);
}
client.Shutdown(SocketShutdown.Send);
serverCopyAll.Wait();
sw.Stop();
var qps = requestCount / sw.Elapsed.TotalSeconds;
log($"SocketNetworkStreamPerf: Elapsed={sw.Elapsed} QPS={qps}");
log($" Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}\n");
}
}
}
}
/// <summary>
/// Reads from proxy network stream and copies to output.
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task InPump(NetworkStream input, Stream output, CancellationToken ct)
{
try {
await input.CopyToAsync(output, 0x10000, ct);
}
catch (OperationCanceledException) {
Console.Error.WriteLine();
}
catch (Exception ex) {
if (ex.GetSocketError() == SocketError.Closed)
{
Console.Error.Write($"Remote side closed ");
}
else if (!ct.IsCancellationRequested)
{
Console.Error.Write($"Output error: {ex.Message} ");
}
}
Console.Error.WriteLine("... output closed");
}
private async Task CopyStream(NetworkStream source, NetworkStream dest)
{
try
{
await source.CopyToAsync(dest);
}
catch (ObjectDisposedException)
{
Debug.Print("Local close");
}
catch (Exception e)
{
Console.WriteLine("Connection exception: {0}", e.Message);
}
finally
{
dest.Close();
Debug.Print("Connect close");
}
}
public async void AskForHealth()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("GET / HTTP/1.1");
builder.AppendLine($"Host: {Host}");
builder.AppendLine("Connection: close");
builder.AppendLine();
var header = Encoding.ASCII.GetBytes(builder.ToString());
try
{
TcpClient client = new TcpClient(Host, Port);
using (NetworkStream stream = client.GetStream())
using (MemoryStream memoryStream = new MemoryStream())
{
await stream.WriteAsync(header, 0, header.Length);
if (stream.DataAvailable)
{
await stream.CopyToAsync(memoryStream);
string response = Encoding.ASCII.GetString(memoryStream.GetBuffer());
if (response.Contains("200 OK"))
{
Alive = true;
}
else
{
Alive = false;
}
}
}
}
catch
{
Alive = false;
}
}
private async Task AcceptTunnelConnectionAsync()
{
try
{
_tunnelSocket = await _tunnelListener.AcceptAsync().WithTimeout(TUNNEL_WAIT_TIMEOUT);
_tunnelListener.Dispose();
Stream remoteStream = new NetworkStream(_remoteSocket);
if (_enableSsl)
{
SslStream sslStream;
if (_ignoreCertificateErrors)
{
sslStream = new SslStream(remoteStream, false, delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return(true); //ignore cert errors
});
}
else
{
sslStream = new SslStream(remoteStream);
}
await sslStream.AuthenticateAsClientAsync(_remoteEP.GetAddress()).WithTimeout(TUNNEL_WAIT_TIMEOUT);
remoteStream = sslStream;
}
Stream tunnelStream = new NetworkStream(_tunnelSocket);
_ = remoteStream.CopyToAsync(tunnelStream).ContinueWith(delegate(Task prevTask) { Dispose(); });
_ = tunnelStream.CopyToAsync(remoteStream).ContinueWith(delegate(Task prevTask) { Dispose(); });
}
catch
{
Dispose();
}
}
/// <summary>
/// Reads from stdin and copies to network stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task StdOutWriter(NetworkStream stream, CancellationToken ct)
{
try {
using (Stream stdout = Console.OpenStandardOutput()) {
await stream.CopyToAsync(stdout, 0x10000, ct);
}
}
catch (OperationCanceledException) {
Console.Error.WriteLine();
}
catch (Exception ex) {
if (ex.GetSocketError() == SocketError.Closed)
{
Console.Error.Write($"Remote side closed ");
}
else if (!ct.IsCancellationRequested)
{
Console.Error.Write($"Exception occurred on stdout {ex} ");
}
}
Console.Error.WriteLine("... stdout closed");
}
public async void AskForHealthActive()
{
if (!client.Connected)
{
ALIVE = false;
return;
}
var builder = new StringBuilder();
builder.AppendLine("GET / HTTP/1.1");
builder.AppendLine($"Host: {HOST}");
builder.AppendLine("Connection: close");
builder.AppendLine();
var header = Encoding.ASCII.GetBytes(builder.ToString());
try
{
using (NetworkStream stream = client.GetStream())
using (MemoryStream memstream = new MemoryStream())
{
await stream.WriteAsync(header, 0, header.Length);
if (stream.DataAvailable)
{
await stream.CopyToAsync(memstream);
string response = Encoding.ASCII.GetString(memstream.GetBuffer());
if (!response.Contains("200 OK"))
{
ALIVE = false;
}
}
}
}
catch { }
}
public async static Task NetworkStreamWriteAsyncCopyToAsync()
{
using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listener.Listen(1);
Task connectTask = Task.Run(() => client.Connect(listener.LocalEndPoint));
using (Socket server = listener.Accept())
{
await connectTask;
using (var serverStream = new NetworkStream(server))
using (var clientStream = new NetworkStream(client))
{
Task serverCopyAll = serverStream.CopyToAsync(Stream.Null);
byte[] data = new byte[1024];
new Random().NextBytes(data);
var sw = new Stopwatch();
int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
sw.Start();
for (int i = 0; i < 1_000_000; i++)
{
await clientStream.WriteAsync(data, 0, data.Length);
}
client.Shutdown(SocketShutdown.Send);
serverCopyAll.Wait();
sw.Stop();
Console.WriteLine($"Elapsed={sw.Elapsed} Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}");
}
}
}
}
private async Task ToStaticTransfer(CancellationToken ct, NetworkStream fromStream, NetworkStream toStream, string clientApp)
{
//单独
using (fromStream)
{
await fromStream.CopyToAsync(toStream, ct);
}
Server.Logger.Debug($"{clientApp}对客户端传输关闭。");
//byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
//try
//{
// while (true)
// {
// int bytesRead = await fromStream.ReadAsync(new Memory<byte>(buffer), ct).ConfigureAwait(false);
// if (bytesRead == 0) break;
// await toStream.WriteAsync(new ReadOnlyMemory<byte>(buffer, 0, bytesRead), ct).ConfigureAwait(false);
// }
//}
//finally
//{
// ArrayPool<byte>.Shared.Return(buffer);
//}
}
internal Task HandleTcpClient(TcpClient inboundClient, Server server)
{
logger.Trace("IN ProxyServer.HandleTcpClient");
try {
var clientPort = ((IPEndPoint)inboundClient.Client.RemoteEndPoint).Port;
var serverClient = new TcpClient(server.IP, server.Port);
Task clientTask = Task.Run(async() => {
try {
await using NetworkStream clientStream = inboundClient.GetStream();
await using NetworkStream serverStream = serverClient.GetStream();
Task clintToServerTask = clientStream.CopyToAsync(serverStream);
Task serverToClientTask = serverStream.CopyToAsync(clientStream);
await Task.WhenAny(clintToServerTask, serverToClientTask);
} catch (Exception e) {
logger.Error(e, "Streaming error occurred...");
} finally {
try {
inboundClient.Close();
serverClient.Close();
} catch (Exception e) {
logger.Error(e, "Streaming dispose error occurred...");
}
serversManager.DecrementConnections(server);
logger.Info($"IN ProxyServer.HandleTcpClient, client detached, listeningPort = \"{clientPort}\"");
Interlocked.Decrement(ref connectedClients);
logger.Info($"CURRENT CLIENTS = \"{connectedClients}\"");
}
});
return(clientTask);
} catch (Exception e) {
logger.Error(e, "IN ProxyServer.HandleTcpClient");
return(null);
} finally {
logger.Trace("OUT ProxyServer.HandleTcpClient");
}
}
/// <summary>
/// Begin reading the stream, and either displaying it or writing it to a file.
/// </summary>
/// <param name="file">Optional filename.</param>
/// <returns></returns>
private async Task readStream(string file = null)
{
if (file != null)
{
try
{
var bw = new BinaryWriter(new FileStream(file, FileMode.Create));
_logger.Info("Writing stream to file");
await _stream.CopyToAsync(bw.BaseStream);
bw?.Close();
_logger.Info($"Done writing to file {file}");
}
catch (IOException ex)
{
_logger.Error(ex.Message);
}
}
else
{
_ = _display?.startDisplay();
}
}
private async Task <string> ToStaticTransfer(CancellationToken ct, NetworkStream fromStream, NetworkStream toStream, string signal, Func <byte[], Task <bool> > beforeTransfer = null)
{
await fromStream.CopyToAsync(toStream, 4096, ct);
return(signal);
}
private async Task ToStaticTransfer(CancellationToken ct, NetworkStream fromStream, NetworkStream toStream, Func <byte[], Task <bool> > beforeTransferHandle = null)
{
await fromStream.CopyToAsync(toStream, ct);
}
