|
public WriteAsync ( byte buffer, int offset, int size, |
||
| buffer | byte | |
| offset | int | |
| size | int | |
| cancellationToken | ||
| return | System.Threading.Task | |
public async Task SendMessageAsync(Message message)
{
try
{
await semaphore.DoAsync(async () =>
{
using (var stream = new NetworkStream(this.socket))
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var byteStream = new MemoryStream();
NetworkEncoder.EncodeMessage(byteStream, message);
var messageBytes = byteStream.ToArray();
await stream.WriteAsync(messageBytes, 0, messageBytes.Length);
stopwatch.Stop();
//Debug.WriteLine("-------------------------");
//Debug.WriteLine(string.Format("Sent {0} in {1} ms\nPayload: {2}", message.Command, stopwatch.ElapsedMilliseconds, message.Payload.ToHexDataString()));
}
});
}
catch (Exception e)
{
Fail(e);
}
}
private async Task AuthenticateV5(NetworkStream stream, CancellationToken cancellationToken)
{
await stream.WriteAsync(new byte[] { 5, 2, 0, 2 }, 0, 4, cancellationToken);
switch ((await ReadBytes(stream, 2, cancellationToken)).Last())
{
case 0:
break;
case 2:
await stream.WriteAsync(new byte[] { 1, 0, 0 }, 0, 3, cancellationToken);
byte[] buffer = new byte[2];
int received = 0;
while (received != 2)
{
received += await stream.ReadAsync(buffer, received, 2 - received, cancellationToken);
}
if (buffer[1] != 0)
{
throw new SocksRequestFailedException("Authentication failed");
}
break;
case 255:
throw new SocksRequestFailedException("No authentication method accepted.");
default:
throw new SocksRequestFailedException();
}
}
public async Task <bool> Send(byte[] data)
{
if (!disposed)
{
if (m_Client.Connected)
{
byte[] dataToSend = new byte[data.Length + 8];
Array.Copy(BitConverter.GetBytes(dataToSend.Length), dataToSend, 4); // PackageLength
Array.Copy(data, 0, dataToSend, 4, data.Length); // Messages
Array.Copy(new byte[] { 0xCC, 0xCC, 0xCC, 0xCC }, 0, dataToSend, data.Length + 4, 4); // PostAmble
try
{
await m_Socket.WriteAsync(dataToSend, 0, dataToSend.Length);
}
catch (Exception)
{
disposed = true;
}
return(true);
}
}
return(false);
}
public async Task V5(NetworkStream stream, Uri uri, CancellationToken cancellationToken)
{
await AuthenticateV5(stream, cancellationToken);
byte[] data = new byte[10] { 5, 1, 0, 1, 0, 0, 0, 0, 0, 0 };
Array.Copy(GetIpAddress(uri.Host).GetAddressBytes(), 0, data, 4, 4);
Array.Copy(PortToBytes((ushort)uri.Port), 0, data, 8, 2);
await stream.WriteAsync(data, 0, data.Length, cancellationToken);
byte[] buffer = await ReadBytes(stream, 4, cancellationToken);
if (buffer[1] != 0)
{
throw new SocksRequestFailedException();
}
switch (buffer[3])
{
case 1:
await ReadBytes(stream, 6, cancellationToken);
break;
case 3:
await ReadBytes(stream, (await ReadBytes(stream, 1, cancellationToken)).Single() + 2, cancellationToken);
break;
case 4:
await ReadBytes(stream, 18, cancellationToken);
break;
default:
throw new SocksRequestFailedException();
}
}
async Task handleNetworkStream(NetworkStream stream)
{
var buffer = new byte[bufferSize];
while (true)
{
if (!await fill(stream, buffer, headerSize).ConfigureAwait(false))
{
Interlocked.Increment(ref CloseByInvalidStream);
return;
}
var length = BitConverter.ToInt32(buffer, 0);
if (length == 0)
{
Interlocked.Increment(ref CloseByPeerCount);
return;
}
if (!await fill(stream, buffer, length).ConfigureAwait(false))
{
Interlocked.Increment(ref CloseByInvalidStream);
return;
}
await stream.WriteAsync(buffer, 0, length).ConfigureAwait(false);
Interlocked.Increment(ref WriteCount);
}
}
/// <summary>
/// input stream에 있는 문자열을 output stream에 맞도록 변환하여 전달한다
/// 만약 stream이 연결이 끊켰을 경우 false를 반환한다
/// 에러가 난 경우 무시한다.
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="input_codepage"></param>
/// <param name="output_codepage"></param>
/// <returns></returns>
protected async Task<bool> ConvertStream(NetworkStream input, NetworkStream output, int input_codepage, int output_codepage)
{
byte[] buf = new byte[8196];
int read_bytes = await input.ReadAsync(buf, 0, 8196);
if (read_bytes == 0)
{
return false;
}
try
{
string converted_string = Encoding.GetEncoding(input_codepage).GetString(buf, 0, read_bytes);
byte[] converted_buf = Encoding.GetEncoding(output_codepage).GetBytes(converted_string);
await output.WriteAsync(converted_buf, 0, converted_buf.Count());
}
catch (Exception e)
{
// 인코딩 변환 실패는 에러만 출력하고 그냥 무시한다.
Console.WriteLine("ConvertStream Fail: " + e.Message);
return true;
}
return true;
}
public void AcceptingMessagesFromClient()
{
Receive<SendMessage>(message => // Send message text to the client as ASCII.
{
byte[] buffer = Encoding.ASCII.GetBytes(message.Text);
_tcpStream = _tcpClient.GetStream();
_tcpStream.WriteAsync(buffer, 0, buffer.Length);
});
Receive<WaitForNextChunk>(message =>
{
var buffer = new byte[BufferSize];
_tcpStream.ReadAsync(buffer, 0, BufferSize).ContinueWith(task =>
{
if (task.Status == TaskStatus.Faulted)
{
// This happens if the socket is closed server side.
return null;
}
//TODO: Check for other error states before reading the result
int bytesReceived = task.Result;
// Note here we start with the previously received chunk.
var text = message.Buffer + Encoding.ASCII.GetString(buffer, 0, bytesReceived);
return new ReceivedChunk(text);
},
TaskContinuationOptions.AttachedToParent &
TaskContinuationOptions.ExecuteSynchronously)
.PipeTo(Self);
});
Receive<ReceivedChunk>(message =>
{
// Check if we have a complete message, if so send to client (who?)
MessageInfo info = _messageSplitter(message.Text);
// We received some bytes which contains (possibly multiple) messages.
foreach (string msg in info.CompleteMessages)
{
_listener.Tell(new ReceivedMessage(msg));
}
// And possibly also received a partial message at the end,
// in which case we keep it to prefix the subsequently
// received data.
if (info.RemainingText != null)
{
Self.Tell(new WaitForNextChunk(info.RemainingText));
}
});
Receive<Shutdown>(message =>
{
BecomeShutDown();
});
}
public async Task<long> WriteAsync(Stream input, TcpResponseHeader header = null)
{
var stream = new NetworkStream(_socket);
var len = input.Length - input.Position;
if (header == null) header = new TcpResponseHeader(() => len);
var head = header.GetBytes();
await stream.WriteAsync(head, 0, head.Length);
await input.CopyToAsync(stream, _writeBuffer.Length);
return len + head.Length;
}
public static async Task Sender(NetworkStream stream, CancellationTokenSource cts)
{
WriteLine("Sender task");
while (true)
{
WriteLine("enter a string to send, shutdown to exit");
string line = ReadLine();
byte[] buffer = Encoding.UTF8.GetBytes($"{line}\r\n");
await stream.WriteAsync(buffer, 0, buffer.Length);
await stream.FlushAsync();
if (string.Compare(line, "shutdown", ignoreCase: true) == 0)
{
cts.Cancel();
WriteLine("sender task closes");
break;
}
}
}
public static async Task SendMsg(object message, NetworkStream stream)
{
MemoryStream memstm = new MemoryStream();
BinaryFormatter fmtr = new BinaryFormatter();
memstm.Seek(MSG_HDR_SIZE, SeekOrigin.Begin);
// serialize object graph to stream
fmtr.Serialize(memstm, message);
// get the buffer from the memory stream
byte[] membuf = memstm.ToArray();
// get the byte array with the message size
byte[] lenbuf = BitConverter.GetBytes(membuf.Length);
// copy the length to the first four bytes of the message
for (int i = 0; i < lenbuf.Length; i++)
membuf[i] = lenbuf[i];
// send the message synchronously
await stream.WriteAsync(membuf, 0, membuf.Length);
}
public async Task V4(NetworkStream stream, Uri uri, CancellationToken cancellationToken)
{
try
{
byte[] data = new byte[9] { 4, 1, 0, 0, 0, 0, 0, 0, 0 };
Array.Copy(PortToBytes((ushort) uri.Port), 0, data, 2, 2);
Array.Copy(GetIpAddress(uri.Host).GetAddressBytes(), 0, data, 4, 4);
await stream.WriteAsync(data, 0, data.Length, cancellationToken);
if ((await ReadBytes(stream, 8, cancellationToken))[1] != 90)
{
throw new SocksRequestFailedException("Negotiation failed.");
}
}
catch
{
throw new SocksRequestFailedException();
}
}
/// <summary>
/// Connect to the EV3 brick.
/// </summary>
/// <returns></returns>
public async Task ConnectAsync()
{
_client = new TcpClient();
await _client.ConnectAsync(_address, 5555);
_stream = _client.GetStream();
// unlock the brick (doesn't actually need serial number?)
byte[] buff = Encoding.UTF8.GetBytes(UnlockCommand);
await _stream.WriteAsync(buff, 0, buff.Length);
// read the "Accept:EV340\r\n\r\n" response
int read = await _stream.ReadAsync(buff, 0, buff.Length);
string response = Encoding.UTF8.GetString(buff, 0, read);
if(string.IsNullOrEmpty(response))
throw new Exception("LEGO EV3 brick did not respond to the unlock command.");
_tokenSource = new CancellationTokenSource();
Task t = Task.Factory.StartNew(async () =>
{
while(!_tokenSource.IsCancellationRequested)
{
// if the stream is valid and ready
if(_stream != null && _stream.CanRead)
{
await _stream.ReadAsync(_sizeBuffer, 0, _sizeBuffer.Length);
short size = (short)(_sizeBuffer[0] | _sizeBuffer[1] << 8);
if(size == 0)
return;
byte[] report = new byte[size];
await _stream.ReadAsync(report, 0, report.Length);
if (ReportReceived != null)
ReportReceived(this, new ReportReceivedEventArgs { Report = report });
}
}
}, _tokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Current);
}
public async Task<HttpListenerWebSocketContext> AcceptWebSocketAsync (string subProtocol, int receiveBufferSize, TimeSpan keepAliveInterval)
{
if (subProtocol != null && subProtocol == "") {
throw new ArgumentException ("subProtocol must not empty string");
}
if (receiveBufferSize < 16 || receiveBufferSize > 64 * 1024) {
throw new ArgumentOutOfRangeException ("receiveBufferSize should be >=16 and <=64K bytes");
}
if (!request.IsWebSocketRequest) {
throw new WebSocketException ("Request is not WebSocket Handshake");
}
string secKey = request.Headers ["Sec-WebSocket-Key"];
if (secKey == null) {
throw new WebSocketException ("Request doesn't contain Sec-WebSocket-Key header");
}
string acceptKey = StreamWebSocket.CreateAcceptKey (secKey);
ArraySegment<byte> preloaded;
var stream = new NetworkStream (cnc.Hijack (out preloaded));
string header = "HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n" +
"Sec-WebSocket-Accept: " + acceptKey + "\r\n\r\n";
var headerBytes = Encoding.ASCII.GetBytes (header);
await stream.WriteAsync (headerBytes, 0, headerBytes.Length);
var ws = new StreamWebSocket (stream, stream, null, subProtocol, false, preloaded);
return new HttpListenerWebSocketContext (ws, request, user);
}
private async Task ProcessSentTasksAsync(NetworkStream netStream, SocketPayloadSendTask sendTask)
{
if (sendTask == null) return;
using (sendTask)
{
var failed = false;
var sw = Stopwatch.StartNew();
try
{
sw.Restart();
StatisticsTracker.IncrementGauge(StatisticGauge.ActiveWriteOperation);
if (OnWriteToSocketAttempt != null) OnWriteToSocketAttempt(sendTask.Payload);
await netStream.WriteAsync(sendTask.Payload.Buffer, 0, sendTask.Payload.Buffer.Length).ConfigureAwait(false);
sendTask.Tcp.TrySetResult(sendTask.Payload);
}
catch (Exception ex)
{
failed = true;
if (_disposeToken.IsCancellationRequested)
{
var exception = new ObjectDisposedException("Object is disposing.");
sendTask.Tcp.TrySetException(exception);
throw exception;
}
sendTask.Tcp.TrySetException(ex);
throw;
}
finally
{
StatisticsTracker.DecrementGauge(StatisticGauge.ActiveWriteOperation);
StatisticsTracker.CompleteNetworkWrite(sendTask.Payload, sw.ElapsedMilliseconds, failed);
}
}
}
private static async Task CommunicateWithClientUsingNetworkStreamAsync(Socket socket)
{
try
{
using (var stream = new NetworkStream(socket, ownsSocket: true))
{
bool completed = false;
do
{
byte[] readBuffer = new byte[1024];
int read = await stream.ReadAsync(readBuffer, 0, 1024);
string fromClient = Encoding.UTF8.GetString(readBuffer, 0, read);
WriteLine($"read {read} bytes: {fromClient}");
if (string.Compare(fromClient, "shutdown", ignoreCase: true) == 0)
{
completed = true;
}
byte[] writeBuffer = Encoding.UTF8.GetBytes($"echo {fromClient}");
await stream.WriteAsync(writeBuffer, 0, writeBuffer.Length);
} while (!completed);
}
WriteLine("closed stream and client socket");
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
public async Task writeMessageAsync(NetworkStream stream, string message, CancellationToken cancelToken, bool addDefaultMessageType = false)
{
byte[] msg;
if (addDefaultMessageType)
msg = Encoding.ASCII.GetBytes("<" + m_defaultMessageType + ">" + message + "</" + m_defaultMessageType + ">");
else
msg = Encoding.ASCII.GetBytes(message);
try
{
await stream.WriteAsync(msg, 0, msg.Length,cancelToken);
}
catch(OperationCanceledException)
{
logMessage("Write operation cancelled");
}
catch(Exception ex)
{
logMessage("Unhandled exception in writeMessageAsync");
logMessage(ex.ToString());
}
}
public async Task ClientSend(NetworkStream networkStream ,ServerClientMsg objectToClient)
{
var xmlSerializer = new XmlSerializer(objectToClient.GetType());
StringBuilder SerializedSb = new StringBuilder();
using (var stringWriter = new StringWriter())
{
xmlSerializer.Serialize(stringWriter, objectToClient);
SerializedSb.Append(stringWriter.ToString());
}
var serializedString = SerializedSb.ToString();
var MsgToSend = Encoding.UTF8.GetBytes(serializedString);
await networkStream.WriteAsync(MsgToSend, 0, MsgToSend.Length);
}
public async Task WriteToStreamAsync(NetworkStream stream)
{
byte[] packet = new byte[TotalPacketSize];
BitConverter.GetBytes(PacketSize).CopyTo(packet, 0);
BitConverter.GetBytes((int)Opcode).CopyTo(packet, 4);
BitConverter.GetBytes((int)Type).CopyTo(packet, 8);
Data.CopyTo(packet, 12);
packet[packet.Length - 1] = ((byte)0x00);
Console.WriteLine("Sent {0}", DataAsString());
await stream.WriteAsync(packet, 0, TotalPacketSize);
}
public static async void Send(NetworkStream stream, string message) {
try {
var data = Encoding.UTF8.GetBytes(message);
await stream.WriteAsync(data, 0, data.Length);
WriteLine($"[INFO] - Send packet -> {message}");
} catch (Exception) {
WriteLine("[ERROR] - If you're having errors connecting, please reload the ixat.");
}
}
public async Task ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
_state = WebSocketState.Connecting;
await _connection.ConnectAsync(uri.Host, uri.Port);
_stream = _connection.GetStream();
var secKey = Convert.ToBase64String(Encoding.ASCII.GetBytes(Guid.NewGuid().ToString().Substring(0, 16)));
var expectedAccept = HandshakeHelpers.CreateResponseKey(secKey);
var headerString =
$"GET {uri.PathAndQuery} HTTP/1.1\r\n" +
$"Host: {uri.Host}\r\n" +
"Connection: Upgrade\r\n" +
"Upgrade: websocket\r\n" +
"Sec-WebSocket-Version: 13\r\n" +
$"Sec-WebSocket-Protocol: {_subProtocol}\r\n" +
$"Sec-WebSocket-Key: {secKey}\r\n\r\n";
var bytes = Encoding.UTF8.GetBytes(headerString);
await _stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
await _stream.FlushAsync(cancellationToken);
var buffer = new byte[1024];
var resultLenth = await _stream.ReadAsync(buffer, 0, 1024, cancellationToken);
var resultString = new StringReader(Encoding.UTF8.GetString(buffer, 0, resultLenth));
var respCode = 0;
var headers = new Dictionary<string, string>();
var line = resultString.ReadLine();
while (line != null)
{
if (line.StartsWith("HTTP/1.1 ") && line.Length > 11)
respCode = Convert.ToInt16(line.Substring(9, 3));
else
{
var items = line.Split(new[] { ':' }, 2);
if (items.Length == 2)
headers[items[0]] = items[1].TrimStart();
}
line = resultString.ReadLine();
}
if (respCode != (int) HttpStatusCode.SwitchingProtocols)
{
throw new WebSocketException($"The server returned status code '{respCode}' when status code '101' was expected");
}
if (!string.Equals(headers["Upgrade"], "WebSocket", StringComparison.OrdinalIgnoreCase)
|| !string.Equals(headers["Connection"], "Upgrade", StringComparison.OrdinalIgnoreCase)
|| !string.Equals(headers["Sec-WebSocket-Accept"], expectedAccept))
{
throw new WebSocketException("HTTP header error during handshake");
}
_state = WebSocketState.Open;
if (_keepAliveInterval != Timeout.InfiniteTimeSpan)
{
_keepAliveTimer = new Timer(SendKeepAlive, this, _keepAliveInterval, _keepAliveInterval);
}
}
/// <summary>
/// Обработка запроса: отправка на сервер, получение результата
/// </summary>
/// <param name="request"></param>
/// <param name="networkStream"></param>
/// <returns></returns>
private static async Task<string> ProcessRequest(string request, NetworkStream networkStream)
{
// отсекаем пустые запросы к серверу. Запрос c null сознательно не отсекаем - флаг отключения клиента
if (string.IsNullOrEmpty(request) && request != null)
{
return null;
}
byte[] requestBytes = Encoding.ASCII.GetBytes(request);
await networkStream.WriteAsync(requestBytes, 0, requestBytes.Length);
var buffer = new byte[8192];
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
return Encoding.ASCII.GetString(buffer, 0, byteCount);
}
internal static ValueTask WriteAsync(this NetworkStream stream, ReadOnlyMemory <byte> buffer)
{
return(stream.WriteAsync(buffer, default));
}
async Task SendAsync(NetworkStream stream, string data)
{
var buffer = Encoding.UTF8.GetBytes(data);
await stream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
}
private async Task WriteStringAsync(NetworkStream stream, string str)
{
if (str.Length > 255)
{
str = str.Substring(0, 255);
}
await stream.WriteByteAsync((byte) str.Length);
var buffer = Encoding.ASCII.GetBytes(str);
await stream.WriteAsync(buffer, 0, buffer.Length);
}
private async Task ProcessSentTasksAsync(NetworkStream netStream, SocketPayloadSendTask sendTask)
{
if (sendTask == null) return;
using (sendTask)
{
var failed = false;
var sw = Stopwatch.StartNew();
try
{
sw.Restart();
if (UseStatisticsTracker())
{
StatisticsTracker.IncrementGauge(StatisticGauge.ActiveWriteOperation);
}
if (OnWriteToSocketAttempt != null) OnWriteToSocketAttempt(sendTask.Payload);
_log.DebugFormat("Sending data for CorrelationId:{0} Connection:{1}", sendTask.Payload.CorrelationId, Endpoint);
await netStream.WriteAsync(sendTask.Payload.Buffer, 0, sendTask.Payload.Buffer.Length, _disposeToken.Token).ConfigureAwait(false);
_log.DebugFormat("Data sent to CorrelationId:{0} Connection:{1}", sendTask.Payload.CorrelationId, Endpoint);
sendTask.Tcp.TrySetResult(sendTask.Payload);
}
catch (Exception ex)
{
failed = true;
var wrappedException = WrappedException(ex);
sendTask.Tcp.TrySetException(wrappedException);
throw;
}
finally
{
if (UseStatisticsTracker())
{
StatisticsTracker.DecrementGauge(StatisticGauge.ActiveWriteOperation);
StatisticsTracker.CompleteNetworkWrite(sendTask.Payload, sw.ElapsedMilliseconds, failed);
}
}
}
}
private async Task WriteMemoryStreamAsync(NetworkStream ns, MemoryStream ms, int offset, int length, CancellationToken cancellationToken = default(CancellationToken)) {
await ns.WriteAsync(BitConverter.GetBytes(length), 0, sizeof(int), cancellationToken).ConfigureAwait(false);
await ns.WriteAsync(ms.GetBuffer(), offset, length, cancellationToken).ConfigureAwait(false);
outboundBytesAggregator.Put(sizeof(int) + length);
}
public async Task SendMessageAsync(Message message)
{
try
{
await semaphore.DoAsync(async () =>
{
using (var stream = new NetworkStream(socket))
{
var stopwatch = Stopwatch.StartNew();
using (var byteStream = new MemoryStream())
using (var writer = new BinaryWriter(byteStream))
{
NodeEncoder.EncodeMessage(writer, message);
var messageBytes = byteStream.ToArray();
await stream.WriteAsync(messageBytes, 0, messageBytes.Length);
}
stopwatch.Stop();
if (logger.IsTraceEnabled)
logger.Trace($"Sent {message.Command} in {stopwatch.ElapsedMilliseconds} ms\nPayload: {message.Payload.ToArray().ToHexDataString()}");
}
});
}
catch (Exception e)
{
Fail(e);
}
}
static async void forward(string prefix, NetworkStream from, NetworkStream to, Action close)
{
var buffer = new byte[1024 * 1024];
do
{
// why no implict buffer?
var count = await from.ReadAsync(buffer, 0, buffer.Length);
Console.WriteLine(prefix + count);
// I/System.Console( 6199): > 393
//I/System.Console( 6199): < 85
//I/System.Console( 6199): < -1
if (count < 0)
{
close();
return;
}
await to.WriteAsync(buffer, 0, count);
}
while (true);
}