webtube 1.0.0 → 1.1.0

data/bin/wsc

@@ -1,14 +1,15 @@
 #! /usr/bin/ruby
 
-# WebSocketCat, a primitive CLI tool for manually talking to WebSocket servers
+# WebSocketCat, a primitive CLI tool for manually talking to
+# WebSocket servers
 
 require 'base64'
 require 'getoptlong'
 require 'webtube'
 
-VERSION_DATA = "WebSocketCat 1.0.0 (Webtube 1.0.0)
-Copyright (C) 2014 Andres Soolo
-Copyright (C) 2014 Knitten Development Ltd.
+VERSION_DATA = "WebSocketCat 1.1.0 (Webtube 1.1.0)
+Copyright (C) 2014-2018 Andres Soolo
+Copyright (C) 2014-2018 Knitten Development Ltd.
 
 Licensed under GPLv3+: GNU GPL version 3 or later
   <http://gnu.org/licenses/gpl.html>
@@ -20,13 +21,16 @@ There is NO WARRANTY, to the extent permitted by law.
 
 "
 
-USAGE = "Usage: wsc [options] ws[s]://host[:port][/path]
+USAGE = "Usage: wsc [options] ws[s]://host[:port][/path][?query]
 
 Interact with a WebSocket server, telnet-style.
 
 --header, -H=name:value
     Use the given HTTP header field in the request.
 
+--cacert=FILENAME
+    Load trusted root certificate(s) from the given PEM file.
+
 --insecure, -k
     Allow connecting to an SSL server with invalid certificate.
 
@@ -46,33 +50,36 @@ ONLINE_HELP = "WebSocketCat's commands are slash-prefixed.
   Send a ping frame to the server.
 
 /close [status [explanation]]
-  Send a close frame to the server.  The status code is specified as an
-  unsigned decimal number.
+  Send a close frame to the server.  The status code is
+  specified as an unsigned decimal number.
 
 /N [payload]
-  Send a message or control frame of opcode [[N]], given as a single hex digit,
-  to the server.  Per protocol specification, [[/1]] is text message, [[/2]] is
-  binary message, [[/8]] is close, [[/9]] is ping, [[/A]] is pong.  Other
-  opcodes can have application-specific meaning.  Note that the specification
-  requires kicking clients (or servers) who send messages so cryptic that the
-  server (or client) can't understand them.
+  Send a message or control frame of opcode [[N]], given as a
+  single hex digit, to the server.  Per protocol specification,
+  [[/1]] is text message, [[/2]] is binary message, [[/8]] is
+  close, [[/9]] is ping, [[/A]] is pong.  Other opcodes can have
+  application-specific meaning.  Note that the specification
+  requires kicking clients (or servers) who send messages so
+  cryptic that the server (or client) can't understand them.
 
 /help
   Show this online help.
 
-If you need to start a text message with a slash, you can double it for escape,
-or you can use the explicit [[/1]] command.  EOF from stdin is equivalent to
-[[/close 1000]].
+If you need to start a text message with a slash, you can double
+it for escape, or you can use the explicit [[/1]] command.  EOF
+from stdin is equivalent to [[/close 1000]].
 
 "
 
 $header = {} # lowercased field name => value
 $insecure = false
+$cert_store = nil
 
 $0 = 'wsc' # for [[GetoptLong]] error reporting
 begin
   GetoptLong.new(
       ['--header', '-H', GetoptLong::REQUIRED_ARGUMENT],
+      ['--cacert', GetoptLong::REQUIRED_ARGUMENT],
       ['--insecure', '-k', GetoptLong::NO_ARGUMENT],
       ['--help', GetoptLong::NO_ARGUMENT],
       ['--version', GetoptLong::NO_ARGUMENT],
@@ -81,7 +88,8 @@ begin
     when '--header' then
       name, value = arg.split /\s*:\s*/, 2
       if value.nil? then
-        $stderr.puts "wsc: colon missing in argument to --header"
+        $stderr.puts "wsc: colon missing in argument to " +
+            "--header"
         exit 1
       end
       name.downcase!
@@ -91,6 +99,9 @@ begin
       else
         $header[name] = value
       end
+    when '--cacert' then
+      $cert_store ||= OpenSSL::X509::Store.new
+      $cert_store.add_file arg
     when '--insecure' then
       $insecure = true
     when '--help' then
@@ -113,8 +124,8 @@ unless ARGV.length == 1 then
   exit 1
 end
 
-# The events incoming over the WebSocket will be listened to by this object,
-# and promptly shown to the user.
+# The events incoming over the WebSocket will be listened to by
+# this object, and promptly shown to the user.
 
 class << $listener = Object.new
   def onopen webtube
@@ -132,8 +143,8 @@ class << $listener = Object.new
   end
 
   def oncontrolframe webtube, frame
-    # We'll ignore 9 (ping) and 10 (pong) here, as they are already processed
-    # by handlers of their own.
+    # We'll ignore 9 (ping) and 10 (pong) here, as they are
+    # already processed by handlers of their own.
     unless [9, 10].include? frame.opcode then
       puts "*#{'%X' % opcode}* #{frame.payload.inspect}"
     end
@@ -154,8 +165,9 @@ class << $listener = Object.new
     if frame.body.bytesize >= 2 then
       status_code, = frame.body.unpack 'n'
       message = frame.body.byteslice 2 .. -1
-      message.force_encoding 'UTF-8'
-      message.force_encoding 'ASCII-8BIT' unless message.valid_encoding?
+      message.force_encoding Encoding::UTF_8
+      message.force_encoding Encoding::ASCII_8BIT \
+          unless message.valid_encoding?
       message = nil if message.empty?
     else
       status_code = nil
@@ -179,26 +191,33 @@ end
 puts "Connecting to #{ARGV.first} ..."
 
 $webtube = Webtube.connect ARGV.first,
-    header_fields: $header,
+    http_header: $header,
     allow_opcodes: 1 .. 15,
-    ssl_verify_mode: $insecure ? OpenSSL::SSL::VERIFY_NONE : nil,
+    ssl_verify_mode: $insecure ?
+        OpenSSL::SSL::VERIFY_NONE :
+        OpenSSL::SSL::VERIFY_PEER,
+    ssl_cert_store: $cert_store,
+    on_http_request: proc{ |request|
+      # Show the HTTP request to the user
+      request.rstrip.each_line do |s|
+        puts "> #{s.rstrip}"
+      end
+      puts
+    },
     on_http_response: proc{ |response|
       # Show the HTTP response to the user
-      puts "| #{response.code} #{response.message}"
-      response.each_key do |key|
-        response.get_fields(key).each do |value|
-          puts "| #{key}: #{value}"
-        end
+      response.rstrip.each_line do |s|
+        puts "< #{s.rstrip}"
       end
       puts
     }
 
-# [[$listener]] will send us, via [[$send_thread]], the [[StopSendThread]]
-# exception when the other side goes away.
+# [[$listener]] will send us, via [[$send_thread]], the
+# [[StopSendThread]] exception when the other side goes away.
 $send_thread = Thread.current
 
-# [[Webtube#run]] will hog the whole thread it runs on, so we'll give it a
-# thread of its own.
+# [[Webtube#run]] will hog the whole thread it runs on, so we'll
+# give it a thread of its own.
 $recv_thread = Thread.new do
   begin
     $webtube.run $listener

data/lib/webtube.rb

@@ -1,12 +1,11 @@
-# webtube.rb -- an implementation of the WebSocket extension of HTTP
+# webtube.rb -- an implementation of the WebSocket extension of
+# HTTP
 
-require 'base64'
-require 'digest/sha1'
 require 'net/http'
+require 'openssl'
 require 'securerandom'
 require 'thread'
 require 'uri'
-require 'webrick/httprequest'
 
 class Webtube
   # Not all the possible 16 values are defined by the standard.
@@ -20,19 +19,27 @@ class Webtube
   attr_accessor :allow_rsv_bits
   attr_accessor :allow_opcodes
 
-  # The following three slots are not used by the [[Webtube]] infrastructrue.
-  # They have been defined purely so that application code could easily
-  # associate data it finds significant to [[Webtube]] instances.
+  attr_reader :url
+      # only available if the [[WebTube]] was instantiated via
+      # [[Webtube::connect]] as the client end of a WebSocket
+      # connection
 
-  attr_accessor :header # [[accept_webtube]] saves the request object here
+  # The following three slots are not used by the [[Webtube]]
+  # infrastructrue.  They have been defined purely so that
+  # application code could easily associate data it finds
+  # significant to [[Webtube]] instances.
+
+  attr_accessor :header
+      # [[accept_webtube]] saves the request object here
   attr_accessor :session
   attr_accessor :context
 
   def initialize socket,
       serverp,
-          # If true, we will expect incoming data masked and will not mask
-          # outgoing data.  If false, we will expect incoming data unmasked and
-          # will mask outgoing data.
+          # If true, we will expect incoming data masked and
+          # will not mask outgoing data.  If false, we will
+          # expect incoming data unmasked and will mask outgoing
+          # data.
       allow_rsv_bits: 0,
       allow_opcodes: [Webtube::OPCODE_TEXT],
       close_socket: true
@@ -45,72 +52,84 @@ class Webtube
     @defrag_buffer = []
     @alive = true
     @send_mutex = Mutex.new
-        # Guards message sending, so that fragmented messages won't get
-        # interleaved, and the [[@alive]] flag.
+        # Guards message sending, so that fragmented messages
+        # won't get interleaved, and the [[@alive]] flag.
     @run_mutex = Mutex.new
         # Guards the main read loop.
     @receiving_frame = false
-        # Are we currently receiving a frame for the [[Webtube#run]] main loop?
+        # Are we currently receiving a frame for the
+        # [[Webtube#run]] main loop?
     @reception_interrupt_mutex = Mutex.new
         # guards [[@receiving_frame]]
     return
   end
 
-  # Run a loop to read all the messages and control frames coming in via this
-  # WebSocket, and hand events to the given [[listener]].  The listener can
-  # implement the following methods:
+  # Run a loop to read all the messages and control frames
+  # coming in via this WebSocket, and hand events to the given
+  # [[listener]].  The listener can implement the following
+  # methods:
   #
-  # - onopen(webtube) will be called as soon as the channel is set up.
+  # - onopen(webtube) will be called as soon as the channel is
+  #   set up.
   #
-  # - onmessage(webtube, message_body, opcode) will be called with each
-  #   arriving data message once it has been defragmented.  The data will be
-  #   passed to it as a [[String]], encoded in [[UTF-8]] for [[OPCODE_TEXT]]
-  #   messages and in [[ASCII-8BIT]] for all the other message opcodes.
+  # - onmessage(webtube, message_body, opcode) will be called
+  #   with each arriving data message once it has been
+  #   defragmented.  The data will be passed to it as a
+  #   [[String]], encoded in [[UTF-8]] for [[OPCODE_TEXT]]
+  #   messages and in [[ASCII-8BIT]] for all the other message
+  #   opcodes.
   #
-  # - oncontrolframe(webtube, frame) will be called upon receipt of a control
-  #   frame whose opcode is listed in the [[allow_opcodes]] parameter of this
-  #   [[Webtube]] instance.  The frame is repreented by an instance of
-  #   [[Webtube::Frame]].  Note that [[Webtube]] handles connection closures
-  #   ([[OPCODE_CLOSE]]) and ponging all the pings ([[OPCODE_PING]])
-  #   automatically.
+  # - oncontrolframe(webtube, frame) will be called upon receipt
+  #   of a control frame whose opcode is listed in the
+  #   [[allow_opcodes]] parameter of this [[Webtube]] instance.
+  #   The frame is represented by an instance of
+  #   [[Webtube::Frame]].  Note that [[Webtube]] handles
+  #   connection closures ([[OPCODE_CLOSE]]) and ponging all the
+  #   pings ([[OPCODE_PING]]) automatically.
   #
-  # - onping(webtube, frame) will be called upon receipt of an [[OPCODE_PING]]
-  #   frame.  [[Webtube]] will take care of ponging all the pings, but the
-  #   listener may want to process such an event for statistical information.
+  # - onping(webtube, frame) will be called upon receipt of an
+  #   [[OPCODE_PING]] frame.  [[Webtube]] will take care of
+  #   ponging all the pings, but the listener may want to
+  #   process such an event for statistical information.
   #
-  # - onpong(webtube, frame) will be called upon receipt of an [[OPCODE_PONG]]
-  #   frame.
+  # - onpong(webtube, frame) will be called upon receipt of an
+  #   [[OPCODE_PONG]] frame.
   #
-  # - onclose(webtube) will be called upon closure of the connection, for any
-  #   reason.
+  # - onclose(webtube) will be called upon closure of the
+  #   connection, for any reason.
   #
-  # - onannoyedclose(webtube, frame) will be called upon receipt of an
-  #   [[OPCODE_CLOSE]] frame with an explicit status code other than 1000.
-  #   This typically indicates that the other side is annoyed, so the listener
-  #   may want to log the condition for debugging or further analysis.
-  #   Normally, once the handler returns, [[Webtube]] will respond with a close
-  #   frame of the same status code and close the connection, but the handler
-  #   may call [[Webtube#close]] to request a closure with a different status
-  #   code or without one.
+  # - onannoyedclose(webtube, frame) will be called upon receipt
+  #   of an [[OPCODE_CLOSE]] frame with an explicit status code
+  #   other than 1000.  This typically indicates that the other
+  #   side is annoyed, so the listener may want to log the
+  #   condition for debugging or further analysis.  Normally,
+  #   once the handler returns, [[Webtube]] will respond with a
+  #   close frame of the same status code and close the
+  #   connection, but the handler may call [[Webtube#close]] to
+  #   request a closure with a different status code or without
+  #   one.
   #
-  # - onexception(webtube, exception) will be called if an unhandled exception
-  #   is raised during the [[Webtube]]'s lifecycle, including all of the
-  #   listener event handlers.  It may log the exception but should return
-  #   normally so that the [[Webtube]] can issue a proper close frame for the
-  #   other end and invoke the [[onclose]] handler, after which the exception
-  #   will be raised again so the caller of [[Webtube#run]] will have a chance
-  #   of handling it.
+  # - onexception(webtube, exception) will be called if an
+  #   unhandled exception is raised during the [[Webtube]]'s
+  #   lifecycle, including all of the listener event handlers.
+  #   It may log the exception but should return normally so
+  #   that the [[Webtube]] can issue a proper close frame for
+  #   the other end and invoke the [[onclose]] handler, after
+  #   which the exception will be raised again so the caller of
+  #   [[Webtube#run]] will have a chance to handle it.
   #
-  # Before calling any of the handlers, [[respond_to?]] will be used to check
-  # implementedness.
+  # Before calling any of the handlers, [[respond_to?]] will be
+  # used to check implementedness.
   #
-  # If an exception occurs during processing, it may implement a specific
-  # status code to be passed to the other end via the [[OPCODE_CLOSE]] frame by
-  # implementing the [[websocket_close_status_code]] method returning the code
-  # as an integer.  The default code, used if the exception does not specify
-  # one, is 1011 'unexpected condition'.  An exception may explicitly suppress
-  # sending any code by having [[websocket_close_status_code]] return [[nil]]
-  # instead of an integer.
+  # If an exception occurs during processing, it (that is, the
+  # [[Exception]] instance) may implement a specific status code
+  # to be passed to the other end via the [[OPCODE_CLOSE]] frame
+  # by implementing the [[websocket_close_status_code]] method
+  # returning the code as an integer.  The default code, used if
+  # the exception does not specify one, is 1011 'unexpected
+  # condition'.  An exception may explicitly suppress sending
+  # any code by having [[websocket_close_status_code]] return
+  # [[nil]] instead of an integer.
   #
   def run listener
     @run_mutex.synchronize do
@@ -133,11 +152,13 @@ class Webtube
           end
           if @serverp then
             unless frame.masked?
-              raise Webtube::UnmaskedFrameToServer.new(frame: frame)
+              raise Webtube::UnmaskedFrameToServer.new(
+                  frame: frame)
             end
           else
             unless !frame.masked? then
-              raise Webtube::MaskedFrameToClient.new(frame: frame)
+              raise Webtube::MaskedFrameToClient.new(
+                  frame: frame)
             end
           end
           if !frame.control_frame? then
@@ -153,7 +174,8 @@ class Webtube
             else
               # continuation frame
               if @defrag_buffer.empty? then
-                raise Webtube::UnexpectedContinuationFrame.new(frame: frame)
+                raise Webtube::UnexpectedContinuationFrame.new(
+                    frame: frame)
               end
             end
             @defrag_buffer.push frame
@@ -162,11 +184,13 @@ class Webtube
               data = @defrag_buffer.map(&:payload).join ''
               @defrag_buffer = []
               if opcode == Webtube::OPCODE_TEXT then
-                # text messages must be encoded in UTF-8, as per RFC 6455
-                data.force_encoding 'UTF-8'
+                # text messages must be encoded in UTF-8, per
+                # RFC 6455
+                data.force_encoding Encoding::UTF_8
                 unless data.valid_encoding? then
-                  data.force_encoding 'ASCII-8BIT'
-                  raise Webtube::BadlyEncodedText.new(data: data)
+                  data.force_encoding Encoding::ASCII_8BIT
+                  raise Webtube::BadlyEncodedText.new(
+                      data: data)
                 end
               end
               listener.onmessage self, data, opcode \
@@ -175,7 +199,8 @@ class Webtube
           elsif (0x08 .. 0x0F).include? frame.opcode then
             # control frame
             unless frame.fin? then
-              raise Webtube::FragmentedControlFrame.new(frame: frame)
+              raise Webtube::FragmentedControlFrame.new(
+                  frame: frame)
             end
             case frame.opcode
             when Webtube::OPCODE_CLOSE then
@@ -191,11 +216,12 @@ class Webtube
               end
               close status_code
             when Webtube::OPCODE_PING then
-              listener.onping self, frame if listener.respond_to? :onping
+              listener.onping self, frame \
+                  if listener.respond_to? :onping
               send_message frame.payload, Webtube::OPCODE_PONG
             when Webtube::OPCODE_PONG then
-              listener.onpong self, frame if listener.respond_to? :onpong
-              # ignore
+              listener.onpong self, frame \
+                  if listener.respond_to? :onpong
             else
               unless @allow_opcodes.include? frame.opcode then
                 raise Webtube::UnknownOpcode.new(frame: frame)
@@ -211,12 +237,14 @@ class Webtube
       rescue AbortReceiveLoop
         # we're out of the loop now, so nothing further to do
       rescue Exception => e
-        status_code = if e.respond_to? :websocket_close_status_code then
-          e.websocket_close_status_code
-        else
-          1011 # 'unexpected condition'
-        end
-        listener.onexception self, e if listener.respond_to? :onexception
+        status_code =
+            if e.respond_to? :websocket_close_status_code then
+              e.websocket_close_status_code
+            else
+              1011 # 'unexpected condition'
+            end
+        listener.onexception self, e \
+            if listener.respond_to? :onexception
         begin
           close status_code
         rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN
@@ -225,56 +253,69 @@ class Webtube
         raise e
       ensure
         @thread = nil
-        listener.onclose self if listener.respond_to? :onclose
+        listener.onclose self \
+            if listener.respond_to? :onclose
       end
     end
     return
   end
 
-  # Send a given message payload to the other party, using the given opcode.
-  # By default, the [[opcode]] is [[Webtube::OPCODE_TEXT]].  Re-encodes the
-  # payload if given in a non-UTF-8 encoding and [[opcode ==
+  # Send a given message payload to the other party, using the
+  # given opcode.  By default, the [[opcode]] is
+  # [[Webtube::OPCODE_TEXT]].  Re-encodes the payload if given
+  # in a non-UTF-8 encoding and [[opcode ==
   # Webtube::OPCODE_TEXT]].
   def send_message message, opcode = Webtube::OPCODE_TEXT
-    if opcode == Webtube::OPCODE_TEXT and message.encoding.name != 'UTF-8' then
-      message = message.encode 'UTF-8'
+    if opcode == Webtube::OPCODE_TEXT and
+        message.encoding != Encoding::UTF_8 then
+      message = message.encode Encoding::UTF_8
     end
     @send_mutex.synchronize do
       raise 'WebSocket connection no longer live' unless @alive
-      # In order to ensure that the local kernel will treat our (data) frames
-      # atomically during the [[write]] syscall, we'll want to ensure that the
-      # frame size does not exceed 512 bytes -- the minimum permitted size for
-      # [[PIPE_BUF]].  At this frame size, the header size is up to four bytes
-      # for unmasked or eight bytes for masked frames.
+      # In order to ensure that the local kernel will treat our
+      # (data) frames atomically during the [[write]] syscall,
+      # we'll want to ensure that the frame size does not exceed
+      # 512 bytes -- the minimum permitted size for
+      # [[PIPE_BUF]].  At this frame size, the header size is up
+      # to four bytes for unmasked or eight bytes for masked
+      # frames.
+      #
+      # (FIXME: in retrospect, that seems like an unpractical
+      # consideration.  We should probably use path MTU
+      # instead.)
       Webtube::Frame.each_frame_for_message(
           message: message,
           opcode: opcode,
           masked: !@serverp,
-          max_frame_body_size: 512 - (!@serverp ? 8 : 4)) do |frame|
+          max_frame_body_size:
+              512 - (!@serverp ? 8 : 4)) do |frame|
         @socket.write frame.header + frame.body
       end
     end
     return
   end
 
-  # Close the connection, thus preventing further processing.
+  # Closes the connection, thus preventing further transmission.
   #
-  # If [[status_code]] is supplied, it will be passed to the other side in the
-  # [[OPCODE_CLOSE]] frame.  The default is 1000 which indicates normal
-  # closure.  Sending a status code can be explicitly suppressed by passing
-  # [[nil]] instead of an integer; then, an empty close frame will be sent.
-  # Due to the way a close frame's payload is structured, this will also
-  # suppress delivery of [[close_explanation]], even if non-empty.
+  # If [[status_code]] is supplied, it will be passed to the
+  # other side in the [[OPCODE_CLOSE]] frame.  The default is
+  # 1000 which indicates normal closure.  Sending a status code
+  # can be explicitly suppressed by passing [[nil]] instead of
+  # an integer; then, an empty close frame will be sent.  Due to
+  # the way a close frame's payload is structured, this will
+  # also suppress delivery of [[close_explanation]], even if
+  # non-empty.
   #
-  # Note that RFC 6455 requires the explanation to be encoded in UTF-8.
-  # Accordingly, this method will re-encode it unless it is already in UTF-8.
+  # Note that RFC 6455 requires the explanation to be encoded in
+  # UTF-8.  Accordingly, this method will re-encode it unless it
+  # is already in UTF-8.
   def close status_code = 1000, explanation = ""
     # prepare the payload for the close frame
     payload = ""
     if status_code then
       payload = [status_code].pack('n')
       if explanation then
-        payload << explanation.encode('UTF-8')
+        payload << explanation.encode(Encoding::UTF_8)
       end
     end
     # let the other side know we're closing
@@ -291,121 +332,312 @@ class Webtube
     return
   end
 
-  # Attempt to set up a [[WebSocket]] connection to the given [[url]].  Return
-  # the [[Webtube]] instance if successful or raise an appropriate
-  # [[Webtube::WebSocketUpgradeFailed]].
+  def inspect
+    s = "#<Webtube@0x%0x" % object_id
+    s << " " << (@server ? 'from' : 'to')
+    unless @url.nil? then
+      s << " " << @url
+    else
+      # [[@socket]] is a [[Net::BufferedIO]] instance, so
+      # [[@socket.io]] is either a plain socket or an SSL
+      # wrapper
+      af, port, hostname = @socket.io.peeraddr
+      s << " %s:%i" % [hostname, port]
+    end
+    s << " @allow_rsv_bits=%s" % @allow_rsv_bits.inspect \
+        unless @allow_rsv_bits.nil?
+    s << " @allow_opcodes=%s" % @allow_opcodes.inspect \
+        unless @allow_opcodes.nil?
+    s << ">"
+    return s
+  end
+
+  # Attempts to set up a [[WebSocket]] connection to the given
+  # [[url]].  Returns the [[Webtube]] instance if successful or
+  # raise an appropriate [[Webtube::WebSocketUpgradeFailed]].
   def self::connect url,
-      header_fields: {},
-      ssl_verify_mode: nil,
-      on_http_response: nil,
       allow_rsv_bits: 0,
       allow_opcodes: [Webtube::OPCODE_TEXT],
-      close_socket: true
-    # We'll replace the WebSocket protocol prefix with an HTTP-based one so
-    # [[URI::parse]] would know how to parse the rest of the URL.
-    case url
-      when /\Aws:/ then
-        hturl = 'http:' + $'
-        ssl = false
-        default_port = 80
-      when /\Awss:/ then
-        hturl = 'https:' + $'
-        ssl = true
-        default_port = 443
-      else
-        raise "unknown URI scheme; use ws: or wss: instead"
+      http_header: {},
+      ssl_verify_mode: OpenSSL::SSL::VERIFY_PEER,
+      ssl_cert_store: nil,
+          # or an [[OpenSSL::X509::Store]] instance
+      tcp_connect_timeout: nil, # or number of seconds
+      tcp_nodelay: true,
+      close_socket: true,
+      on_http_request: nil,
+      on_http_response: nil,
+      on_ssl_handshake: nil,
+      on_tcp_connect: nil
+    loc = Webtube::Location.new url
+
+    socket = if tcp_connect_timeout.nil? then
+      TCPSocket.new loc.host, loc.port
+    else
+      Timeout.timeout tcp_connect_timeout, Net::OpenTimeout do
+        TCPSocket.new loc.host, loc.port
+      end
     end
-    hturi = URI.parse hturl
-
-    reqhdr = {}
+    if tcp_nodelay then
+      socket.setsockopt Socket::IPPROTO_TCP,
+          Socket::TCP_NODELAY, 1
+    end
+    on_tcp_connect.call socket if on_tcp_connect
 
-    # Copy over the user-supplied header fields.  Since Ruby hashes are
-    # case-sensitive but HTTP header field names are case-insensitive, we may
-    # have to combine fields whose names only differ in case.
-    header_fields.each_pair do |name, value|
-      name = name.downcase
-      if reqhdr.has_key? name then
-        reqhdr[name] += ', ' + value
-      else
-        reqhdr[name] = value
+    if loc.ssl? then
+      # construct an SSL context
+      if ssl_cert_store.nil? then
+	ssl_cert_store = OpenSSL::X509::Store.new
+	ssl_cert_store.set_default_paths
+      end
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.cert_store = ssl_cert_store
+      ssl_context.verify_mode = ssl_verify_mode
+      # wrap the socket
+      socket = OpenSSL::SSL::SSLSocket.new socket, ssl_context
+      socket.sync_close = true
+      socket.hostname = loc.host # Server Name Indication
+      socket.connect # perform SSL handshake
+      socket.post_connection_check loc.host
+      on_ssl_handshake.call socket if on_ssl_handshake
+    end
+
+    socket = Net::BufferedIO.new socket
+
+    # transmit the request
+    req = Webtube::Request.new loc, http_header
+    composed_request = req.to_s
+    socket.write composed_request
+    on_http_request.call composed_request if on_http_request
+
+    # wait for response
+    response = Net::HTTPResponse.read_new socket
+
+    if on_http_response then
+      # reconstitute the response as a string
+      #
+      # (XXX: this loses some diagnostically useful bits, but
+      # [[Net::HTTPResponse::read_new]] just doesn't preserve
+      # the pristine original)
+      s = "#{response.code} #{response.message}\r\n"
+      response.each_header do |k, v|
+        s << "#{k}: #{v}\r\n"
       end
+      s << "\r\n"
+      on_http_response.call s
     end
 
-    # Set up the WebSocket header fields (but we'll give user-specified values,
-    # if any, precedence)
-    reqhdr['host'] ||=
-        hturi.host + (hturi.port != default_port ? ":#{hturi.port}" : "")
-    reqhdr['upgrade'] ||= 'websocket'
-    reqhdr['connection'] ||= 'upgrade'
-    reqhdr['sec-websocket-key'] ||= SecureRandom.base64(16)
-    reqhdr['sec-websocket-version'] ||= '13'
+    # Check that the server is seeing us now
+    # FIXME: ensure that the socket will be closed in case of
+    # exception
+    d = rejection response, req.expected_accept
+    raise Webtube::WebSocketDeclined.new(d) \
+        if d
 
-    start_options = {}
-    start_options[:use_ssl] = ssl
-    start_options[:verify_mode] = ssl_verify_mode if ssl and ssl_verify_mode
-    http = Net::HTTP.start hturi.host, hturi.port, **start_options
+    # Can the server speak our protocol version?
+    unless (response['Sec-WebSocket-Version'] || '13').
+        strip.split(/\s*,\s*/).include? '13' then
+      raise Webtube::WebSocketVersionMismatch.new(
+          "Sec-WebSocket-Version negotiation failed")
+    end
 
-    object_to_request = hturi.path
-    if object_to_request.empty? then
-      object_to_request = '/'
+    # The connection has been set up.  Now we can instantiate
+    # [[Webtube]].
+    wt = Webtube.new socket, false,
+        allow_rsv_bits: allow_rsv_bits,
+        allow_opcodes: allow_opcodes,
+        close_socket: close_socket
+    wt.instance_variable_set :@url, loc.to_s
+    return wt
+  end
+
+  # Checks whether the given [[Net::HTTPResponse]] represents a
+  # valid WebSocket upgrade acceptance.  Returns [[nil]] if so,
+  # or a human-readable string explaining the issue if not.
+  # [[expected_accept]] is the value [[Sec-WebSocket-Accept]] is
+  # expected to hold, generated from the [[Sec-WebSocket-Key]]
+  # header field.
+  def self::rejection response, expected_accept
+    unless response.code == '101' then
+      return "the HTTP response code was not 101"
     end
-    if hturi.query then
-      object_to_request += '?' + hturi.query
+    unless (response['Connection'] || '').downcase ==
+        'upgrade' then
+      return "the HTTP response did not say " +
+          "'Connection: upgrade'"
     end
-    response = http.get object_to_request, reqhdr
-    on_http_response.call response if on_http_response
+    unless (response['Upgrade'] || '').downcase ==
+        'websocket' then
+      return "the HTTP response did not say " +
+          "'Upgrade: websocket'"
+    end
+    unless (response['Sec-WebSocket-Accept'] || '') ==
+        expected_accept then
+      return "the HTTP response did not say " +
+          "'Sec-WebSocket-Accept: #{expected_accept}'"
+    end
+    return nil
+  end
 
-    # Check that the server is seeing us now
-    unless response.code == '101' then
-      raise Webtube::WebSocketDeclined.new("the HTTP response code was not 101")
+  # Represents a parsed WebSocket URL.
+  class Location
+    def initialize url
+      super()
+      # force into a single-byte encoding so urlencoding can
+      # work correctly
+      url = url.dup.force_encoding Encoding::ASCII_8BIT
+      # ensure that any whitespace, ASCII on-printables, and
+      # some popular text delimiters (parens, brokets, brackets,
+      # and broken bar) in [[url]] are properly urlencoded
+      url.gsub! ' ', '+'
+      url.gsub!(/[^\x21-\x7E]/){'%%%02X' % $&.ord}
+      url.gsub!(/[()<>\[\]\|]/){'%%%02X' % $&.ord}
+      # We'll replace the WebSocket protocol prefix with an
+      # HTTP-based one so [[URI::parse]] would know how to
+      # parse the rest of the URL.
+      case url
+        when /\A(ws|http):/ then
+          http_url = 'http:' + $'
+          @ssl = false
+          @default_port = 80
+        when /\A(wss|https):/ then
+          http_url = 'https:' + $'
+          @ssl = true
+          @default_port = 443
+        else
+          raise "unknown URI scheme; use ws: or wss: instead"
+      end
+      http_uri = URI.parse http_url
+      @host = http_uri.host
+      @port = http_uri.port
+      @requestee = http_uri.path
+      if @requestee.empty? then
+        @requestee = '/'
+      end
+      @requestee += '?' + http_uri.query \
+          if http_uri.query
+      return
     end
-    unless (response['Connection'] || '').downcase == 'upgrade' then
-      raise Webtube::WebSocketDeclined.new("the HTTP response did not say " +
-          "'Connection: upgrade'")
+
+    def to_s
+      s = !ssl? ? 'ws:' : 'wss:'
+      s += '//' + host_and_maybe_port
+      s += @requestee \
+          unless @requestee == '/'
+      return s
     end
-    unless (response['Upgrade'] || '').downcase == 'websocket' then
-      raise Webtube::WebSocketDeclined.new("the HTTP response did not say " +
-          "'Upgrade: websocket'")
+
+    def ssl?
+      return @ssl
     end
-    expected_accept = Digest::SHA1.base64digest(
-        reqhdr['sec-websocket-key'] +
-        '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
-    unless (response['Sec-WebSocket-Accept'] || '') == expected_accept then
-      raise Webtube::WebSocketDeclined.new("the HTTP response did not say " +
-          "'Sec-WebSocket-Accept: #{expected_accept}'")
+
+    attr_reader :default_port
+    attr_reader :host
+    attr_reader :port
+    attr_reader :requestee
+
+    # Returns the hostname and, if non-default, the port number
+    # separated by colon.  This combination is used in HTTP 1.1
+    # [[Host]] header fields but also in URIs.
+    def host_and_maybe_port
+      h = @host
+      h += ":#@port" \
+          unless @port == @default_port
+      return h
     end
-    unless (response['Sec-WebSocket-Version'] || '13').
-        split(/\s*,\s*/).include? '13' then
-      raise Webtube::WebSocketVersionMismatch.new(
-          "Sec-WebSocket-Version negotiation failed")
+  end
+
+  # Represents an HTTP request (well, request header, since a
+  # WebSocket open request shouldn't have a body) being prepared
+  # to open a WebSocket connection.
+  class Request
+    attr_reader :location
+
+    def initialize location, custom_fields = {}
+      super()
+      @location = location
+      @fields = {} # capitalised-name => value
+      # Since Ruby hashes are case-sensitive but HTTP header
+      # field names are case-insensitive, we may have to combine
+      # fields whose names only differ in case.
+      custom_fields.each_pair do |name, value|
+        name = name.capitalize
+        if @fields.has_key? name then
+          @fields[name] += ', ' + value
+        else
+          @fields[name] = value
+        end
+      end
+
+      # Add in the WebSocket header fields but give precedence
+      # to user-specified values
+      @fields['Host'] ||= @location.host_and_maybe_port
+      @fields['Upgrade'] ||= 'websocket'
+      @fields['Connection'] ||= 'upgrade'
+      @fields['Sec-websocket-key'] ||=
+          SecureRandom.base64(16)
+      @fields['Sec-websocket-version'] ||= '13'
+
+      return
     end
 
-    # The connection has been set up.  Now let's set up the Webtube.
-    socket = http.instance_eval{@socket}
-    socket.read_timeout = nil # turn off timeout
-    return Webtube.new socket, false,
-        allow_rsv_bits: allow_rsv_bits,
-        allow_opcodes: allow_opcodes,
-        close_socket: close_socket
+    def [] name
+      return @fields[name.capitalize]
+    end
+
+    def []= name, value
+      name = name.capitalize
+      unless value.nil? then
+        @fields[name] = value
+      else
+        @fields.delete name
+      end
+      return value
+    end
+
+    def each_pair &thunk
+      @fields.each_pair &thunk
+      return self
+    end
+
+    # Constructs an HTTP request header in string form, together
+    # with CRLF line terminators and the terminal blank line,
+    # ready to be transmitted to the server.
+    def to_s
+      s = ''
+      s << "GET #{@location.requestee} HTTP/1.1\r\n"
+      each_pair do |k, v|
+        s << "#{k}: #{v}\r\n"
+      end
+      s << "\r\n"
+      return s
+    end
+
+    def expected_accept
+      return OpenSSL::Digest::SHA1.base64digest(
+          self['Sec-WebSocket-Key'] +
+          '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+    end
   end
 
-  # The application may want to store many Webtube instances in a hash or a
-  # set.  In order to facilitate this, we'll need [[hash]] and [[eql?]].  The
-  # latter is already adequately -- comparing by identity -- implemented by
-  # [[Object]]; in order to ensure the former hashes by identity, we'll
-  # override it.
+  # The application may want to store many Webtube instances in
+  # a hash or a set.  In order to facilitate this, we'll need
+  # [[hash]] and [[eql?]].  The latter is already adequately --
+  # comparing by identity -- implemented by [[Object]]; in order
+  # to ensure the former hashes by identity, we'll override it.
   def hash
     return object_id
   end
 
-  # A technical exception, raised by [[Webtube#close]] if [[Webtube#run]] is
-  # currently waiting for a frame.
+  # A technical exception, raised by [[Webtube#close]] if
+  # [[Webtube#run]] is currently waiting for a frame.
   class AbortReceiveLoop < Exception
   end
 
-  # Note that [[body]] holds the /raw/ data; that is, if [[masked?]] is true,
-  # it will need to be unmasked to get the payload.  Call [[payload]] in order
-  # to abstract this away.
+  # Note that [[body]] holds the /raw/ data; that is, if
+  # [[masked?]] is true, it will need to be unmasked to get
+  # the payload.  Call [[payload]] in order to abstract this
+  # away.
   Frame = Struct.new(:header, :body)
   class Frame
     def fin?
@@ -413,7 +645,8 @@ class Webtube
     end
 
     def fin= new_value
-      header.setbyte 0, header.getbyte(0) & 0x7F | (new_value ? 0x80 : 0x00)
+      header.setbyte 0, header.getbyte(0) & 0x7F |
+          (new_value ? 0x80 : 0x00)
       return new_value
     end
 
@@ -429,8 +662,8 @@ class Webtube
       return (header.getbyte(0) & 0x10) != 0
     end
 
-    # The three reserved bits of the frame, shifted rightwards to meet the
-    # binary point
+    # The three reserved bits of the frame, shifted rightwards
+    # to meet the binary point
     def rsv
       return (header.getbyte(0) & 0x70) >> 4
     end
@@ -440,7 +673,8 @@ class Webtube
     end
 
     def opcode= new_opcode
-      header.setbyte 0, (header.getbyte(0) & ~0x0F) | (new_opcode & 0x0F)
+      header.setbyte 0, (header.getbyte(0) & ~0x0F) |
+          (new_opcode & 0x0F)
       return new_opcode
     end
 
@@ -452,8 +686,8 @@ class Webtube
       return (header.getbyte(1) & 0x80) != 0
     end
 
-    # Determine the size of this frame's extended payload length field in bytes
-    # from the 7-bit short payload length field.
+    # Determine the size of this frame's extended payload length
+    # field in bytes from the 7-bit short payload length field.
     def extended_payload_length_field_size
       return case header.getbyte(1) & 0x7F
         when 126 then 2
@@ -462,18 +696,20 @@ class Webtube
       end
     end
 
-    # Extract the length of this frame's payload.  Enough bytes of the header
-    # must already have been read; see [[extended_payload_lenth_field_size]].
+    # Extract the length of this frame's payload.  Enough bytes
+    # of the header must already have been read; see
+    # [[extended_payload_lenth_field_size]].
     def payload_length
       return case base = header.getbyte(1) & 0x7F
-        when 126 then header.unpack('@2 n').first
-        when 127 then header.unpack('@2 @>').first
+        when 126 then header.unpack('@2 S>')[0]
+        when 127 then header.unpack('@2 Q>')[0]
         else base
       end
     end
 
-    # Extract the mask as a 4-byte [[ASCII-8BIT]] string from this frame.  If
-    # the frame has the [[masked?]] bit unset, return [[nil]] instead.
+    # Extracts the mask as a tetrabyte integer from this frame.
+    # If the frame has the [[masked?]] bit unset, returns
+    # [[nil]] instead.
     def mask
       if masked? then
         mask_offset = 2 + case header.getbyte(1) & 0x7F
@@ -481,66 +717,69 @@ class Webtube
           when 127 then 8
           else 0
         end
-        return header[mask_offset, 4]
+        return header.unpack('@%i L>' % mask_offset)[0]
       else
         return nil
       end
     end
 
-    # Extract the frame's payload and return it as a [[String]] instance of the
-    # [[ASCII-8BIT]] encoding.  If the frame has the [[masked?]] bit set, this
-    # also involves demasking.
+    # Extract the frame's payload and return it as a [[String]]
+    # instance of the [[ASCII-8BIT]] encoding.  If the frame has
+    # the [[masked?]] bit set, this also involves demasking.
     def payload
       return Frame.apply_mask(body, mask)
     end
 
-    # Apply the given [[mask]], specified as a four-byte (!) [[String]], to the
-    # given [[data]].  Note that since the underlying operation is [[XOR]], the
-    # operation can be repeated to reverse itself.
-    #
-    # [[nil]] can be supplied instead of [[mask]] to indicate that no
-    # processing is needed.
+    # Apply the given [[mask]], specified as an integer, to the
+    # given [[data]].  Note that since the underlying operation
+    # is [[XOR]], the operation can be repeated to reverse
+    # itself.
     #
+    # [[nil]] can be supplied instead of [[mask]] to indicate
+    # that no processing is needed.
     def self::apply_mask data, mask
       return data if mask.nil?
-      raise 'invalid mask' unless mask.bytesize == 4
-      result = data.dup
-      (0 ... result.bytesize).each do |i|
-        result.setbyte i, result.getbyte(i) ^ mask.getbyte(i & 3)
-      end
-      return result
+      return (data + "\0\0\0").        # pad to full tetras
+          unpack('L>*').               # extract tetras
+          map!{|i| i ^ mask}.          # XOR each with the mask
+          pack('L>*').                 # pack back into a string
+          byteslice(0, data.bytesize)  # remove padding
     end
 
-    # Read all the bytes of one WebSocket frame from the given [[socket]] and
-    # return them in a [[Frame]] instance.  In case traffic ends before the
-    # frame is complete, raise [[BrokenFrame]].
+    # Read all the bytes of one WebSocket frame from the given
+    # [[socket]] and return them in a [[Frame]] instance.  In
+    # case traffic ends before the frame is complete, raise
+    # [[BrokenFrame]].
     #
-    # Note that this will call [[socket.read]] twice or thrice, and assumes no
-    # other thread will consume bytes from the socket inbetween.  In a
-    # multithreaded environment, it may be necessary to apply external
-    # locking.
+    # Note that this will call [[socket.read]] twice or thrice,
+    # and assumes no other thread will consume bytes from the
+    # socket inbetween.  In a multithreaded environment, it may
+    # be necessary to apply external locking.
     #
     def self::read_from_socket socket
       header = socket.read(2)
       unless header and header.bytesize == 2 then
-        header ||= String.new.force_encoding('ASCII-8BIT')
+        header ||= String.new encoding: Encoding::ASCII_8BIT
         raise BrokenFrame.new(header)
       end
       frame = Frame.new header
 
-      header_tail_size = frame.extended_payload_length_field_size +
-          (frame.masked? ? 4 : 0)
+      header_tail_size =
+          frame.extended_payload_length_field_size +
+              (frame.masked? ? 4 : 0)
       unless header_tail_size.zero? then
         header_tail = socket.read(header_tail_size)
         frame.header << header_tail if header_tail
-        unless header_tail and header_tail.bytesize == header_tail_size then
+        unless header_tail and
+            header_tail.bytesize == header_tail_size then
           raise BrokenFrame.new(frame.header)
         end
       end
 
       data_size = frame.payload_length
       frame.body = socket.read(data_size)
-      unless frame.body and frame.body.bytesize == data_size then
+      unless frame.body and
+          frame.body.bytesize == data_size then
         raise BrokenFrame.new(frame.body ?
             frame.header + frame.body :
             frame.header)
@@ -549,29 +788,30 @@ class Webtube
       return frame
     end
 
-    # Given a frame's payload, prepare the header and return a [[Frame]]
-    # instance representing such a frame.  Optionally, some header fields can
-    # also be set.
+    # Given a frame's payload, prepare the header and return a
+    # [[Frame]] instance representing such a frame.  Optionally,
+    # some header fields can also be set.
     #
-    # It's OK for the caller to modify some header fields, such as [[fin]] or
-    # [[opcode]], on the returned [[Frame]] by calling the appropriate methods.
-    # Its body should not be modified after construction, however, because its
-    # length and possibly its mask is already encoded in the header.
+    # It's OK for the caller to modify some header fields, such
+    # as [[fin]] or [[opcode]], on the returned [[Frame]] by
+    # calling the appropriate methods.  Its body should not be
+    # modified after construction, however, because its length
+    # and possibly its mask is already encoded in the header.
     def self::prepare(
         payload: '',
         opcode: OPCODE_TEXT,
         fin: true,
         masked: false)
-      header = [0].pack 'C' # we'll fill out the first byte later
+      header = [0].pack 'C' # we'll fill in the first byte later
       mask_flag = masked ? 0x80 : 0x00
       header << if payload.bytesize <= 125 then
         [mask_flag | payload.bytesize].pack 'C'
       elsif payload.bytesize <= 0xFFFF then
-        [mask_flag | 126, payload.bytesize].pack 'C n'
+        [mask_flag | 126, payload.bytesize].pack 'C S>'
       elsif payload.bytesize <= 0x7FFF_FFFF_FFFF_FFFF then
         [mask_flag | 127, payload.bytesize].pack 'C Q>'
       else
-        raise 'attempted to prepare a WebSocket frame with too big payload'
+        raise 'payload too big for a WebSocket frame'
       end
       frame = Frame.new(header)
       unless masked then
@@ -579,7 +819,7 @@ class Webtube
       else
         mask = SecureRandom.random_bytes(4)
         frame.header << mask
-        frame.body = apply_mask(payload, mask)
+        frame.body = apply_mask(payload, mask.unpack('L>')[0])
       end
 
       # now, it's time to fill out the first byte
@@ -589,11 +829,12 @@ class Webtube
       return frame
     end
 
-    # Given a message and attributes, break it up into frames, and yields each
-    # such [[Frame]] separately for processing by the caller -- usually,
-    # delivery to the other end via the socket.  Takes care to not fragment
-    # control messages.  If masking is required, uses
-    # [[SecureRandom.random_bytes]] to generate masks for each frame.
+    # Given a message and attributes, break it up into frames,
+    # and yields each such [[Frame]] separately for processing
+    # by the caller -- usually, delivery to the other end via
+    # the socket.  Takes care to not fragment control messages.
+    # If masking is required, uses [[SecureRandom]] to generate
+    # masks for each frame.
     def self::each_frame_for_message message: '',
         opcode: OPCODE_TEXT,
         masked: false,
@@ -621,7 +862,7 @@ class Webtube
 
   class ConnectionNotAlive < RuntimeError
     def initialize
-      super "WebSocket connection is no longer alive and can not transmit " +
+      super "WebSocket connection has died and can't convey " +
           "any more messages"
       return
     end
@@ -633,14 +874,16 @@ class Webtube
     end
   end
 
-  # Indicates that a complete frame could not be read from the underlying TCP
-  # connection.  [[Webtube::Frame::read_from_socket]] will also give it the
-  # partial frame as a string so it could be further analysed, but this is
-  # optional.
+  # Indicates that a complete frame could not be read from the
+  # underlying TCP connection.
+  # [[Webtube::Frame::read_from_socket]] will also give it the
+  # partial frame as a string so it could be further analysed,
+  # but this is optional.
   class BrokenFrame < ProtocolError
     attr_reader :partial_frame
 
-    def initialize message = "no complete WebSocket frame was available",
+    def initialize message =
+            "no complete WebSocket frame was available",
         partial_frame = nil
       super message
       @partial_frame = partial_frame
@@ -651,7 +894,8 @@ class Webtube
   class UnknownReservedBit < ProtocolError
     attr_reader :frame
 
-    def initialize message = "frame with unknown RSV bit arrived",
+    def initialize message =
+            "frame with unknown RSV bit arrived",
         frame: nil
       super message
       @frame = frame
@@ -666,7 +910,8 @@ class Webtube
   class UnknownOpcode < ProtocolError
     attr_reader :frame
 
-    def initialize message = "frame with unknown opcode arrived",
+    def initialize message =
+            "frame with unknown opcode arrived",
         frame: nil
       super message
       @frame = frame
@@ -681,7 +926,8 @@ class Webtube
   class UnmaskedFrameToServer < ProtocolError
     attr_reader :frame
 
-    def initialize message = "unmasked frame arrived but we're the server",
+    def initialize message =
+            "unmasked frame arrived but we're the server",
         frame: nil
       super message
       @frame = frame
@@ -692,7 +938,8 @@ class Webtube
   class MaskedFrameToClient < ProtocolError
     attr_reader :frame
 
-    def initialize message = "masked frame arrived but we're the client",
+    def initialize message =
+            "masked frame arrived but we're the client",
         frame: nil
       super message
       @frame = frame
@@ -701,7 +948,8 @@ class Webtube
   end
 
   class MissingContinuationFrame < ProtocolError
-    def initialize message = "a new initial data frame arrived while only " +
+    def initialize message =
+        "a new initial data frame arrived while only " +
         "parts of a previous fragmented message had arrived"
       super message
       return
@@ -711,8 +959,9 @@ class Webtube
   class UnexpectedContinuationFrame < ProtocolError
     attr_reader :frame
 
-    def initialize message = "a continuation frame arrived but there was no " +
-        "fragmented message pending",
+    def initialize message =
+            "a continuation frame arrived but there was no " +
+            "fragmented message pending",
         frame: nil
       super message
       @frame = frame
@@ -723,8 +972,9 @@ class Webtube
   class BadlyEncodedText < ProtocolError
     attr_reader :data
 
-    def initialize message = "invalid UTF-8 in a text-type message",
-        data: data
+    def initialize message =
+            "UTF-8 encoding error in a text-type message",
+        data: nil
       super message
       @data = data
       return
@@ -738,7 +988,8 @@ class Webtube
   class FragmentedControlFrame < ProtocolError
     attr_reader :frame
 
-    def initialize message = "a control frame arrived without its FIN flag set",
+    def initialize message =
+            "a control frame arrived without its FIN flag set",
         frame: nil
       super message
       @frame = frame
@@ -754,4 +1005,6 @@ class Webtube
 
   class WebSocketVersionMismatch < WebSocketUpgradeFailed
   end
+
+  VERSION = '1.1.0'
 end