rubysocket-client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af6f7040d67393cd43bcc9dc3c5cf4f2ba04c12700f168ea3e66232dfd54e58a
+  data.tar.gz: 83601a6fb5eccf3c36b17421c859c06d5c91953eb8baabebb947487335bfe548
+SHA512:
+  metadata.gz: 62c924bfb28651865d746f0e63c613cf82d93db493ba43ce11e237987406cda96fdd9d794228b2e0f1df41ea77a9fca00117ed3ed216486fa8e5fbae3fa6e67e
+  data.tar.gz: 0270f649e6b304d8b909356135c1881ec020f1ff24187d1f5639690b9a59baaf6ffbd6c4e92bb2d643f8abcbc447950e20d9b3098af005eb6a3195ca7a903ce1

data/.gitignore

@@ -0,0 +1,61 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*
+
+.DS_Store
+
+.vscode/
+.idea/

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec"
+end
+
+gem 'rest-client'
+gemspec

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,2 @@
+# rubysocket
+Socket implementation in ruby

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--colour --format documentation']
+end

data/lib/RubySocket/version.rb

@@ -0,0 +1,6 @@
+module RubySocket
+    class Client
+      VERSION = "0.0.2"
+    end
+end
+  

data/lib/parser.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+module Parser
+    @regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/
+  
+    def self.decode(string)
+      if pieces = string.match(@regexp)
+        {type: pieces[1], id: pieces[2], end_point: pieces[4], data: pieces[5]}
+      else
+        {type: '0'}
+      end
+    end
+end

data/lib/web_socket.rb

@@ -0,0 +1,596 @@
+#!/usr/bin/env ruby 
+
+require "base64"
+require "socket"
+require "uri"
+require "digest/md5"
+require "digest/sha1"
+require "openssl"
+require "stringio"
+
+
+class WebSocket
+
+    class << self
+
+        attr_accessor(:debug)
+
+    end
+
+    class Error < RuntimeError
+
+    end
+    
+    WEB_SOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
+    def initialize(arg, params = {})
+      if params[:server] # server
+
+        @server = params[:server]
+        @socket = arg
+        line = gets()
+        if !line
+          raise(WebSocket::Error, "Client disconnected without sending anything.")
+        end
+        line = line.chomp()
+        if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
+          raise(WebSocket::Error, "Invalid request: #{line}")
+        end
+        @path = $1
+        read_header()
+        if @header["sec-websocket-version"]
+          @web_socket_version = @header["sec-websocket-version"]
+          @key3 = nil
+        elsif @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
+          @web_socket_version = "hixie-76"
+          @key3 = read(8)
+        else
+          @web_socket_version = "hixie-75"
+          @key3 = nil
+        end
+        if !@server.accepted_origin?(self.origin)
+          raise(WebSocket::Error,
+            ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
+              "To accept this origin, write e.g. \n" +
+              "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
+              "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
+            [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
+        end
+        @handshaked = false
+
+      else # client
+        
+        @web_socket_version = "hixie-76"
+        uri = arg.is_a?(String) ? URI.parse(arg) : arg
+
+        if uri.scheme == "ws"
+          default_port = 80
+        elsif uri.scheme = "wss"
+          default_port = 443
+        else
+          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
+        end
+
+        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
+        host = uri.host + ((!uri.port || uri.port == default_port) ? "" : ":#{uri.port}")
+        origin = params[:origin] || "http://#{uri.host}"
+        key1 = generate_key()
+        key2 = generate_key()
+        key3 = generate_key3()
+
+        socket = TCPSocket.new(uri.host, uri.port || default_port)
+
+        if uri.scheme == "ws"
+          @socket = socket
+        else
+          @socket = ssl_handshake(socket)
+        end
+
+        write(
+          "GET #{@path} HTTP/1.1\r\n" +
+          "Upgrade: WebSocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          "Host: #{host}\r\n" +
+          "Origin: #{origin}\r\n" +
+          "Sec-WebSocket-Key1: #{key1}\r\n" +
+          "Sec-WebSocket-Key2: #{key2}\r\n" +
+          "\r\n" +
+          "#{key3}")
+        flush()
+
+        line = gets().chomp()
+        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
+        read_header()
+        if (@header["sec-websocket-origin"] || "").downcase() != origin.downcase()
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["sec-websocket-origin"]}' != '#{origin}'")
+        end
+        reply_digest = read(16)
+        expected_digest = hixie_76_security_digest(key1, key2, key3)
+        if reply_digest != expected_digest
+          raise(WebSocket::Error,
+            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
+        end
+        @handshaked = true
+
+      end
+      @received = []
+      @buffer = ""
+      @closing_started = false
+    end
+
+    attr_reader(:server, :header, :path)
+
+    def handshake(status = nil, header = {})
+      if @handshaked
+        raise(WebSocket::Error, "handshake has already been done")
+      end
+      status ||= "101 Switching Protocols"
+      def_header = {}
+      case @web_socket_version
+        when "hixie-75"
+          def_header["WebSocket-Origin"] = self.origin
+          def_header["WebSocket-Location"] = self.location
+          extra_bytes = ""
+        when "hixie-76"
+          def_header["Sec-WebSocket-Origin"] = self.origin
+          def_header["Sec-WebSocket-Location"] = self.location
+          extra_bytes = hixie_76_security_digest(
+            @header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
+        else
+          def_header["Sec-WebSocket-Accept"] = security_digest(@header["sec-websocket-key"])
+          extra_bytes = ""
+      end
+      header = def_header.merge(header)
+      header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
+      # Note that Upgrade and Connection must appear in this order.
+      write(
+        "HTTP/1.1 #{status}\r\n" +
+        "Upgrade: websocket\r\n" +
+        "Connection: Upgrade\r\n" +
+        "#{header_str}\r\n#{extra_bytes}")
+      flush()
+      @handshaked = true
+    end
+
+    def send(data)
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        when "hixie-75", "hixie-76"
+          data = force_encoding(data.dup(), "ASCII-8BIT")
+          write("\x00#{data}\xff")
+          flush()
+        else
+          send_frame(OPCODE_TEXT, data, !@server)
+      end
+    end
+    
+    def receive()
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        
+        when "hixie-75", "hixie-76"
+          packet = gets(force_encoding("\xff", "ASCII-8BIT"))
+          return nil if !packet
+          if packet =~ /\A\x00(.*)\xff\z/nm
+            return force_encoding($1, "UTF-8")
+          elsif packet == "\xff" && read(1) == "\x00" # closing
+            close(1005, "", :peer)
+            return nil
+          else
+            raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
+          end
+        
+        else
+          while true
+            begin
+              bytes = read(2).unpack("C*")
+              fin = (bytes[0] & 0x80) != 0
+              opcode = bytes[0] & 0x0f
+              mask = (bytes[1] & 0x80) != 0
+              plength = bytes[1] & 0x7f
+              if plength == 126
+                bytes = read(2)
+                plength = bytes.unpack("n")[0]
+              elsif plength == 127
+                bytes = read(8)
+                (high, low) = bytes.unpack("NN")
+                plength = high * (2 ** 32) + low
+              end
+              if @server && !mask
+                # Masking is required.
+                @socket.close()
+                raise(WebSocket::Error, "received unmasked data")
+              end
+              mask_key = mask ? read(4).unpack("C*") : nil
+              payload = read(plength)
+              payload = apply_mask(payload, mask_key) if mask
+              if WebSocket.debug
+                $stderr.printf("recv_frame> opcode:%d fin:%d payload:%p\n" % [opcode, fin ? 1 : 0, payload])
+              end
+              case opcode
+                when OPCODE_TEXT
+                  return force_encoding(payload, "UTF-8")
+                when OPCODE_BINARY
+                  raise(WebSocket::Error, "received binary data, which is not supported")
+                when OPCODE_CLOSE
+                  close(1005, "", :peer)
+                  return nil
+                when OPCODE_PING
+                  raise(WebSocket::Error, "received ping, which is not supported")
+                when OPCODE_PONG
+                  next
+                else
+                  raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
+              end
+            rescue EOFError
+              return nil
+            end
+          end
+      end
+    end
+    
+    def tcp_socket
+      return @socket
+    end
+
+    def host
+      return @header["host"]
+    end
+
+    def origin
+      case @web_socket_version
+        when "7", "8"
+          name = "sec-websocket-origin"
+        else
+          name = "origin"
+      end
+      if @header[name]
+        return @header[name]
+      else
+        raise(WebSocket::Error, "%s header is missing" % name)
+      end
+    end
+
+    def location
+      return "ws://#{self.host}#{@path}"
+    end
+    
+    # Does closing handshake.
+    def close(code = 1005, reason = "", origin = :self)
+      if !@closing_started
+        case @web_socket_version
+          when "hixie-75", "hixie-76"
+            write("\xff\x00")
+          else
+            if code == 1005
+              payload = ""
+            else
+              payload = [code].pack("n") + force_encoding(reason.dup(), "ASCII-8BIT")
+            end
+            send_frame(OPCODE_CLOSE, payload, false)
+        end
+      end
+      @socket.close() if origin == :peer
+      @closing_started = true
+    end
+    
+    def close_socket()
+      @socket.close()
+    end
+
+  private
+
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+    def read_header()
+      @header = {}
+      while line = gets()
+        line = line.chomp()
+        break if line.empty?
+        if !(line =~ /\A(\S+): (.*)\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @header[$1] = $2
+        @header[$1.downcase()] = $2
+      end
+      if !@header["upgrade"]
+        raise(WebSocket::Error, "Upgrade header is missing")
+      end
+      if !(@header["upgrade"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !@header["connection"]
+        raise(WebSocket::Error, "Connection header is missing")
+      end
+      if @header["connection"].split(/,/).grep(/\A\s*Upgrade\s*\z/i).empty?
+        raise(WebSocket::Error, "invalid Connection: " + @header["connection"])
+      end
+    end
+
+    def send_frame(opcode, payload, mask)
+      if WebSocket.debug
+        $stderr.printf("send_frame> opcode:%d masked:%d payload:%p\n" % [opcode, mask ? 1 : 0, payload])
+      end
+      payload = force_encoding(payload.dup(), "ASCII-8BIT")
+      # Setting StringIO's encoding to ASCII-8BIT.
+      buffer = StringIO.new(force_encoding("", "ASCII-8BIT"))
+      write_byte(buffer, 0x80 | opcode)
+      masked_byte = mask ? 0x80 : 0x00
+      if payload.bytesize <= 125
+        write_byte(buffer, masked_byte | payload.bytesize)
+      elsif payload.bytesize < 2 ** 16
+        write_byte(buffer, masked_byte | 126)
+        buffer.write([payload.bytesize].pack("n"))
+      else
+        write_byte(buffer, masked_byte | 127)
+        buffer.write([payload.bytesize / (2 ** 32), payload.bytesize % (2 ** 32)].pack("NN"))
+      end
+      if mask
+        mask_key = Array.new(4){ rand(256) }
+        buffer.write(mask_key.pack("C*"))
+        payload = apply_mask(payload, mask_key)
+      end
+      buffer.write(payload)
+      write(buffer.string)
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if WebSocket.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if WebSocket.debug
+      if str && str.bytesize == num_bytes
+        return str
+      else
+        raise(EOFError)
+      end
+    end
+
+    def write(data)
+      if WebSocket.debug
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def flush()
+      @socket.flush()
+    end
+    
+    def write_byte(buffer, byte)
+      buffer.write([byte].pack("C"))
+    end
+    
+    def security_digest(key)
+      return Base64.encode64(Digest::SHA1.digest(key + WEB_SOCKET_GUID)).gsub(/\n/, "")
+    end
+
+    def hixie_76_security_digest(key1, key2, key3)
+      bytes1 = websocket_key_to_bytes(key1)
+      bytes2 = websocket_key_to_bytes(key2)
+      return Digest::MD5.digest(bytes1 + bytes2 + key3)
+    end
+
+    def apply_mask(payload, mask_key)
+      orig_bytes = payload.unpack("C*")
+      new_bytes = []
+      orig_bytes.each_with_index() do |b, i|
+        new_bytes.push(b ^ mask_key[i % 4])
+      end
+      return new_bytes.pack("C*")
+    end
+
+    def generate_key()
+      spaces = 1 + rand(12)
+      max = 0xffffffff / spaces
+      number = rand(max + 1)
+      key = (number * spaces).to_s()
+      (1 + rand(12)).times() do
+        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+        pos = rand(key.size + 1)
+        key[pos...pos] = char
+      end
+      spaces.times() do
+        pos = 1 + rand(key.size - 1)
+        key[pos...pos] = " "
+      end
+      return key
+    end
+
+    def generate_key3()
+      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+    end
+
+    def websocket_key_to_bytes(key)
+      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
+      return [num].pack("N")
+    end
+
+    def force_encoding(str, encoding)
+      if str.respond_to?(:force_encoding)
+        return str.force_encoding(encoding)
+      else
+        return str
+      end
+    end
+
+    def ssl_handshake(socket)
+      ssl_context = OpenSSL::SSL::SSLContext.new()
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
+      ssl_socket.connect()
+      return ssl_socket
+    end
+
+end
+
+
+class WebSocketServer
+
+    def initialize(params_or_uri, params = nil)
+      if params
+        uri = params_or_uri.is_a?(String) ? URI.parse(params_or_uri) : params_or_uri
+        params[:port] ||= uri.port
+        params[:accepted_domains] ||= [uri.host]
+      else
+        params = params_or_uri
+      end
+      @port = params[:port] || 80
+      @accepted_domains = params[:accepted_domains]
+      if !@accepted_domains
+        raise(ArgumentError, "params[:accepted_domains] is required")
+      end
+      if params[:host]
+        @tcp_server = TCPServer.open(params[:host], @port)
+      else
+        @tcp_server = TCPServer.open(@port)
+      end
+    end
+
+    attr_reader(:tcp_server, :port, :accepted_domains)
+
+    def run(&block)
+      while true
+        Thread.start(accept()) do |s|
+          begin
+            ws = create_web_socket(s)
+            yield(ws) if ws
+          rescue => ex
+            print_backtrace(ex)
+          ensure
+            begin
+              ws.close_socket() if ws
+            rescue
+            end
+          end
+        end
+      end
+    end
+
+    def accept()
+      return @tcp_server.accept()
+    end
+
+    def accepted_origin?(origin)
+      domain = origin_to_domain(origin)
+      return @accepted_domains.any?(){ |d| File.fnmatch(d, domain) }
+    end
+
+    def origin_to_domain(origin)
+      if origin == "null" || origin == "file://"  # local file
+        return "null"
+      else
+        return URI.parse(origin).host
+      end
+    end
+
+    def create_web_socket(socket)
+      ch = socket.getc()
+      if ch == ?<
+        # This is Flash socket policy file request, not an actual Web Socket connection.
+        send_flash_socket_policy_file(socket)
+        return nil
+      else
+        socket.ungetc(ch) if ch
+        return WebSocket.new(socket, :server => self)
+      end
+    end
+
+  private
+
+    def print_backtrace(ex)
+      $stderr.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
+      for s in ex.backtrace[1..-1]
+        $stderr.printf("        %s\n", s)
+      end
+    end
+
+    # Handles Flash socket policy file request sent when web-socket-js is used:
+    # http://github.com/gimite/web-socket-js/tree/master
+    def send_flash_socket_policy_file(socket)
+      socket.puts('<?xml version="1.0"?>')
+      socket.puts('<!DOCTYPE cross-domain-policy SYSTEM ' +
+        '"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">')
+      socket.puts('<cross-domain-policy>')
+      for domain in @accepted_domains
+        next if domain == "file://"
+        socket.puts("<allow-access-from domain=\"#{domain}\" to-ports=\"#{@port}\"/>")
+      end
+      socket.puts('</cross-domain-policy>')
+      socket.close()
+    end
+
+end
+
+
+if __FILE__ == $0
+  Thread.abort_on_exception = true
+
+  if ARGV[0] == "server" && ARGV.size == 3
+
+    server = WebSocketServer.new(
+      :accepted_domains => [ARGV[1]],
+      :port => ARGV[2].to_i())
+    puts("Server is running at port %d" % server.port)
+    server.run() do |ws|
+      puts("Connection accepted")
+      puts("Path: #{ws.path}, Origin: #{ws.origin}")
+      if ws.path == "/"
+        ws.handshake()
+        while data = ws.receive()
+          printf("Received: %p\n", data)
+          ws.send(data)
+          printf("Sent: %p\n", data)
+        end
+      else
+        ws.handshake("404 Not Found")
+      end
+      puts("Connection closed")
+    end
+
+  elsif ARGV[0] == "client" && ARGV.size == 2
+
+    client = WebSocket.new(ARGV[1])
+    puts("Connected")
+    Thread.new() do
+      while data = client.receive()
+        printf("Received: %p\n", data)
+      end
+    end
+    $stdin.each_line() do |line|
+      data = line.chomp()
+      client.send(data)
+      printf("Sent: %p\n", data)
+    end
+
+  else
+
+    $stderr.puts("Usage:")
+    $stderr.puts("  ruby web_socket.rb server ACCEPTED_DOMAIN PORT")
+    $stderr.puts("  ruby web_socket.rb client ws://HOST:PORT/")
+    exit(1)
+
+  end
+end
+
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10

data/rubysocket.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'RubySocket/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rubysocket-client"
+  s.version     = RubySocket::Client::VERSION
+  s.authors     = ["KrishPranav"]
+  s.email       = [""]
+  s.homepage    = "http://github.com/krishpranav/rubysocket"
+  s.summary     = %q{ruby socket implem}
+  s.description = %q{ruby socket implementation}
+
+  s.rubyforge_project = "rubysocket-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "rest-client"
+end

data/spec/parser_spec.rb

@@ -0,0 +1,22 @@
+require 'RubySocket'
+
+describe Parser do
+  
+  it 'should be able to decode all valid messages' do
+    Parser.decode("0").should == {type: "0"}
+    Parser.decode("1::").should == {type: "1", id: nil, end_point: nil, data: ""}
+    Parser.decode("2::").should == {type: "2", id: nil, end_point: nil, data: ""}
+    Parser.decode("3:::hay you").should == {type: "3", id: nil, end_point: nil, data: "hay you"}
+    Parser.decode("4:::{\"can\":\"youcall\"}").should == {type: "4", id: nil, end_point: nil, data: "{\"can\":\"youcall\"}"}
+    Parser.decode("5:::hay you").should == {type: "5", id: nil, end_point: nil, data: "hay you"}
+    Parser.decode("6:::").should == {type: "6", id: nil, end_point: nil, data: ""}
+    Parser.decode("7:::there is an error").should == {type: "7", id: nil, end_point: nil, data: "there is an error"}
+    Parser.decode("8:::").should == {type: "8", id: nil, end_point: nil, data: ""}
+  end
+
+  it "should give a disconnect if bad input" do
+    Parser.decode("hay dude").should == {type: "0"}
+    Parser.decode("9").should == {type: "0"}
+  end
+
+end

data/spec/rubysocket_spec.rb

@@ -0,0 +1,45 @@
+describe RubySocket do
+  
+    before :all do
+      @client = RubySocket.connect("http://localhost", :sync => true)
+    end
+  
+    it "can send a heartbeat" do
+      @client.send_heartbeat
+    end
+  
+    it "gets a message back when it sends one" do
+      count = 0
+      @client.on_message do |msg|
+        count += 1 if msg == "hay dude"
+      end
+      @client.send("hay dude")
+      sleep 0.5
+      count.should == 1
+    end
+  
+    it "gets an emit back when it hits the echo" do
+      count = 0
+      @client.on_event("event") do |data|
+        count += 1 if data[0] == {"first"=>"element", "second"=>"guy"}
+      end 
+      @client.emit("event", {first: "element", second: "guy"})
+      sleep 0.5
+      count.should == 1
+    end
+  
+    it "can have a block for every thing" do
+      @client.on_disconnect { }
+      @client.on_connect { }
+      @client.on_heartbeat { }
+      @client.on_message { |msg| }
+      @client.on_json_message { |json| }
+      @client.on_event('en') { |event_hash| }
+      @client.on_ack { }
+      @client.on_error { |data| }
+      @client.on_noop { }
+    end
+  
+    
+  
+  end

data/spec/setup/io.js

@@ -0,0 +1,17 @@
+var io = require('socket.io').listen(80);
+
+io.sockets.on('connection', function(socket) {
+
+  socket.on('message', function(msg) {
+    socket.send(msg)
+  })
+
+  socket.on('event', function(data) {
+    socket.emit('event', data);
+  });
+
+  socket.on('dc', function() {
+  	socket.close()
+  })
+
+});

data/spec/setup/start.rb

@@ -0,0 +1,6 @@
+echo_server = fork do
+    puts `pwd`
+end
+
+puts "pid ??? #{echo_server}"
+Process.detach(echo_server)

data/spec/setup/stop.rb

@@ -0,0 +1,6 @@
+echo_server = fork do
+    puts `pwd`
+  end
+
+puts "pid ??? #{echo_server}"
+Process.detach(echo_server)

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rubysocket-client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- KrishPranav
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ruby socket implementation
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/RubySocket/version.rb
+- lib/parser.rb
+- lib/web_socket.rb
+- rubysocket.gemspec
+- spec/parser_spec.rb
+- spec/rubysocket_spec.rb
+- spec/setup/io.js
+- spec/setup/start.rb
+- spec/setup/stop.rb
+homepage: http://github.com/krishpranav/rubysocket
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: ruby socket implem
+test_files:
+- spec/parser_spec.rb
+- spec/rubysocket_spec.rb
+- spec/setup/io.js
+- spec/setup/start.rb
+- spec/setup/stop.rb