Guest User

Untitled

a guest
Jun 13th, 2018
97
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.14 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Security.Cryptography;
  6. using System.Text;
  7. using System.Text.RegularExpressions;
  8. using System.Threading;
  9. using System.Windows;
  10.  
  11. public partial class MainWindow : Window
  12. {
  13. private Websocket_listen _listener;
  14. public MainWindow()
  15. {
  16. _listener = new Websocket_listen("127.0.0.1", 13000);
  17. _listener.StringReceived += _listener_StringReceived;
  18. _listener.Start();
  19. }
  20.  
  21. private void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
  22. {
  23. _running = false;
  24. _listener.Stop();
  25. }
  26.  
  27. private void _listener_StringReceived(string received)
  28. {
  29. }
  30. }
  31.  
  32. public class Websocket_listen
  33. {
  34. public readonly int port = 13000;
  35. public readonly IPAddress localAddr;
  36.  
  37. private TcpListener server = null;
  38. private TcpClient client = null;
  39. private NetworkStream stream = null;
  40. private bool connected = false;
  41. private byte[] bytes = new byte[2048];
  42. private byte[] _last_key = new byte[4];
  43. private int _last_message_length;
  44. private bool read_more_message;
  45. private Thread _current_thread;
  46. private bool _running = true;
  47. private int _received = 0;
  48. private StringBuilder _results = new StringBuilder();
  49.  
  50. public event Action<string> StringReceived = null;
  51.  
  52. public Websocket_listen(string ipaddress, int port)
  53. {
  54. this.port = port;
  55. localAddr = IPAddress.Parse(ipaddress);
  56. server = new TcpListener(localAddr, port);
  57. }
  58.  
  59. public void _running_loop()
  60. {
  61.  
  62. while (_running)
  63. {
  64. try
  65. {
  66.  
  67. server.Server.ReceiveTimeout = 5000;
  68. server.Server.SendTimeout = 5000;
  69. client = server.AcceptTcpClient();
  70. // Get a stream object for reading and writing
  71. stream = client.GetStream();
  72. }
  73. catch (Exception ex)
  74. {
  75. continue;
  76. }
  77.  
  78. while (_running)
  79. {
  80. try
  81. {
  82. try
  83. {
  84.  
  85. l.AcquireWriterLock(-1);
  86. if (messsages.Count > 0)
  87. {
  88. byte[] msg = System.Text.Encoding.ASCII.GetBytes(messsages[0]);
  89. //byte[] msg = System.Text.Encoding.ASCII.GetBytes("Connected to " + Environment.MachineName);
  90. Array.Copy(msg, 0, bytes, 2, msg.Length);
  91. bytes[0] = 0x81;
  92. bytes[1] = (byte)msg.Length;
  93. // Send back a response.
  94. stream.Write(bytes, 0, msg.Length + 2);
  95. messsages.RemoveAt(0);
  96. }
  97. }
  98. finally
  99. {
  100. l.ReleaseWriterLock();
  101. }
  102.  
  103. }
  104. catch { }
  105.  
  106. try
  107. {
  108. _received = stream.Read(bytes, 0, bytes.Length);
  109. }
  110. catch
  111. {
  112. continue;
  113. }
  114. if (_received == 0)
  115. continue;
  116.  
  117. if (!connected)
  118. {
  119. _is_connection();
  120. continue;
  121. }
  122.  
  123. if (!_parse_message())
  124. break;
  125. }
  126. }
  127.  
  128. try
  129. {
  130. stream.Close();
  131. client.Close();
  132. }
  133. catch (Exception ex)
  134. {
  135.  
  136. }
  137. }
  138.  
  139. private bool _parse_message()
  140. {
  141. int offset = 0;
  142. int message_length = 0;
  143. if (read_more_message)
  144. {
  145. _last_message_length -= bytes.Length;
  146. message_length = _last_message_length;
  147. if (message_length < bytes.Length)
  148. message_length += 8;
  149. }
  150. else
  151. {
  152. _results.Clear();
  153. var trigger = bytes[0];
  154. var magic_byte = bytes[1];
  155. bool is_text = (0x1 & trigger) != 0;
  156. bool is_fin = (0x80 & trigger) != 0;
  157.  
  158. if (trigger == 0x88)
  159. {
  160. connected = false;
  161. return false;
  162. }
  163. /*
  164. text = 0x81
  165. binary = 0x82
  166. close 0x88
  167. ping 0x89
  168. pong -0x8A
  169. */
  170.  
  171.  
  172. if (!is_fin)
  173. {
  174. return true;
  175. }
  176.  
  177. if (!is_text)
  178. {
  179. return true;
  180. }
  181.  
  182. //If the second byte minus 128 is between 0 and 125, this is the length of message.
  183. //If it is 126, the following 2 bytes (16-bit unsigned integer), if 127, the following 8 bytes (64-bit unsigned integer) are the length.
  184. var r = magic_byte - 128;
  185. var key_starts_at = 0;
  186. if (r <= 125)
  187. {
  188. key_starts_at = 2;
  189. message_length = r;
  190. }
  191. else if (r == 126)
  192. {
  193. key_starts_at = 4;
  194. message_length = BitConverter.ToUInt16(new byte[] { bytes[3], bytes[2] }, 0);
  195. }
  196. else if (r == 127)
  197. {
  198. key_starts_at = 10;
  199. for (var m = 7; m >= 0; --m)
  200. {
  201. message_length += bytes[m] << (8 * (7 - m));
  202. }
  203. }
  204. else
  205. {
  206. // not documented
  207. }
  208. //// because its encoded
  209. _last_message_length = message_length;
  210. Array.Copy(bytes, key_starts_at, _last_key, 0, 4);
  211.  
  212. offset = key_starts_at + 4;
  213.  
  214. }
  215. for (var mx = 0; mx < message_length && offset + mx < bytes.Length; ++mx)
  216. {
  217. bytes[offset + mx] = (byte)(bytes[offset + mx] ^ _last_key[mx % 4]);
  218. }
  219.  
  220. var new_result = System.Text.Encoding.ASCII.GetString(bytes, offset, Math.Min(message_length, bytes.Length - offset));
  221. _results.Append(new_result);
  222. read_more_message = message_length > bytes.Length;
  223.  
  224. if (!read_more_message)
  225. {
  226. try
  227. {
  228. StringReceived?.Invoke(_results.ToString());
  229. }
  230. catch (Exception ex)
  231. {
  232.  
  233. }
  234. }
  235.  
  236. return true;
  237. }
  238.  
  239. private void _is_connection()
  240. {
  241. try
  242. {
  243. string data = System.Text.Encoding.ASCII.GetString(bytes, 0, _received);
  244.  
  245. if (!new Regex("^GET").IsMatch(data))
  246. return;
  247. Byte[] response = Encoding.UTF8.GetBytes("HTTP/1.1 101 Switching Protocols" + Environment.NewLine
  248. + "Connection: Upgrade" + Environment.NewLine
  249. + "Upgrade: websocket" + Environment.NewLine
  250. + "Sec-WebSocket-Accept: " + Convert.ToBase64String(
  251. SHA1.Create().ComputeHash(
  252. Encoding.UTF8.GetBytes(
  253. new Regex("Sec-WebSocket-Key: (.*)").Match(data).Groups[1].Value.Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
  254. )
  255. )
  256. ) + Environment.NewLine
  257. + Environment.NewLine);
  258.  
  259. stream.Write(response, 0, response.Length);
  260. connected = true;
  261.  
  262. }
  263. catch (Exception ex)
  264. {
  265.  
  266. }
  267. }
  268.  
  269. public void Stop()
  270. {
  271. _running = false;
  272. }
  273.  
  274. public void Start()
  275. {
  276. // Start listening for client requests.
  277. server.Start();
  278.  
  279.  
  280. _current_thread = new Thread(new ThreadStart(_running_loop));
  281. _current_thread.Start();
  282.  
  283. }
  284. ReaderWriterLock l = new ReaderWriterLock();
  285. List<string> messsages = new List<string>();
  286. internal void Send(string msg)
  287. {
  288. try
  289. {
  290. l.AcquireWriterLock(-1);
  291.  
  292. messsages.Add(msg);
  293. }
  294. catch
  295. {
  296.  
  297. }
  298. finally
  299. {
  300. l.ReleaseWriterLock();
  301.  
  302. }
  303. }
  304. }
  305.  
  306. try {
  307. var isopen = false;
  308. connection = new WebSocket('ws://127.0.0.1:13000');
  309.  
  310. // When the connection is open, send some data to the server
  311. connection.onopen = function () {
  312. isopen = true;
  313. connection.send('Ping'); // Send the message 'Ping' to the server
  314. $('#open_messages').html("connection madern<br>");
  315. $('#socket_errors').html("");
  316. };
  317.  
  318. // Log errors
  319. connection.onerror = function (error) {
  320. console.log('WebSocket Error ', error);
  321. $('#socket_errors').html(error.currentTarget.url + " failedrn<br><button id="reconnect">Try to connect</button>");
  322. };
  323.  
  324. // Log messages from the server
  325. connection.onmessage = function (e) {
  326. console.log('Server: ', e);
  327. $('#messages').append(e.data + "rn<br>");
  328. };
  329.  
  330. connection.onclose = function(x) {
  331. console.log('closed ', x);
  332. $('#open_messages').html("Disconnectedrn<br>");
  333. $('#socket_errors').html("<button id="reconnect">Connect</button>");
  334. };
  335.  
  336. } catch (err) {
  337. console.log(err);
  338. }
Add Comment
Please, Sign In to add comment