public void Stop()
{
_tcpClient.Close();
_stream.Close();
LogRequest?.Invoke(this, new LogEventArgs("Client writer stopped."));
}
// PUBLIC METHODS
#region public methods
#region Start()
public void Start(int port)
{
ThreadPool.QueueUserWorkItem(_ =>
{
_tcpClient = new TcpClient("127.0.0.1", port);
LogRequest?.Invoke(this, new LogEventArgs("Connection was established...."));
_stream = _tcpClient.GetStream();
Byte[] response = new Byte[_tcpClient.ReceiveBufferSize];
while (_listening)
{
int bytesRead = _stream.Read(response, 0, (int)_tcpClient.ReceiveBufferSize);
if (bytesRead > 0)
{
string returnData = Encoding.UTF8.GetString(response, 0, bytesRead);
LogRequest?.Invoke(this, new LogEventArgs("Server Response: " + returnData));
if (returnData == "q")
{
_listening = false;
}
}
}
_tcpClient.Close();
_stream.Close();
LogRequest?.Invoke(this, new LogEventArgs("Client reader stopped."));
});
}
// PUBLIC METHODS
#region public methods
#region Start()
public void Start(int port)
{
ThreadPool.QueueUserWorkItem(_ =>
{
_tcpClient = new TcpClient("127.0.0.1", port);
LogRequest?.Invoke(this, new LogEventArgs("Connection was established...."));
_stream = _tcpClient.GetStream();
});
}
void SendMessage(TcpClient client, byte[] payload, int opcode, bool masking, byte[] mask)
{
if (masking && mask == null)
{
throw new ArgumentException(nameof(mask));
}
using (var packet = new MemoryStream())
{
byte firstbyte = 0b0_0_0_0_0000; // fin | rsv1 | rsv2 | rsv3 | [ OPCODE | OPCODE | OPCODE | OPCODE ]
firstbyte |= 0b1_0_0_0_0000; // fin
//firstbyte |= 0b0_1_0_0_0000; // rsv1
//firstbyte |= 0b0_0_1_0_0000; // rsv2
//firstbyte |= 0b0_0_0_1_0000; // rsv3
firstbyte += (byte)opcode; // Text
packet.WriteByte(firstbyte);
// Set bit: bytes[byteIndex] |= mask;
byte secondbyte = 0b0_0000000; // mask | [SIZE | SIZE | SIZE | SIZE | SIZE | SIZE | SIZE]
if (masking)
{
secondbyte |= 0b1_0000000; // mask
}
if (payload.LongLength <= 0b0_1111101) // 125
{
secondbyte |= (byte)payload.Length;
packet.WriteByte(secondbyte);
}
else if (payload.LongLength <= UInt16.MaxValue) // If length takes 2 bytes
{
secondbyte |= 0b0_1111110; // 126
packet.WriteByte(secondbyte);
var len = BitConverter.GetBytes(payload.LongLength);
Array.Reverse(len, 0, 2);
packet.Write(len, 0, 2);
}
else // if (payload.LongLength <= Int64.MaxValue) // If length takes 8 bytes
{
secondbyte |= 0b0_1111111; // 127
packet.WriteByte(secondbyte);
var len = BitConverter.GetBytes(payload.LongLength);
Array.Reverse(len, 0, 8);
packet.Write(len, 0, 8);
}
if (masking)
{
packet.Write(mask, 0, 4);
payload = ApplyMask(payload, mask);
}
// Write all data to the packet
packet.Write(payload, 0, payload.Length);
// Get client's stream
var stream = client.GetStream();
var finalPacket = packet.ToArray();
LogRequest?.Invoke(null, new LogEventArgs($@"SENT: {BitConverter.ToString(finalPacket)}"));
// Send the packet
foreach (var b in finalPacket)
{
stream.WriteByte(b);
}
}
}
private void MessageLoop()
{
var packet = new List <byte>();
var messageOpcode = 0x0;
using (var messageBuffer = new MemoryStream())
{
while (_client.Connected)
{
packet.Clear();
var ab = _client.Available;
if (ab == 0)
{
continue;
}
packet.Add((byte)_clientStream.ReadByte());
var fin = (packet[0] & (1 << 7)) != 0;
var rsv1 = (packet[0] & (1 << 6)) != 0;
var rsv2 = (packet[0] & (1 << 5)) != 0;
var rsv3 = (packet[0] & (1 << 4)) != 0;
// Must error if is set.
//if (rsv1 || rsv2 || rsv3)
// return;
var opcode = packet[0] & ((1 << 4) - 1);
switch (opcode)
{
case 0x0: // Continuation Frame
break;
case 0x1: // Text
case 0x2: // Binary
case 0x8: // Connection Close
messageOpcode = opcode;
break;
case 0x9:
continue; // Ping
case 0xA:
continue; // Pong
default:
continue; // Reserved
}
packet.Add((byte)_clientStream.ReadByte());
var masked = IsMasking = (packet[1] & (1 << 7)) != 0;
var pseudoLength = packet[1] - (masked ? 128 : 0);
ulong actualLength = 0;
if (pseudoLength > 0 && pseudoLength < 125)
{
actualLength = (ulong)pseudoLength;
}
else if (pseudoLength == 126)
{
var length = new byte[2];
_clientStream.Read(length, 0, length.Length);
packet.AddRange(length);
Array.Reverse(length);
actualLength = BitConverter.ToUInt16(length, 0);
}
else if (pseudoLength == 127)
{
var length = new byte[8];
_clientStream.Read(length, 0, length.Length);
packet.AddRange(length);
Array.Reverse(length);
actualLength = BitConverter.ToUInt64(length, 0);
}
var mask = new byte[4];
if (masked)
{
_clientStream.Read(mask, 0, mask.Length);
packet.AddRange(mask);
}
if (actualLength > 0)
{
var data = new byte[actualLength];
_clientStream.Read(data, 0, data.Length);
packet.AddRange(data);
if (masked)
{
data = ApplyMask(data, mask);
}
messageBuffer.Write(data, 0, data.Length);
}
LogRequest?.Invoke(this, new LogEventArgs($@"RECV: {BitConverter.ToString(packet.ToArray())}"));
if (!fin)
{
continue;
}
var message = messageBuffer.ToArray();
switch (messageOpcode)
{
case 0x1:
AnyMessageReceived?.Invoke(this, message);
TextMessageReceived?.Invoke(this, Encoding.UTF8.GetString(message));
break;
case 0x2:
AnyMessageReceived?.Invoke(this, message);
BinaryMessageReceived?.Invoke(this, Encoding.UTF8.GetString(message));
break;
case 0x8:
Close();
break;
default:
throw new Exception("Invalid opcode: " + messageOpcode);
}
messageBuffer.SetLength(0);
}
}
}
private async Task <string> DoRequest(string methodString, HttpRequestMethod requestMethod, string postData = null)
{
// make sure values are set
if (string.IsNullOrEmpty(this.URL))
{
throw new InvalidOperationException("URL not set");
}
if (string.IsNullOrEmpty(this.apiKey))
{
throw new InvalidOperationException("apiKey not set");
}
if (string.IsNullOrEmpty(this.Password))
{
throw new InvalidOperationException("Password not set");
}
// create the URI
string addressString = string.Format("{0}{1}", this.URL, (this.URL.EndsWith("/") ? string.Empty : "/"));
var uriBuilder = new UriBuilder(addressString)
{
Scheme = "https",
Port = -1 // default port for scheme
};
Uri address = uriBuilder.Uri;
var handler = new HttpClientHandler();
handler.SslProtocols = System.Security.Authentication.SslProtocols.Tls12;
var client = new HttpClient(handler)
{
Timeout = TimeSpan.FromMilliseconds(this._timeout),
BaseAddress = address
};
var byteArray = Encoding.ASCII.GetBytes($"{this.apiKey}:{this.Password}");
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue(this.UseJSON ? "application/json" : "application/xml"));
client.DefaultRequestHeaders.TransferEncodingChunked = false;
try
{
// Send the request for logging, if applicable.
LogRequest?.Invoke(requestMethod, addressString + methodString, postData);
switch (requestMethod)
{
case HttpRequestMethod.Get:
_lastResponse = await client.GetAsync(methodString);
break;
case HttpRequestMethod.Post:
_lastResponse = await client.PostAsync(methodString, new StringContent(postData, Encoding.UTF8, this.UseJSON ? "application/json" : "text/xml"));
break;
case HttpRequestMethod.Put:
_lastResponse = await client.PutAsync(methodString, new StringContent(postData, Encoding.UTF8, this.UseJSON ? "application/json" : "text/xml"));
break;
case HttpRequestMethod.Delete:
_lastResponse = await client.DeleteAsync(methodString);
break;
}
var content = await _lastResponse?.Content?.ReadAsStringAsync();
// Send the response for logging, if applicable.
LogResponse?.Invoke(_lastResponse.StatusCode, addressString + methodString, content);
return(content);
}
catch (Exception ex)
{
throw;
}
}
// PUBLIC METHODS
#region public methods
#region Listen()
public void Listen(int port)
{
if (_listening)
{
throw new Exception("Already listening!");
}
_listening = true;
TcpListener tcpListener = new TcpListener(IPAddress.Any, port);
tcpListener.Start();
ClientConnected?.Invoke(this, new LogEventArgs($"Server has started on 127.0.0.1:{port}. Waiting for a connection..."));
ThreadPool.QueueUserWorkItem(_ =>
{
TcpClient tcpClientWriter = tcpListener.AcceptTcpClient();
TcpClient tcpClientReader = tcpListener.AcceptTcpClient();
LogRequest?.Invoke(this, new LogEventArgs("Client connected."));
_clientStreamWriter = tcpClientWriter.GetStream();
byte[] bufferWriter = new byte[tcpClientWriter.ReceiveBufferSize];
_clientStreamReader = tcpClientReader.GetStream();
byte[] bufferReader = new byte[tcpClientReader.ReceiveBufferSize];
while (_listening)
{
//---read incoming stream---
int bytesRead;
try
{
using (_cancellationTokenSource = new CancellationTokenSource())
{
using (_cancellationTokenSource.Token.Register(() => _clientStreamWriter.Close()))
{
bytesRead = _clientStreamWriter.Read(bufferWriter, 0, tcpClientWriter.ReceiveBufferSize);
if (bytesRead > 0)
{
//---convert the data received into a string---
string dataReceived = Encoding.ASCII.GetString(bufferWriter, 0, bytesRead);
LogRequest?.Invoke(this, new LogEventArgs("Received : " + dataReceived));
//---write back the text to the client---
if (dataReceived.Length > 0)
{
byte[] bytesToSend = ASCIIEncoding.ASCII.GetBytes(dataReceived);
LogRequest?.Invoke(this, new LogEventArgs("Sending back : " + dataReceived));
_clientStreamReader.Write(bytesToSend, 0, bytesToSend.Length);
}
}
}
}
}
catch (Exception ex)
{
if (_listening)
{
throw;
}
else
{
byte[] bytesToSend = ASCIIEncoding.ASCII.GetBytes("q");
LogRequest?.Invoke(this, new LogEventArgs("Closing Client Reader..."));
_clientStreamReader.Write(bytesToSend, 0, bytesToSend.Length);
}
}
}
tcpClientWriter.Close();
tcpClientReader.Close();
tcpListener.Stop();
_clientStreamReader.Flush();
_clientStreamReader.Dispose();
_clientStreamWriter.Dispose();
ClientDisconnected?.Invoke(this, new LogEventArgs("Server stopped."));
});
}