|
public ReadAsync ( byte buffer, int offset, int size, |
||
| buffer | byte | |
| offset | int | |
| size | int | |
| cancellationToken | ||
| return | Task |
|
private async Task<String> ReadRequest(NetworkStream stream)
{
var encoding = Encoding.UTF8;
var i = 0;
var bytes = new byte[1024];
var sb = new StringBuilder();
while ((i = await stream.ReadAsync(bytes, 0, bytes.Length)) != 0)
{
sb.Append(encoding.GetString(bytes, 0, i));
if (!stream.DataAvailable) break;
}
return sb.ToString();
}
public async Task<PingPayload> Ping(){
NetworkStream = null;
WriteBuffer.Clear();
ReadOffset = 0;
var client = new TcpClient();
await client.ConnectAsync(Host, Port);
if (!client.Connected)
return null;
NetworkStream = client.GetStream();
/*
* Send a "Handshake" packet
* http://wiki.vg/Server_List_Ping#Ping_Process
*/
WriteVarInt(47);
WriteString(Host);
WriteShort(Port);
WriteVarInt(1);
await Flush(0);
/*
* Send a "Status Request" packet
* http://wiki.vg/Server_List_Ping#Ping_Process
*/
await Flush(0);
var message = new List<byte>();
var buf = new byte[1024];
var bytes = await NetworkStream.ReadAsync(buf, 0, buf.Length, CancellationToken);
message.AddRange(new ArraySegment<byte>(buf, 0, bytes));
var length = ReadVarInt(buf);
var left = length - (message.Count - ReadOffset);
while (left > 0) {
buf = new byte[1024];
bytes = await NetworkStream.ReadAsync(buf, 0, buf.Length, CancellationToken);
message.AddRange(new ArraySegment<byte>(buf, 0, bytes));
left -= bytes;
}
client.Close();
ReadOffset = 0;
var buffer = message.ToArray();
length = ReadVarInt(buffer);
ReadVarInt(buffer); // packetID
var jsonLength = ReadVarInt(buffer);
var json = ReadString(buffer, jsonLength);
var ping = JsonConvert.DeserializeObject<PingPayload>(json);
ping.Motd = ping.Motd != null ? CleanMotd(ping.Motd) : null;
return ping;
}
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 <byte[]> Receive()
{
if (!disposed)
{
// Reusable SocketAsyncEventArgs and awaitable wrapper
try
{
var bytes = await m_Socket.ReadAsync(internalBuffer, 0, internalBuffer.Length);
if (bytes > 0)
{
byte[] queueBuffer = new byte[bytes];
Array.Copy(internalBuffer, queueBuffer, bytes);
return(queueBuffer);
}
}
catch (Exception)
{
disposed = true;
}
}
return(null);
}
/// <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;
}
private async void ReadAsync(NetworkStream stream)
{
byte[] buffer = new byte[100];
while (true)
{
try
{
int length = await stream.ReadAsync(buffer, 0, buffer.Length);
Invoke(new MethodInvoker(delegate
{
outputText.Append(buffer, length);
}));
}
catch
{
if (this.Visible)
{ // we're not being closed
Invoke(new MethodInvoker(delegate
{
Stop();
}));
}
break;
}
}
}
private async void buttonConnect_Click(object sender, RibbonControlEventArgs e)
{
if (!string.IsNullOrEmpty(comboBoxIp.Text))
{
try {
if (listner != null)
{
listner.Stop();
listner = null;
}
listner = new TcpListener(IPAddress.Parse(comboBoxIp.Text),port);
listner.Start();
labelStatus.Label = "データ待機中";
client = await listner.AcceptTcpClientAsync();
stream = client.GetStream();
byte[] buff = new byte[1];
var read = await stream.ReadAsync(buff, 0, buff.Length);
ExecuteCommand(buff[0]);
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
else
{
MessageBox.Show("IPを選択してください");
}
}
// read memory buffer helper
async static Task<byte[]>ReadMessage(NetworkStream s)
{
MemoryStream ms = new System.IO.MemoryStream();
byte[] buffer = new byte[0x1000];
do { ms.Write(buffer, 0, await s.ReadAsync(buffer, 0, buffer.Length)); }
while (s.DataAvailable);
return ms.ToArray();
}
// Receive a message synchronously
public static async Task<object> RecvMsg(NetworkStream stream)
{
byte[] lenbuf = new byte[MSG_HDR_SIZE];
// receive message length
int bytesRead = await stream.ReadAsync(lenbuf, 0, lenbuf.Length);
if (bytesRead != MSG_HDR_SIZE)
throw new ApplicationException(String.Format("RecvMessage: unexpected message length size with {0} bytes", bytesRead));
// receive message payload
return await RecvMsg(stream, lenbuf);
}
/// <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 static void Run()
{
var socket = SocketBuilder.GetSocket();
var networkStream = new NetworkStream(socket);
var buffer = new byte[0x1000];
// begin
var task = networkStream.ReadAsync(buffer, 0, 1);
// end
task.Wait();
Logger.Log("Byte: {0}", buffer[0]);
}
// Receive message payload synchronously, after length has been received
private static async Task<object> RecvMsg(NetworkStream stream, byte[] lenbuf)
{
// compute message length
int memlen = BitConverter.ToInt32(lenbuf, 0) - MSG_HDR_SIZE;
// allocate a byte array for the remainder of message
byte[] membuf = new byte[memlen];
// receive the remainder of message
int bytesRead = 0;
while (bytesRead < memlen)
{
bytesRead += await stream.ReadAsync(membuf, bytesRead, memlen - bytesRead);
}
// create a stream from message content and get the object graph
MemoryStream memstm = new MemoryStream(membuf);
BinaryFormatter fmtr = new BinaryFormatter();
return fmtr.Deserialize(memstm);
}
protected async Task<byte[]> ReceiveAsync(NetworkStream stream)
{
try
{
int len = await stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);
stream.Flush();
// 异步接收回答
if (len > 0)
{
return CheckReplyDatagram(len);
}
return null;
}
catch (Exception err)
{
AddInfo("receive exception: " + err.Message);
CloseClientSocket();
return null;
}
}
private async Task<int> ReadAsync(NetworkStream stream, byte[] buffer, int count)
{
var timeout = Task.Delay(SocksTimeout);
var readTask = stream.ReadAsync(buffer, 0, count);
var completed = await Task.WhenAny(timeout, readTask).ConfigureAwait(false);
if (completed == readTask)
{
int read = await readTask; // so we can throw exceptions
if (read < 2)
{
throw new SocksException("Unable to negotiate with the proxy.");
}
else
{
return read;
}
}
else
{
throw new SocksException("The proxy did not respond in a timely manner.");
}
}
//public void readFromNetworkStream(TcpClient client, NetworkStream stream)
//{
// discardProcessedData();
// //read if there's something to read and if we have available storage
// do
// {
// //CJobDispatcher.checkConnection(client);
// if (stream.DataAvailable && m_bytesInBuffer < m_maxChunkSize)
// {
// m_bytesInBuffer += stream.Read(m_buffer, m_bytesInBuffer, m_maxChunkSize - m_bytesInBuffer);
// }
// if (m_bytesInBuffer == 0) Thread.Sleep(200);
// } while (m_bytesInBuffer == 0);
//}
public async Task<int> readFromNetworkStreamAsync(TcpClient client, NetworkStream stream,CancellationToken cancelToken)
{
int numBytesRead= 0;
discardProcessedData();
//read if there's something to read and if we have available storage
try { numBytesRead = await stream.ReadAsync(m_buffer, m_bytesInBuffer, m_maxChunkSize - m_bytesInBuffer, cancelToken); }
catch (OperationCanceledException) { logMessage("async read from network stream cancelled"); }
m_bytesInBuffer += numBytesRead;
return numBytesRead;
}
public async Task<ServerClientMsg> ClientReceive(NetworkStream networkStream)
{
var ReadBytes = new byte[8192];
ServerClientMsg ReceivedObject = new ServerClientMsg();
int BytesRead = await networkStream.ReadAsync(ReadBytes, 0, ReadBytes.Length);
if (BytesRead > 0)
{
ClientSb.Append(Encoding.UTF8.GetString(ReadBytes, 0, BytesRead));
var ReceivedMsg = ClientSb.ToString();
if (ReceivedMsg.IndexOf("</TcpMsg>") > -1)
{
XmlSerializer xmlS = new XmlSerializer(typeof(ServerClientMsg));
using (var stringReader = new StringReader(ReceivedMsg))
{
ReceivedObject = (ServerClientMsg)xmlS.Deserialize(stringReader);
}
ClientSb.Clear();
}
}
return ReceivedObject;
}
public static async Task<Packet> ReadFromStreamAsync(NetworkStream stream)
{
Packet packet = new Packet();
byte[] sizeBuffer = new byte[4];
stream.Read(sizeBuffer, 0, 4);
packet.PacketSize = BitConverter.ToInt32(sizeBuffer, 0);
byte[] packetBuffer = new byte[packet.PacketSize];
if(packet.PacketSize != 0)
{
int readProgress = 0;
while(readProgress < packet.PacketSize)
{
int read = await stream.ReadAsync(packetBuffer, readProgress, packet.PacketSize - readProgress);
readProgress += read;
if(read == 0)
{
throw new Exception("NetworkStream failed to read data. Connection may have been lost!");
}
}
}
packet.Opcode = (Opcode)BitConverter.ToInt32(packetBuffer, 0);
packet.Type = (PacketType)BitConverter.ToInt32(packetBuffer, 4);
Array.Copy(packetBuffer, 8, packet.Data, 0, packet.DataSize);
Console.WriteLine("Recieved {0}", packet.DataAsString());
return packet;
}
public static async Task Receiver(NetworkStream stream, CancellationToken token)
{
try
{
stream.ReadTimeout = 5000;
WriteLine("Receiver task");
byte[] readBuffer = new byte[ReadBufferSize];
while (true)
{
Array.Clear(readBuffer, 0, ReadBufferSize);
int read = await stream.ReadAsync(readBuffer, 0, ReadBufferSize, token);
string receivedLine = Encoding.UTF8.GetString(readBuffer, 0, read);
WriteLine($"received {receivedLine}");
}
}
catch (OperationCanceledException ex)
{
WriteLine(ex.Message);
}
}
/// <summary>
/// Reads from the stream with provided timeout
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <param name="buffer">The byte buffer</param>
/// <param name="offset">The stream offset</param>
/// <param name="length">The number of bytes to read</param>
/// <param name="timeout">The timeout</param>
/// <returns>The number of read bytes</returns>
private async Task<int> ReadWithTimeout(
NetworkStream stream,
byte[] buffer,
int offset,
int length,
TimeSpan timeout)
{
var tokenSource = new CancellationTokenSource();
var ct = tokenSource.Token;
var task = stream.ReadAsync(buffer, offset, length, ct);
if (await Task.WhenAny(task, Task.Delay(timeout, ct)) == task)
{
tokenSource.Cancel();
return task.Result;
}
tokenSource.Cancel();
throw new ParcelTimeoutException { Notification = this };
}
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);
}
}
async Task<bool> fill(NetworkStream stream, byte[] buffer, int rest)
{
if (rest > buffer.Length)
{
return false;
}
int offset = 0;
while (rest > 0)
{
var length = await stream.ReadAsync(buffer, offset, rest).ConfigureAwait(false);
Interlocked.Increment(ref ReadCount);
if (length == 0)
{
return false;
}
rest -= length;
offset += length;
}
return true;
}
private async Task ProcessReadTaskAsync(NetworkStream netStream, SocketPayloadReadTask readTask)
{
using (readTask)
{
try
{
if (UseStatisticsTracker())
{
StatisticsTracker.IncrementGauge(StatisticGauge.ActiveReadOperation);
}
var readSize = readTask.ReadSize;
var result = new List<byte>(readSize);
var bytesReceived = 0;
while (bytesReceived < readSize)
{
readSize = readSize - bytesReceived;
var buffer = new byte[readSize];
if (OnReadFromSocketAttempt != null) OnReadFromSocketAttempt(readSize);
bytesReceived = await netStream.ReadAsync(buffer, 0, readSize, readTask.CancellationToken).ConfigureAwait(false);
if (OnBytesReceived != null) OnBytesReceived(bytesReceived);
if (bytesReceived <= 0)
{
using (_client)
{
_client = null;
if (_disposeToken.IsCancellationRequested) { return; }
throw new BrokerConnectionException(string.Format("Lost connection to server: {0}", _endpoint), _endpoint);
}
}
result.AddRange(buffer.Take(bytesReceived));
}
readTask.Tcp.TrySetResult(result.ToArray());
}
catch (Exception ex)
{
if (_disposeToken.IsCancellationRequested)
{
var exception = new ObjectDisposedException(string.Format("Object is disposing (KafkaTcpSocket for endpoint: {0})", Endpoint));
readTask.Tcp.TrySetException(exception);
throw exception;
}
if (ex is BrokerConnectionException)
{
readTask.Tcp.TrySetException(ex);
if (_disposeToken.IsCancellationRequested) return;
throw;
}
//if an exception made us lose a connection throw disconnected exception
if (_client == null || _client.Connected == false)
{
var exception = new BrokerConnectionException(string.Format("Lost connection to server: {0}", _endpoint), _endpoint);
readTask.Tcp.TrySetException(exception);
throw exception;
}
readTask.Tcp.TrySetException(ex);
if (_disposeToken.IsCancellationRequested) return;
throw;
}
finally
{
if (UseStatisticsTracker())
{
StatisticsTracker.DecrementGauge(StatisticGauge.ActiveReadOperation);
}
}
}
}
public async Task<byte[]> GetRawRequestAsync(NetworkStream stream)
{
Requires.NotNull(stream, "stream");
if (!stream.CanRead)
{
throw new IOException();
}
var buffer = new byte[DefaultBufferSize];
using (var memoryStream = new MemoryStream(DefaultBufferSize))
{
while (stream.DataAvailable)
{
int read = await stream.ReadAsync(buffer, 0, buffer.Length);
// resize a raw request array
await memoryStream.WriteAsync(buffer, 0, read);
}
return memoryStream.ToArray();
}
}
/// <summary>
/// Extend the buffer size by BufferSegment class each time, that avoid the copy of buffer.
/// In buffer will grow when it is remaining buffer is less than 512 bytes.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static async Task ProcessLineWithAdvancedGrowthBufferAndBufferRecycleAsync(this NetworkStream stream)
{
const int minimumBufferSize = 512;
var segments = new List <BufferSegment>();
// The index of consumed bytes in the first segment
var bytesConsumed = 0;
// The bytes that buffered in current segment
var bytesBuffered = 0;
var segment = new BufferSegment {
Buffer = ArrayPool <byte> .Shared.Rent(1024)
};
segments.Add(segment);
while (true)
{
if (segment.Remaining < minimumBufferSize)
{
// Remove the current segment if it has not any valid data
if (segment.Count == bytesConsumed)
{
segments.RemoveAt(0);
bytesConsumed = 0;
}
// Allocate a new segment
segment = new BufferSegment {
Buffer = ArrayPool <byte> .Shared.Rent(1024)
};
segments.Add(segment);
bytesBuffered = 0;
}
var bytesRead = 0;
try
{
bytesRead = await stream.ReadAsync(segment.Buffer, segment.Count, segment.Remaining);
}
catch (IOException e)
{
Console.WriteLine($"{e.Message}");
return;
}
if (bytesRead == 0)
{
break;
}
segment.Count += bytesRead;
bytesBuffered += bytesRead;
// Process multiple line
while (true)
{
// Look for line end delimiter
var startIndex = segments.Count == 1 ? bytesConsumed : 0;
var count = segments.Count == 1 ? segment.Count - bytesConsumed : segment.Count;
var linePosition = Array.IndexOf(segment.Buffer, (byte)'\n', startIndex, count);
if (linePosition >= 0)
{
ProcessLine(segments, linePosition, bytesConsumed);
bytesConsumed = linePosition + 1;
// Drop fully consumed segments from the list so we don't look at them again
for (int i = segments.Count - 1; i >= 0; --i)
{
var consumedSegment = segments[i];
// Return all segment unless the last segment
if (consumedSegment != segment)
{
ArrayPool <byte> .Shared.Return(consumedSegment.Buffer);
segments.RemoveAt(i);
}
}
}
else
{
break;
}
}
}
}
public async Task<int> CalculatePrefix(NetworkStream netStream)
{
var packetSize = new List<byte>(sizeof(int));
var tmpBuff = new byte[1];
while (true)
{
// receive 1 byte at a time, ensuring complete packet
var read = await netStream.ReadAsync(tmpBuff, 0, 1);
if (read == 0)
return -1;
packetSize.AddRange(tmpBuff);
// if entire integer has been read then return calculated packet size
if (packetSize.Count >= sizeof(int))
return BitConverter.ToInt32(packetSize.ToArray(), 0);
}
}
private async Task<bool> TryReadAsync(TcpClient client, NetworkStream stream, byte[] buffer, int length, CancellationToken token)
{
int readBytes = 0;
while (readBytes < length)
{
if (token.IsCancellationRequested || !client.IsConnected())
return false;
readBytes += await stream.ReadAsync(buffer, readBytes, length - readBytes, token);
}
return true;
}
private async Task StartServerAsync()
{
try {
listner = new TcpListener(IPAddress.Parse("127.0.0.1"), int.Parse(SettingManager.ServerPort));
listner.Start();
LogList.Add("ServerListen 127.0.0.1 Port=" + SettingManager.ServerPort);
client = await listner.AcceptTcpClientAsync();
LogList.Add("Client Accepted");
stream = client.GetStream();
while (true)
{
if (client.Available > 0) {
byte[] buff = new byte[client.Available];
var read = await stream.ReadAsync(buff, 0, buff.Length);
var json = Encoding.UTF8.GetString(buff);
var data = JsonConvert.DeserializeObject<ConnectionData>(json);
if (data.AcceptPass == Setting.PassCode)
{
LogList.Add("Script Run ["+data.Script+"]");
Process.Start(Setting.PowerShellPath,data.Script);
}
else
{
MessageBox.Show("パスコードが違うようです。CortanaCommandアプリの設定からパスコードを取得し、サーバーの設定にペーストしてください");
}
client.Close();
listner.Stop();
await StartServerAsync();
break;
}
else
{
await Task.Delay(100);
}
}
}
catch (Exception e)
{
LogList.Add(e.Message);
client.Close();
listner.Stop();
await StartServerAsync();
}
}
/// <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);
}
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);
}
}
private async Task<byte[]> ReadBytes(NetworkStream stream, int count, CancellationToken cancellationToken)
{
if (count <= 0)
throw new ArgumentException();
byte[] buffer = new byte[count];
int received = 0;
while (received != count)
{
int result = await stream.ReadAsync(buffer, received, count - received, cancellationToken);
if (result == 0)
{
throw new SocketException(10060);
}
received += result;
}
return buffer;
}
public async Task<TcpReceiveContext> ReadAsync()
{
using (var cancellationTokenSource = new CancellationTokenSource(Timeout))
{
var socketStream = new NetworkStream(_socket);
var receivedStream = new MemoryStream();
var read = 0;
TcpRequestHeader header = null;
while (true)
{
read = await socketStream.ReadAsync(_readBuffer, 0, _readBuffer.Length, cancellationTokenSource.Token);
if (header == null)
{
header = new TcpRequestHeader(_readBuffer);
}
else
{
header.Append(_readBuffer);
}
if (header.IsComplete || read < _readBuffer.Length) break;
}
if ((read - header.HeaderLength) > 0)
receivedStream.Write(_readBuffer, header.HeaderLength, read - header.HeaderLength);
while (receivedStream.Position < header.ContentLength)
{
read = await socketStream.ReadAsync(_readBuffer, 0, _readBuffer.Length, cancellationTokenSource.Token);
receivedStream.Write(_readBuffer, 0, read);
}
DebugOutput.Log("Received {0} bytes", receivedStream.Position);
receivedStream.Position = 0;
return new TcpReceiveContext(_socket)
{
Header = header,
ReceivedData = receivedStream
};
}
}
/*
* These overloads are in the API reference, but our System.dll internals are visible
* to the tests. This causes the compiler to incorrectly resolve these against the
* overloaded version.
*
* The API reference has this in corlib:
*
* ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
* ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
*
* In System.dll, we override this as
*
* public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
*
* Without System.dll internals being visible, the compiler would correctly resolve the call using the
* API reference, but we need this custom extension for the tests.
*/
internal static ValueTask <int> ReadAsync(this NetworkStream stream, Memory <byte> buffer)
{
return(stream.ReadAsync(buffer, default));
}
private async Task<IOutputStream> CreateMatchedHandler(
IPEndPoint remote_endpoint,
NetworkStream stream,
AccessControlInfo acinfo)
{
var output_factories = PeerCast.OutputStreamFactories.OrderBy(factory => factory.Priority);
var header = new byte[4096];
int offset = 0;
using (var cancel_source=new CancellationTokenSource(TimeSpan.FromMilliseconds(3000))) {
var cancel_token = cancel_source.Token;
cancel_token.Register(() => stream.Close());
try {
while (offset<header.Length) {
var len = await stream.ReadAsync(header, offset, header.Length-offset);
if (len==0) break;
offset += len;
var header_ary = header.Take(offset).ToArray();
foreach (var factory in output_factories) {
if ((acinfo.Accepts & factory.OutputStreamType) == 0) continue;
var channel_id = factory.ParseChannelID(header_ary);
if (channel_id.HasValue) {
return factory.Create(
stream,
stream,
remote_endpoint,
acinfo,
channel_id.Value,
header_ary);
}
}
}
}
catch (System.ObjectDisposedException) {
}
catch (System.IO.IOException) {
}
}
return null;
}