private bool Ping()
{
NetStream.WriteByte(0x01);
NetStream.WriteByte(0x00);
NetStream.FlushAsync();
return(true);
}
async void HandleLogin(string _username, string _password)
{
string loginCheck = "neg";
user row = Program.db.users.SingleOrDefault(u => u.username == _username);
if (row != null)
{
if (row.password == _password)
{
var user = Program.chatList.SingleOrDefault(u => u.username == _username);
if (user == null)
{
loginCheck = "pos";
Console.WriteLine("[Chat] Client {0} joined chat with username: {1}", hash, _username);
this.username = _username;
Program.chatList.Add(this);
}
}
}
byte[] buffer = Encoding.ASCII.GetBytes(loginCheck);
await stream.WriteAsync(buffer, 0, buffer.Length);
await stream.FlushAsync();
if (loginCheck == "pos")
{
foreach (Client user in Program.chatList)
{
user.SendUserList(Program.chatList);
}
}
}
/// <summary>
/// Method to send a test packet over the specified port.
/// Async allows textbox updates from the TCPProxy to be chronological.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void testPacketToolStripMenuItem_Click(object sender, EventArgs e)
{
// send a "checkService" socket message to java services
byte[] msg = Encoding.ASCII.GetBytes("checkService\n");
byte[] bytes = new byte[256];
TcpClient testClient = new TcpClient(_config.HostIp, _config.ListenPort);
NetworkStream netStream = testClient.GetStream();
netStream.ReadTimeout = _config.ReadTimeout;
AppendTextBox($"Sending service check to {_config.JavaIp}:{_config.JavaPort}");
await netStream.WriteAsync(msg, 0, msg.Length);
await netStream.FlushAsync();
try
{
await netStream.ReadAsync(bytes, 0, bytes.Length);
await netStream.FlushAsync();
AppendTextBox($"Response Received: {Encoding.ASCII.GetString(bytes)}");
}
catch (Exception ex)
{
AppendTextBox(ex.Message);
}
}
public static async Task FlushCancellableAsync(this NetworkStream stream, CancellationToken cancellationToken)
{
#if !NO_SOCKETASYNC
await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
#else
await stream.FlushAsync().WithCancellation(cancellationToken).ConfigureAwait(false);
#endif
}
private void SendHeartbeatAsync()
{
var buffer = BitConverter.GetBytes(16908292).ToBE(); //0x01,0x02,0x00,0x04
NetStream.WriteAsync(buffer, 0, buffer.Length);
NetStream.FlushAsync();
Debug.WriteLine("Message Sent: Heartbeat");
}
static void Connect(String server, String message)
{
try
{
Int32 port = 13000;
TcpClient client = new TcpClient(server, port);
NetworkStream stream = client.GetStream();
Byte[] data = new Byte[256];
data = System.Text.Encoding.ASCII.GetBytes(message);
// Send the message to the connected TcpServer.
stream.Write(data, 0, data.Length);
Thread.Sleep(200);
Byte[] tmp1 = new Byte[2];
stream.Read(tmp1, 0, 2);
// Console.WriteLine(tmp1);
stream.FlushAsync();
int count = 0;
while (count++ < 10)
{
data = new Byte[256];
Thread.Sleep(50);
string message2 = "\u0033\u0001NICK12WIADOMOSC";
Byte[] tmp = new Byte[256];
data = new Byte[256];
tmp = System.Text.Encoding.ASCII.GetBytes(message2);
data[0] = (byte)message2.Length;
System.Buffer.BlockCopy(tmp, 0, data, 1, tmp.Length);
stream.Write(data, 0, data[0]);
Thread.Sleep(100);
data = new Byte[256];
String response = String.Empty;
// Read the Tcp Server Response Bytes.
Byte[] tmp2 = new Byte[1];
while (!stream.DataAvailable)
{
;
}
stream.Read(tmp2, 0, 1);
if (tmp2[0] != 0) // 0 bit is ping byte
{
Int32 bytes = stream.Read(data, 0, tmp2[0]);
stream.Read(tmp1, 0, 2);
response = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
Console.WriteLine("Received: {0}", response + "XD");
}
stream.FlushAsync();
Thread.Sleep(250);
}
stream.Close();
client.Close();
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e);
}
Console.Read();
}
protected override async Task SendAsync(byte[] payload)
{
if (_clientStream != null)
{
await _clientStream.WriteAsync(payload, 0, payload.Length, OperationCancellationToken.Token);
await _clientStream.FlushAsync(OperationCancellationToken.Token);
}
}
public async Task SendAll(params string[] lines)
{
var text = string.Join("\r\n", lines);
var writer = new StreamWriter(_stream, Encoding.GetEncoding("iso-8859-1"));
await writer.WriteAsync(text).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
await _stream.FlushAsync().ConfigureAwait(false);
}
public void Connect(String server, String message)
{
try
{
Int32 port = 13000;
TcpClient client = new TcpClient(server, port);
NetworkStream stream = client.GetStream();
Byte[] data = new Byte[256];
data = Encoding.ASCII.GetBytes(message);
// Send the message to the connected TcpServer.
stream.Write(data, 0, data.Length);
Thread.Sleep(200);
Byte[] tmp1 = new Byte[2];
stream.Read(tmp1, 0, 2);
string resp = Encoding.ASCII.GetString(tmp1, 0, 2);
if (resp == "OK")
{
Console.WriteLine("Connected");
}
else
{
Console.WriteLine("Error in connection");
}
stream.FlushAsync();
while (true)
{
stream = client.GetStream();
data = new Byte[256];
String response = String.Empty;
// Read the Tcp Server Response Bytes.
Byte[] length = new Byte[1];
while (!stream.DataAvailable)
{
;
}
stream.Read(length, 0, 1); //check length of response in bytes
if (length[0] != 0) //0 bit is ping byte
{
int bytes_count = stream.Read(data, 0, length[0]);
response = Encoding.ASCII.GetString(data, 0, bytes_count);
Console.WriteLine("Received: {0}", response);
Add_To_Datebase(response);
}
stream.FlushAsync();
Thread.Sleep(250);
}
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e);
}
Console.Read();
}
public async Task <int> GetCurtainStatus(int id)
{
int retPercent = 0;
byte[] data = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x55, 0x01, (byte)id, 0x01, 0x02, 0x01 };
await _streamCurtain.WriteAsync(data, 0, data.Length);
data = new Byte[12];
Int32 ret = await _streamCurtain.ReadAsync(data, 0, data.Length);
retPercent = data[11];
await _streamCurtain.FlushAsync();
return(retPercent);
}
public async Task WriteBody(string path, NetworkStream ns)
{
if (!File.Exists(path))
{
return;
}
Int64 offset = 0;
FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
Int64 fileSize = fs.Length;
while (fileSize > offset)
{
fs.Seek(offset, SeekOrigin.Begin);
Int32 currentBufferSize = (fileSize - offset) >= bufferSize ? bufferSize : (Int32)(fileSize - offset);
byte[] buff = new byte[currentBufferSize];
await fs.ReadAsync(buff, 0, currentBufferSize);
await ns.WriteAsync(buff);
await ns.FlushAsync();
offset += currentBufferSize;
}
fs.Close();
await fs.DisposeAsync();
return;
}
/// <summary>
/// Send Package to NetworkStream
/// </summary>
/// <param name="e">NetworkStream</param>
/// <param name="package">Package of Bytes</param>
public static async Task <bool> Send(this NetworkStream e, byte[] package)
{
try
{
var l = new byte[sizeof(long)];
var msg = package;
// Get size of package - Add it to length buffer
BitConverter.GetBytes(msg.Length)
.CopyTo(l, 0);
// Send length buffer to stream
await e.WriteAsync(l, 0, l.Length);
// Send Package buffer to stream
await e.WriteAsync(msg, 0, msg.Length);
// Flush stream
await e.FlushAsync();
return(true);
}
catch
{
return(false);
}
}
public bool GrinSend <T>(T message)
{
try
{
string output = JsonConvert.SerializeObject(message, Formatting.None, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("TCP OUT: " + output + Environment.NewLine);
Console.ResetColor();
byte[] bmsg = Encoding.UTF8.GetBytes(output + "\n");
stream.Write(bmsg, 0, bmsg.Length);
stream.FlushAsync();
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
async public Task SendAsync(IPacket packet)
{
try
{
NetworkStream stream = this.client.GetStream();
// 1. 보낼 데이터를 압축한다.
byte[] sendData = NetUtil.SerializeObject(data: packet);
byte[] compressData = await NetUtil.CompressAsync(data : sendData);
// 2. 요청의 헤더를 보낸다.
int sendDataLength = compressData.Length;
byte[] sendHeader = BitConverter.GetBytes(value: sendDataLength);
await stream.WriteAsync(buffer : sendHeader, offset : 0, count : sendHeader.Length);
// 3. 요청을 보낸다.
await TcpUtil.SendDataAsync(networkStream : stream, data : compressData, dataLength : sendDataLength);
await stream.FlushAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public async Task SendMessage(Message Message)
{
byte[] RawMessage = Message.GetPacket();
await Stream.WriteAsync(RawMessage, 0, RawMessage.Length);
await Stream.FlushAsync();
}
public async Task write(String message, Boolean forceNoSsl = false)
{
try
{
if (isSsl & !forceNoSsl)
{
// SSLStream crops char[0] into the first 4bytes -> packet length. This is a workaround it.
byte[] msg = utf8Encoding.GetBytes(" " + message);
await sslStream.WriteAsync(msg, 0, msg.Length, ct);
await sslStream.FlushAsync(ct);
}
else
{
byte[] msg = utf8Encoding.GetBytes(message);
await stream.WriteAsync(msg, 0, msg.Length, ct);
await stream.FlushAsync(ct);
}
log.Info(String.Format("Sent xmpp packet {0}.", message));
}
catch (Exception ex)
{
log.Error("Exception occured while writing.", ex);
}
}
/// <summary>
/// Sends a request to the Tor SOCKS5 connection and returns a byte response.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="cancellationToken">Cancellation token to cancel sending.</param>
/// <returns>Reply</returns>
/// <exception cref="ArgumentException">When <paramref name="request"/> is not supported.</exception>
/// <exception cref="TorConnectionException">When we receive no response from Tor or the response is invalid.</exception>
private async Task <byte[]> SendRequestAsync(TcpClient tcpClient, ByteArraySerializableBase request, CancellationToken cancellationToken = default)
{
try
{
NetworkStream stream = tcpClient.GetStream();
byte[] dataToSend = request.ToBytes();
// Write data to the stream.
await stream.WriteAsync(dataToSend.AsMemory(0, dataToSend.Length), cancellationToken).ConfigureAwait(false);
await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
if (request is VersionMethodRequest or UsernamePasswordRequest)
{
return(await ReadTwoByteResponseAsync(stream, cancellationToken).ConfigureAwait(false));
}
else if (request is TorSocks5Request)
{
return(await ReadRequestResponseAsync(stream, cancellationToken).ConfigureAwait(false));
}
else
{
throw new ArgumentException("Not supported request type.", nameof(request));
}
}
/// <summary>
/// Send serialized class into tcp connection
/// login, getjob...
/// </summary>
public bool GrinSend <T>(T message)
{
try
{
string output = JsonConvert.SerializeObject(message, Formatting.None, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
Console.ForegroundColor = ConsoleColor.DarkGreen;
if (shouldPrint())
{
Logger.Log(LogLevel.DEBUG, $"(sc id {id}): TCP OUT: {output} {Environment.NewLine}");
}
Console.ResetColor();
byte[] bmsg = Encoding.ASCII.GetBytes(output + "\n");
if (streamTLS != null)
{
lock (streamTLS)
{
if (streamTLS.CanWrite)
{
streamTLS.Write(bmsg, 0, bmsg.Length);
streamTLS.FlushAsync();
}
else
{
IsConnected = false;
Logger.Log(LogLevel.DEBUG, $" !! streamTLS.CanWrite == false, disconnecting");
}
}
}
else
{
lock (stream)
{
if (stream.CanWrite)
{
stream.Write(bmsg, 0, bmsg.Length);
stream.FlushAsync();
}
else
{
IsConnected = false;
Logger.Log(LogLevel.DEBUG, $" !! stream.CanWrite == false, disconnecting");
}
}
}
return(true);
}
catch (Exception ex)
{
Logger.Log(ex);
IsConnected = false;
return(false);
}
}
public async Task <string> SendAndReceive(string msg)
{
string tempS = "error";
byte[] data = new Byte[256];
string responseData = string.Empty;
try
{
stream = client.GetStream();
stream.ReadTimeout = 200;
await stream.WriteAsync(Encoding.ASCII.GetBytes(msg + "\r\n"), 0, Encoding.ASCII.GetBytes(msg + "\r\n").Length);
await stream.FlushAsync();
IsOnline();
//Int32 bytes = stream.Read(data, 0, data.Length);
Int32 bytes = await stream.ReadAsync(data, 0, data.Length);
tempS = Encoding.ASCII.GetString(data, 0, bytes);
return(tempS);
}
catch
{
IsOnline();
return("error");
}
}
/// <summary>
/// Sends the specified formatted message to the IRC server without waiting for the message queue.
/// </summary>
/// <param name="format"></param>
/// <param name="args"></param>
/// <returns></returns>
public async Task <bool> Send(string format, params object[] args)
{
if (!Connected)
{
return(false);
}
await writingLock.WaitAsync();
try
{
var message = new StringBuilder();
message.AppendFormat(format, args).Append('\n');
byte[] buf = Encoding.GetBytes(message.ToString());
await stream.WriteAsync(buf, 0, buf.Length);
await stream.FlushAsync();
return(true);
}
finally
{
writingLock.Release();
}
}
/// <summary>
/// 创建HTML的读取
/// </summary>
/// <param name="hostname">地址</param>
/// <returns></returns>
public static async Task <string> RequestHtmlAsync(string hostname)
{
try
{
using var client = new TcpClient();
await client.ConnectAsync(hostname, 20);
NetworkStream stream = client.GetStream();
string header = $"GET/HTTP/1.1\r\nHost:{hostname}:80\r\nConnection:close\r\n\r\n";
byte[] buffer = Encoding.UTF8.GetBytes(header);
await stream.WriteAsync(buffer, 0, buffer.Length);
await stream.FlushAsync();
var ms = new MemoryStream();
buffer = new byte[ReadBufferSize];
int read = 0;
do
{
read = await stream.ReadAsync(buffer, 0, ReadBufferSize);
ms.Write(buffer, 0, read);
Array.Clear(buffer, 0, buffer.Length);
} while (read > 0);
ms.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(ms);
return(reader.ReadToEnd());
}
catch (Exception ex) {
throw ex;
}
}
protected override async void SendToRemote(byte[] buffer)
{
if (remoteConnected)
{
try
{
var(data, len) = Encrypt(buffer, (uint)buffer.Length);
await networkStream.WriteAsync(data, 0, (int)len);
await networkStream.FlushAsync();
Recved((ushort)buffer.Length);
#if YTLOG_VERBOSE
Debug.WriteLine("Sent data" + buffer.Length);
#endif
// r.Send(e);
}
catch (Exception)
{
Debug.WriteLine("Cannot send to remote");
}
}
else
{
// buffer.CopyTo(0, localbuf, localbuf.Length, buffer.Length);
// localbuf.Length += buffer.Length;
localbuf.Enqueue(buffer);
#if YTLOG_VERBOSE
Debug.WriteLine("Queued data" + buffer.Length);
#endif
}
}
internal async Task WriteFrame(HTTP2Frame frame)
{
try
{
StringBuilder s = new StringBuilder();
s.AppendLine("---------------");
s.AppendLine("Send frame: ");
s.AppendLine(frame.ToString());
s.AppendLine("---------------");
Console.WriteLine(s);
if (_useSsl)
{
await _sslWriter.FlushAsync();
await _sslWriter.WriteAsync(frame.GetBytes(), 0, frame.GetBytes().Length);
}
else
{
await _http2Writer.FlushAsync();
await _http2Writer.WriteAsync(frame.GetBytes(), 0, frame.GetBytes().Length);
}
}
catch (Exception ex)
{
Console.WriteLine("WriteFrame()\n" + ex);
}
}
private async Task SendAsyncInternal(byte[] message)
{
try
{
if (!_tcp.Connected)
{
await ConnectAsync().ConfigureAwait(false);
}
_stream = _tcp.GetStream();
await _stream.WriteAsync(message, 0, message.Length).ConfigureAwait(false);
await _stream.FlushAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
if (_setting.ExceptionHandler == null)
{
throw;
}
_setting.ExceptionHandler.Invoke(ex);
}
}
private async Task HandleTcpClientAsync(TcpClient client)
{
// When the TcpClient connects, send it a message
using NetworkStream ns = client.GetStream();
using StreamWriter sw = new StreamWriter(ns);
using StreamReader sr = new StreamReader(ns);
string helloMessage = "Hello, what is your name?";
this.messageFactory.WriteMessage(helloMessage, ns, ServerUserId);
// Read the header of the message
MessageHeader header = this.messageFactory.ReadMessageHeader(ns);
string name = this.messageFactory.ReadMessage(header, ns);
// Write the message to all the clients in the chatroom
foreach (ChatroomUser c in this.chatroomUsers)
{
this.messageFactory.WriteMessage($"Everyone F****N WELCOME {header.UserId} to the chatroom.", c.TcpClient.GetStream(), ServerUserId);
}
// Flush the stream so the client gets the message
await ns.FlushAsync();
}
public static async Task <long> CopyRawImageFileToShim(string FilePath,
IPAddress ShimDataClientIpAddr,
int port = TransmitDataHostPortDefault,
CancellationToken ct = default(CancellationToken))
{
try
{
using Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse("0.0.0.0");
IPEndPoint local = new IPEndPoint(ip, 0);
var detClient = new TcpClient(local);
await detClient.ConnectAsync(ShimDataClientIpAddr, port, ct);
NetworkStream detDataStream = detClient.GetStream();
Console.WriteLine("connected.");
using FileStream file = new FileStream(FilePath, FileMode.Open, System.IO.FileAccess.Read);
Console.WriteLine($"copying >{FilePath} : {file.Length}< ");
await file.CopyToAsync(detDataStream, ct);
await detDataStream.FlushAsync(ct);
detDataStream.Close();
return(file.Length);
}
catch (Exception e)
{
Console.WriteLine($"Error sending image data from the file >{FilePath}< ");
Console.WriteLine($" {e} ");
};
return(0);
}
void SendSocketData(int packetlength, short magic, short ver, int action, int param = 1, string body = "")
{
var playload = Encoding.UTF8.GetBytes(body);
if (packetlength == 0)
{
packetlength = playload.Length + 16;
}
var buffer = new byte[packetlength];
using (var ms = new MemoryStream(buffer))
{
var b = BitConverter.GetBytes(buffer.Length).ToBE();
ms.Write(b, 0, 4);
b = BitConverter.GetBytes(magic).ToBE();
ms.Write(b, 0, 2);
b = BitConverter.GetBytes(ver).ToBE();
ms.Write(b, 0, 2);
b = BitConverter.GetBytes(action).ToBE();
ms.Write(b, 0, 4);
b = BitConverter.GetBytes(param).ToBE();
ms.Write(b, 0, 4);
if (playload.Length > 0)
{
ms.Write(playload, 0, playload.Length);
}
NetStream.WriteAsync(buffer, 0, buffer.Length);
NetStream.FlushAsync();
}
}
private async void OnSendCommand(object sender, RoutedEventArgs e)
{
try
{
if (!VerifyIsConnected())
{
return;
}
NetworkStream stream = _client.GetStream();
byte[] writeBuffer = Encoding.ASCII.GetBytes(GetCommand());
await stream.WriteAsync(writeBuffer, 0, writeBuffer.Length);
await stream.FlushAsync();
byte[] readBuffer = new byte[1024];
int read = await stream.ReadAsync(readBuffer, 0, readBuffer.Length);
string messageRead = Encoding.ASCII.GetString(readBuffer, 0, read);
Log += messageRead + Environment.NewLine;
ParseMessage(messageRead);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
protected override async Task WriteProtocolMessageToRemoteMachine(string message)
{
if (!this.client.Connected)
{
Log.Trace(1, "{0}: Connection lost", this.Name);
this.Connect();
Log.Trace(1, "{0}: After connect", this.Name);
}
Byte[] data = System.Text.Encoding.ASCII.GetBytes(message + "\r\n"); // newline is required for TableManager protocol
try
{
await stream.WriteAsync(data, 0, data.Length);
await stream.FlushAsync(); // Send the message to the connected TcpServer (without Flush the message will stay in the buffer)
}
catch (IOException x)
{
Log.Trace(0, "Error '{0}'", x.Message);
}
catch (Exception x)
{
Log.Trace(0, "Error '{0}'", x.Message);
}
finally
{
Log.Trace(0, "TM {1} sends '{0}'", message, this.seat.ToString().PadRight(5));
}
}
private async Task <Stream> ConnectToServer()
{
var connectionInfo = await _commands.GetTcpInfoAsync();
var uri = new Uri(connectionInfo.Url);
await _tcpClient.ConnectAsync(uri.Host, uri.Port);
_tcpClient.NoDelay = true;
_tcpClient.SendBufferSize = 32 * 1024;
_tcpClient.ReceiveBufferSize = 4096;
_networkStream = _tcpClient.GetStream();
var ms = new MemoryStream();
RavenJObject.FromObject(new TcpConnectionHeaderMessage
{
Operation = TcpConnectionHeaderMessage.OperationTypes.Subscription,
DatabaseName = MultiDatabase.GetDatabaseName(_commands.Url)
}).WriteTo(ms);
RavenJObject.FromObject(_options).WriteTo(ms);
ArraySegment <byte> bytes;
ms.TryGetBuffer(out bytes);
await _networkStream.WriteAsync(bytes.Array, bytes.Offset, bytes.Count);
await _networkStream.FlushAsync();
return(_networkStream);
}
