simpleblockingwebsocketclient 0.42 → 0.43

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bae507dffc762b0aba09d3d64e9ff29d15cd1447
+  data.tar.gz: 2589a59049b591e570e54637f2c0b127fe44c044
+SHA512:
+  metadata.gz: 32bc7ee3726a3c89525d5a423a337ddb29b1f407b05c9b441e4b4a6eb12a436124822912a20b4d232107af8791a8174721682f5870a06ff4cae1538b8ca407ac
+  data.tar.gz: 8b28ec38ebd303d2458c72ebc9536a9e89e365115f8961826cd82a44f7f1d878ed54ccc004e2db95cb94197b404f9b9664849fc7247619983e3da080fa1076e5

data/.gitignore

@@ -1 +1 @@
-exp
+.idea

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    simple (0.43)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  simple!

data/lib/ws.rb

@@ -0,0 +1,210 @@
+#
+# = net/ws.rb
+#
+# Copyright (c) 2013-2013 Marvin Frick
+#
+# Written and maintained by Marvin Frick <marvinfrick@gmx.de>.
+#
+#
+# This program is free software. You can re-distribute and/or
+# modify this program under the same terms of ruby itself ---
+# Ruby Distribution License or GNU General Public License.
+#
+# See Net::WS for an overview and examples.
+#
+
+require 'net/http'
+require "digest/sha1"
+require "base64"
+
+class Net::WSError < Net::ProtocolError
+  def initialize(msg, res=nil) #:nodoc:
+    super msg
+    @response = res
+  end
+
+  attr_reader :response
+end
+
+module Net #:nodoc:
+  autoload :OpenSSL, 'openssl'
+
+  class WS < Protocol
+    class << self
+      attr_accessor(:debug)
+    end
+
+    WSVersion = "13"
+    WS_MAGIC_STRING = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
+    def initialize(arg)
+      uri = arg.is_a?(String) ? URI.parse(arg) : arg
+      origin = "http://#{uri.host}"
+      key = generate_key
+
+      http = HTTP.new(uri.host, uri.port).start
+      handshake = http.send_request("GET", uri.path.empty? ? "/" : uri.path, nil, initheader(key, origin))
+      if handshake["sec-websocket-accept"] != security_digest(key)
+        raise Net::WSError.new("Sec-Websocket-Accept missmatch", handshake)
+      end
+      @handshaked = true
+      @socket = http.instance_variable_get(:@socket).io
+
+      if block_given?
+        @rth = Thread.new do
+          while data = receive()
+            yield data
+          end
+        end
+      end
+
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if Net::WS.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if Net::WS.debug
+      if str && str.bytesize == num_bytes
+        return str
+      else
+        raise(EOFError)
+      end
+    end
+
+    def receive
+      if !@handshaked
+        raise Net::WSError.new("call WebSocket\#handshake first")
+      end
+
+      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(WSError, "received unmasked data")
+        end
+        mask_key = mask ? read(4).unpack("C*") : nil
+        payload = read(plength)
+        payload = apply_mask(payload, mask_key) if mask
+        case opcode
+          when OPCODE_TEXT
+            return payload
+          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
+          else
+            raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
+        end
+      rescue EOFError
+        return nil
+      end
+    end
+
+    def write(data)
+      if WS.debug
+        puts data
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def send(data)
+      if !@handshaked
+        raise Net::WSError.new("call WebSocket\#handshake first")
+      else
+        send_frame(OPCODE_TEXT, data, false)
+      end
+    end
+
+    def send_frame(opcode, payload, mask)
+      buffer = StringIO.new()
+      buffer.set_encoding("UTF-8")
+      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 write_byte(buffer, byte)
+      buffer.write([byte].pack("C"))
+    end
+
+    def initheader(key, origin)
+      {
+          "Upgrade" => "websocket",
+          "Connection" => "Upgrade",
+          "Sec-WebSocket-Key" => "#{key}",
+          "Sec-WebSocket-Version" => WSVersion,
+          "Origin" => "#{origin}"
+      }
+    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
+      Base64.encode64(key).chop
+    end
+
+    def security_digest(key)
+      Base64.encode64(Digest::SHA1.digest(key + WS_MAGIC_STRING)).gsub(/\n/, "")
+    end
+
+  end
+
+end

data/samples/simple_echo_server.rb

@@ -0,0 +1,25 @@
+# this file makes use of EventMachine and its purpose is 
+# solely to have a server to connect to for testing the client lib.
+
+require 'em-websocket'
+
+EM.run {
+  EM::WebSocket.run(:host => "0.0.0.0", :port => 8080) do |ws|
+    ws.onopen { |handshake|
+      puts "WebSocket connection open"
+
+      # Access properties on the EM::WebSocket::Handshake object, e.g.
+      # path, query_string, origin, headers
+
+      # Publish message to the client
+      ws.send "Hello Client, you connected to #{handshake.path}"
+    }
+
+    ws.onclose { puts "Connection closed" }
+
+    ws.onmessage { |msg|
+      puts "Recieved message: #{msg}"
+      ws.send "Pong: #{msg}"
+    }
+  end
+}

data/samples/stdio_client.rb

@@ -1,15 +1,13 @@
-# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
-# Lincense: New BSD Lincense
 
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
-require "web_socket"
+require "ws"
 
 if ARGV.size != 1
   $stderr.puts("Usage: ruby samples/stdio_client.rb ws://HOST:PORT/")
   exit(1)
 end
 
-client = WebSocket.new(ARGV[0]) { |data| puts data}
+client = Net::WS.new(ARGV[0]) { |data| puts data }
 puts("Connected")
 
 $stdin.each_line() do |line|

data/simpleblockingwebsocketclient.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Marvin Frick"]
   gem.email         = ["frick@informatik.uni-luebeck.de"]
   gem.description   = %q{Ruby gem to connect to a websocket server}
-  gem.summary       = %q{Allows you to connect to a websocket server-side, using the hixie-76 protocol version. Sending and receiving data is supported. That's it.}
+  gem.summary       = %q{Allows you to connect to a websocket server-side, using the RFC 6455 protocol version. Sending and receiving data is supported. That's it.}
   gem.homepage      = "https://github.com/MrMarvin/simpleblockingwebsocketclient"
 
   gem.files         = `git ls-files`.split($\)
@@ -12,5 +12,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "simpleblockingwebsocketclient"
   gem.require_paths = ["lib"]
-  gem.version       = "0.42"
+  gem.version       = "0.43"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simpleblockingwebsocketclient
 version: !ruby/object:Gem::Version
-  version: '0.42'
-  prerelease: 
+  version: '0.43'
 platform: ruby
 authors:
 - Marvin Frick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-18 00:00:00.000000000 Z
+date: 2013-03-06 00:00:00.000000000 Z
 dependencies: []
 description: Ruby gem to connect to a websocket server
 email:
@@ -20,35 +19,36 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - README.md
 - Rakefile
-- lib/simpleblockingwebsocketclient.rb
+- lib/ws.rb
 - pkg/simpleblockingwebsocketclient-0.42.gem
+- samples/simple_echo_server.rb
 - samples/stdio_client.rb
 - simpleblockingwebsocketclient.gemspec
 homepage: https://github.com/MrMarvin/simpleblockingwebsocketclient
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
-summary: Allows you to connect to a websocket server-side, using the hixie-76 protocol
+specification_version: 4
+summary: Allows you to connect to a websocket server-side, using the RFC 6455 protocol
   version. Sending and receiving data is supported. That's it.
 test_files: []

data/lib/simpleblockingwebsocketclient.rb

@@ -1,405 +0,0 @@
-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 = {})
-
-        @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
-
-      @received = []
-      @buffer = ""
-      @closing_started = false
-      
-      if block_given?
-        @rth = Thread.new do
-          while data = receive()
-            yield data
-          end
-        end
-      end
-      
-    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("\xff")
-          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
-          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
-            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
-              else
-                raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
-            end
-          rescue EOFError
-            return nil
-          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)
-      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