daily pastebin goal
83%
SHARE
TWEET

Untitled

a guest Jun 13th, 2018 58 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top