telnet_q 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in telnet_q.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,43 @@
+== telnet_q - The Q Method of Implementing TELNET Option Negotiation (RFC 1143)
+
+    gem install telnet_q
+
+telnet_q provides a RFC 1143-compliant state machine for performing TELNET option negotiation.
+
+---
+
+===Contributors
+
+* Dwayne Litzenberger - dlitz@patientway.com
+
+---
+
+===Issues?
+
+Lighthouse: https://github.com/dlitz/telnet_q/issues
+
+---
+
+===License
+
+(The MIT License)
+
+Copyright © 2011 Infonium Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the ‘Software’), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs = %w( lib test )
+end

data/lib/telnet_q.rb

@@ -0,0 +1,4 @@
+require 'telnet_q/version'
+require 'telnet_q/base'
+require 'telnet_q/sm'
+require 'telnet_q/socket_q'

data/lib/telnet_q/base.rb

@@ -0,0 +1,186 @@
+require 'set'
+
+module TelnetQ
+  # This class implements RFC 1143 - The Q Method of implementing TELNET option negotiation.
+  #
+  # There are two sides to the conversation: "us" and "him".  "us" refers to
+  # the local party; "him" refers to the remote party. (This is the terminology
+  # used in the RFC.)
+  #
+  # Telnet options are integers between 0 and 255.  The current list of options
+  # is available at: http://www.iana.org/assignments/telnet-options
+  #
+  # Options:
+  #
+  # [:us]
+  #   The list of options the local party should initially enable.  When the
+  #   connection is established, the local party sends a WILL request for each
+  #   of these options.  Note that if the remote party sends DONT in response
+  #   to our request, the option will remain disabled.
+  # [:him]
+  #   The list of options we want the remote party should initially enable.
+  #   When the connection is established, the local party sends a DO request
+  #   for each of these options.  Note that if the remote party sends WONT
+  #   in response to our request, the option will remain disabled.
+  #
+  # Example usage:
+  #
+  #   TelnetQ::Base.new(:us => [0,3], :him => [0,1,3])
+  #
+  class Base
+    def initialize(options={})
+      @state_machines = {
+        :us => {},
+        :him => {},
+      }
+      @supported_options = {
+        :us => Set.new(options[:us] || []),
+        :him => Set.new(options[:him].uniq || []),
+      }
+    end
+
+    def start
+      initial_requests
+    end
+
+    def inspect
+      us = @state_machines[:us].keys.sort.map{|opt| "#{opt}:#{@state_machines[:us][opt].state}"}.join(" ")
+      him = @state_machines[:him].keys.sort.map{|opt| "#{opt}:#{@state_machines[:him][opt].state}"}.join(" ")
+      "#<#{self.class.name} us(#{us}) him(#{him})>"
+    end
+
+    # Invoke this when a TELNET negotiation message is received.
+    #
+    # Example usage:
+    #   tq = TelnetQ::Base.new(...)
+    #   tq.received_message(:do, 0)       # Remote party requesting that we enable binary transmission on our side
+    #   tq.received_message(:will, 0)     # Remote party requesting that to enable binary transmission on his side.
+    def received_message(verb, option)
+      case verb
+      when :do, :dont
+        party = :us
+      when :will, :wont
+        party = :him
+      else
+        raise ArgumentError.new("invalid verb #{verb.inspect}")
+      end
+      sm = state_machine(party, option)
+      sm.received(verb)
+      nil
+    end
+
+    # Check whether the option is currently enabled
+    def enabled?(party, option)
+      sm = state_machine(party, option)
+      sm.state == :yes
+    end
+
+    # Ask the specified party enable this option.
+    #
+    # party may be one of :us or :them.
+    def request(party, option)
+      sm = state_machine(party, option)
+      @supported_options[party] << option
+      sm.ask_enable unless sm.state == :yes
+      nil
+    end
+
+    # Ask the specified party to disable this option.
+    #
+    # party may be one of :us or :them.
+    def forbid(party, option)
+      sm = state_machine(party, option)
+      @supported_options[party].delete(option)
+      sm.ask_disable unless sm.state == :no
+      nil
+    end
+
+    protected
+
+    # Callback invoked when the remote party requests that a currently-disabled
+    # option be enabled.
+    #
+    # The "party" parameter is as follows:
+    # [:us]
+    #   Received a request for the local party to enable the option. (Remote sent DO).
+    # [:him]
+    #   Received a request for the remote party enable the option. (Remote sent WILL).
+    #
+    # Return true if we allow the change, or false if we forbid it.
+    #
+    # You may override this in your subclass.
+    def option_supported?(party, option)
+      @supported_options[party].include?(option)
+    end
+
+    # Callback invoked when the specified option has been negotiated.
+    #
+    # Override this in your subclass.
+    def option_negotiated(party, option, enabled)
+      #puts "#{party == :us ? "We" : "He"} #{enabled ? "enabled" : "disabled"} option #{option}"
+      nil
+    end
+
+    # Callback: Send the specified message to the remote party.
+    #
+    # Override this in your subclass.
+    def send_message(verb, option)
+      #puts "SEND #{verb.to_s.upcase} #{option.inspect}"
+      nil
+    end
+
+    # Callback: Invoked when there is an error negotiating the specified option.
+    #
+    # Override this in your subclass.
+    def error(msg, party, option)
+      $stderr.puts "Error negotiating option #{party}#{option}: #{msg}"
+      nil
+    end
+
+    private
+
+    def state_machine(party, option)
+      party = parse_party(party)
+      option = parse_option(option)
+
+      unless @state_machines[party][option]
+        case party
+        when :him
+          sm = SM::HisOptionState.new(:supported_proc => lambda{ option_supported?(:him, option) },
+                                      :send_proc => lambda{ |verb| send_message(verb, option) },
+                                      :negotiated_proc => lambda{ |enabled| option_negotiated(:him, option, enabled) },
+                                      :error_proc => lambda{ |msg| error(msg, :him, option) })
+          @state_machines[party][option] = sm
+        when :us
+          sm = SM::MyOptionState.new(:supported_proc => lambda{ option_supported?(:us, option) },
+                                     :send_proc => lambda{ |verb| send_message(verb, option) },
+                                     :negotiated_proc => lambda{ |enabled| option_negotiated(:us, option, enabled) },
+                                     :error_proc => lambda{ |msg| error(msg, :us, option) })
+          @state_machines[party][option] = sm
+        else
+          raise "BUG"
+        end
+      end
+      @state_machines[party][option]
+    end
+
+    def parse_option(option)
+      raise TypeError.new("option must be an integer") unless option.is_a?(Integer)
+      option
+    end
+
+    def parse_party(party)
+      raise ArgumentError.new("party must be :us or :him") unless [:us, :him].include?(party)
+      party
+    end
+
+    def initial_requests
+      # Set the initial options
+      [:us, :him].each do |party|
+        @supported_options[party].each do |option|
+          request(party, option)
+        end
+      end
+    end
+  end
+end

data/lib/telnet_q/sm.rb

@@ -0,0 +1,167 @@
+module TelnetQ
+  module SM
+    # Implements the state machine described in Section 7 of RFC 1143.
+    #
+    # NOTE: This code is awful, so consider this entire API private and subject
+    # to change!
+    class HisOptionState
+
+      def initialize(options={}, &block)
+        @state = :no
+        @supported_proc = options[:supported_proc]
+        @send_proc = options[:send_proc]
+        @error_proc = options[:error_proc]
+        @negotiated_proc = options[:negotiated_proc]
+      end
+
+      # Is he allowed to enable this option?
+      def supported?
+        !!@supported_proc.call
+      end
+
+      attr_reader :state
+
+      def state=(v)
+        raise ArgumentError.new unless [:no, :yes, :wantno, :wantyes, :wantno_opposite, :wantyes_opposite].include?(v)
+        old_state = @state
+        @state = v
+        if v != old_state
+          if v == :yes
+            negotiated(true)
+          elsif v == :no
+            negotiated(false)
+          end
+        end
+        v
+      end
+
+      alias him state
+      alias him= state
+
+      def received(which)
+        raise ArgumentError.new("invalid which=#{which.inspect}") unless [:will, :wont, :do, :dont].include?(which)
+        send("received_#{which}")
+      end
+
+      # Received WILL for this option
+      def received_will
+        case state
+        when :no
+          if supported?
+            self.state = :yes
+            send_do
+          else
+            send_dont
+          end
+        when :yes
+          # Ignore; already enabled
+        when :wantno
+          error("DONT answered by WILL.")
+          self.state = :no
+        when :wantno_opposite
+          error("DONT answered by WILL.")
+          self.state = :yes
+        when :wantyes
+          self.state = :yes
+        when :wantyes_opposite
+          self.state = :wantno
+          send_dont
+        else
+          raise "BUG: Illegal state #{state.inspect}"
+        end
+      end
+
+      def received_wont
+        case state
+        when :no
+          # Ignore; already disabled
+        when :yes
+          self.state = :no
+          send_dont
+        when :wantno
+          self.state = :no
+        when :wantno_opposite
+          self.state = :wantyes
+          send_do
+        when :wantyes
+          self.state = :no
+        when :wantyes_opposite
+          self.state = :no
+        else
+          raise "BUG: Illegal state #{state.inspect}"
+        end
+      end
+
+      # If we decide to ask him to enable
+      def ask_enable
+        case state
+        when :no
+          self.state = :wantyes
+          send_do
+        when :yes
+          error("Already enabled.")
+        when :wantno
+          self.state = :wantno_opposite
+        when :wantno_opposite
+          error("Already queued an enable request.")
+        when :wantyes
+          error("Already negotiating for enable.")
+        when :wantyes_opposite
+          self.state = :wantyes
+        else
+          raise "BUG: Illegal state #{state.inspect}"
+        end
+      end
+
+      def ask_disable
+        case state
+        when :no
+          error("Already disabled.")
+        when :yes
+          self.state = :wantno
+          send_dont
+        when :wantno
+          error("Already negotiating for disable.")
+        when :wantno_opposite
+          self.state = :wantno
+        when :wantyes
+          self.state = :wantyes_opposite
+        when :wantyes_opposite
+          error("Already queued a disable request.")
+        else
+          raise "BUG: Illegal state #{state.inspect}"
+        end
+      end
+
+      def send_do; send_option(:do); end
+      def send_dont; send_option(:dont); end
+
+      def send_option(cmd)
+        raise ArgumentError.new("invalid send-option #{cmd.inspect}") unless [:will, :wont, :do, :dont].include?(cmd)
+        @send_proc.call(cmd)
+      end
+
+      def error(msg)
+        @error_proc.call(msg)
+      end
+
+      def negotiated(enabled)
+        @negotiated_proc.call(enabled)
+      end
+    end
+
+    # Same, but for negotiating our options
+    class MyOptionState < HisOptionState
+      def send_will; send_option(:will); end
+      def send_wont; send_option(:wont); end
+      alias send_do send_will
+      alias send_dont send_wont
+
+      alias received_do received_will
+      alias received_dont received_wont
+
+      alias us state
+      alias us= state=
+    end
+  end
+end

data/lib/telnet_q/socket_q.rb

@@ -0,0 +1,57 @@
+require 'telnet_q/base'
+
+module TelnetQ
+  class SocketQ < Base
+
+    VERB_NAMES = {
+      251 => :will,
+      252 => :wont,
+      253 => :do,
+      254 => :dont,
+    }.freeze
+
+    VERB_NUMS = VERB_NAMES.invert.freeze
+
+    def initialize(connection, options={})
+      @connection = connection
+      super(options)
+    end
+
+    # Invoke this when a TELNET negotiation message is received.
+    #
+    # Example usage:
+    #   sq = TelnetQ::SocketQ.new(connection, ...)
+    #   sq.received_raw_message("\377\375\000")       # Remote party requesting that we enable binary transmission on our side
+    #   sq.received_raw_message("\377\373\000")     # Remote party requesting that to enable binary transmission on his side.
+    def received_raw_message(raw)
+      verb, option = parse_raw_telnet_option_message(raw)
+      received_message(verb, option)
+    end
+
+    protected
+
+      def send_message(verb, option)
+        send_raw_message(generate_raw_telnet_option_message(verb, option))
+      end
+
+      def send_raw_message(raw)
+        @connection.write(raw)
+      end
+
+      # Translate e.g. "\377\375\000" -> [:do, 0]
+      def parse_raw_telnet_option_message(raw)
+        iac, v, option = raw.unpack("CCC")
+        verb = VERB_NAMES[v]
+        raise ArgumentError.new("illegal option") unless raw.length == 3 and iac == 255 and verb
+        [verb, option]
+      end
+
+      # Translate e.g. [:do, 0] -> "\377\375\000"
+      def generate_raw_telnet_option_message(verb, option)
+        vn = VERB_NUMS[verb]
+        raise ArgumentError.new("unsupported verb: #{verb.inspect}") unless vn
+        raise ArgumentError.new("illegal option: #{option.inspect}") unless option.is_a?(Integer) and (0..255).include?(option)
+        [255, vn, option].pack("CCC")
+      end
+  end
+end

data/lib/telnet_q/version.rb

@@ -0,0 +1,3 @@
+module TelnetQ
+  VERSION = '0.1'
+end

data/telnet_q.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "telnet_q/version"
+
+Gem::Specification.new do |s|
+  s.name        = "telnet_q"
+  s.version     = TelnetQ::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dwayne Litzenberger"]
+  s.email       = ["dlitz@patientway.com"]
+  s.homepage    = ""
+  s.summary =   %q{The Q Method of Implementing TELNET Option Negotiation (RFC 1143)}
+  s.description = %q{telnet_q implements D. J. Bernstein's "Q Method" of implementing TELNET option negotiation, as described in RFC 1143.}
+
+  s.rubyforge_project = "telnet_q"
+
+  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"]
+end

data/test/base_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+class BaseTest < Test::Unit::TestCase
+  class TQBase < TelnetQ::Base
+    def initialize(test_events, *args)
+      @test_events = test_events
+      super(*args)
+    end
+
+    attr_accessor :other
+    attr_accessor :name
+
+    def received_message(verb, option)
+      @test_events << "#{name}: Received #{verb.to_s.upcase} #{option.inspect}"
+      super
+    end
+
+    def send_message(verb, option)
+      @test_events << "#{name}: Sent #{verb.to_s.upcase} #{option.inspect}"
+      @other.received_message(verb, option)
+    end
+
+    # Always allow option 3 (for both parties)
+    def option_supported?(party, option)
+      (option == 3) or super
+    end
+
+    def option_negotiated(party, option, enabled)
+      @test_events << "#{name}: #{party == :us ? "We" : "They"} #{enabled ? "enabled" : "disabled"} option #{option}"
+    end
+  end
+
+  def test_option_not_supported_him
+    events = []
+
+    alice = TQBase.new(events, :us => [], :him => [0])
+    bob = TQBase.new(events, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+    alice.other = bob
+    bob.other = alice
+
+    alice.start
+    bob.start
+
+    assert_equal [
+     "alice: Sent DO 0",
+     "bob: Received DO 0",
+     "bob: Sent WONT 0",
+     "alice: Received WONT 0",
+     "alice: They disabled option 0",
+    ], events
+  end
+
+  def test_option_not_supported_us
+    events = []
+
+    alice = TQBase.new(events, :us => [0], :him => [])
+    bob = TQBase.new(events, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+    alice.other = bob
+    bob.other = alice
+
+    alice.start
+    bob.start
+
+    assert_equal [
+     "alice: Sent WILL 0",
+     "bob: Received WILL 0",
+     "bob: Sent DONT 0",
+     "alice: Received DONT 0",
+     "alice: We disabled option 0",
+    ], events
+  end
+
+  def test_option_supported_him
+    events = []
+
+    alice = TQBase.new(events, :us => [], :him => [3])
+    bob = TQBase.new(events, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+    alice.other = bob
+    bob.other = alice
+
+    alice.start
+    bob.start
+
+    assert_equal [
+      "alice: Sent DO 3",
+      "bob: Received DO 3",
+      "bob: We enabled option 3",
+      "bob: Sent WILL 3",
+      "alice: Received WILL 3",
+      "alice: They enabled option 3",
+    ], events
+  end
+
+  def test_option_supported_us
+    events = []
+
+    alice = TQBase.new(events, :us => [3], :him => [])
+    bob = TQBase.new(events, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+    alice.other = bob
+    bob.other = alice
+
+    alice.start
+    bob.start
+
+    assert_equal [
+      "alice: Sent WILL 3",
+      "bob: Received WILL 3",
+      "bob: They enabled option 3",
+      "bob: Sent DO 3",
+      "alice: Received DO 3",
+      "alice: We enabled option 3",
+    ], events
+  end
+end

data/test/socket_test.rb

@@ -0,0 +1,175 @@
+require 'test_helper'
+require 'socket'
+
+class SocketTest < Test::Unit::TestCase
+  class TQSocketQ < TelnetQ::SocketQ
+    def initialize(test_events, *args)
+      @test_events = test_events
+      super(*args)
+    end
+
+    attr_accessor :name
+
+    def received_message(verb, option)
+      @test_events << "#{name}: Received #{verb.to_s.upcase} #{option.inspect}"
+      super
+    end
+
+    def send_message(verb, option)
+      @test_events << "#{name}: Sent #{verb.to_s.upcase} #{option.inspect}"
+      super
+    end
+
+    # Always allow option 3 (for both parties)
+    def option_supported?(party, option)
+      (option == 3) or super
+    end
+
+    def option_negotiated(party, option, enabled)
+      @test_events << "#{name}: #{party == :us ? "We" : "They"} #{enabled ? "enabled" : "disabled"} option #{option}"
+    end
+  end
+
+  def test_option_not_supported_him
+    alice_socket, bob_socket = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+
+    events = []
+
+    alice = TQSocketQ.new(events, alice_socket, :us => [], :him => [0])
+    bob = TQSocketQ.new(events, bob_socket, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+
+    alice.start
+    bob.start
+
+    until events.length >= 5
+      rr, ww, ee = select([alice_socket, bob_socket], nil, nil)
+      if rr.include?(alice_socket)
+        alice.received_raw_message(alice_socket.read(3))
+      end
+      if rr.include?(bob_socket)
+        bob.received_raw_message(bob_socket.read(3))
+      end
+    end
+
+    assert_equal [
+     "alice: Sent DO 0",
+     "bob: Received DO 0",
+     "bob: Sent WONT 0",
+     "alice: Received WONT 0",
+     "alice: They disabled option 0",
+    ], events
+  ensure
+    alice_socket.close if alice_socket
+    bob_socket.close if bob_socket
+  end
+
+  def test_option_not_supported_us
+    alice_socket, bob_socket = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+
+    events = []
+
+    alice = TQSocketQ.new(events, alice_socket, :us => [0], :him => [])
+    bob = TQSocketQ.new(events, bob_socket, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+
+    alice.start
+    bob.start
+
+    until events.length >= 5
+      rr, ww, ee = select([alice_socket, bob_socket], nil, nil)
+      if rr.include?(alice_socket)
+        alice.received_raw_message(alice_socket.read(3))
+      end
+      if rr.include?(bob_socket)
+        bob.received_raw_message(bob_socket.read(3))
+      end
+    end
+
+    assert_equal [
+     "alice: Sent WILL 0",
+     "bob: Received WILL 0",
+     "bob: Sent DONT 0",
+     "alice: Received DONT 0",
+     "alice: We disabled option 0",
+    ], events
+  ensure
+    alice_socket.close if alice_socket
+    bob_socket.close if bob_socket
+  end
+
+  def test_option_supported_him
+    alice_socket, bob_socket = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+
+    events = []
+
+    alice = TQSocketQ.new(events, alice_socket, :us => [], :him => [3])
+    bob = TQSocketQ.new(events, bob_socket, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+
+    alice.start
+    bob.start
+
+    until events.length >= 5
+      rr, ww, ee = select([alice_socket, bob_socket], nil, nil)
+      if rr.include?(alice_socket)
+        alice.received_raw_message(alice_socket.read(3))
+      end
+      if rr.include?(bob_socket)
+        bob.received_raw_message(bob_socket.read(3))
+      end
+    end
+
+    assert_equal [
+      "alice: Sent DO 3",
+      "bob: Received DO 3",
+      "bob: We enabled option 3",
+      "bob: Sent WILL 3",
+      "alice: Received WILL 3",
+      "alice: They enabled option 3",
+    ], events
+  ensure
+    alice_socket.close if alice_socket
+    bob_socket.close if bob_socket
+  end
+
+  def test_option_supported_us
+    alice_socket, bob_socket = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+
+    events = []
+
+    alice = TQSocketQ.new(events, alice_socket, :us => [3], :him => [])
+    bob = TQSocketQ.new(events, bob_socket, :us => [], :him => [])
+    alice.name = "alice"
+    bob.name = "bob"
+
+    alice.start
+    bob.start
+
+    until events.length >= 5
+      rr, ww, ee = select([alice_socket, bob_socket], nil, nil)
+      if rr.include?(alice_socket)
+        alice.received_raw_message(alice_socket.read(3))
+      end
+      if rr.include?(bob_socket)
+        bob.received_raw_message(bob_socket.read(3))
+      end
+    end
+
+    assert_equal [
+      "alice: Sent WILL 3",
+      "bob: Received WILL 3",
+      "bob: They enabled option 3",
+      "bob: Sent DO 3",
+      "alice: Received DO 3",
+      "alice: We enabled option 3",
+    ], events
+  ensure
+    alice_socket.close if alice_socket
+    bob_socket.close if bob_socket
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'telnet_q'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: telnet_q
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+  - Dwayne Litzenberger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-16 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: telnet_q implements D. J. Bernstein's "Q Method" of implementing TELNET option negotiation, as described in RFC 1143.
+email: 
+  - dlitz@patientway.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - Gemfile
+  - README.rdoc
+  - Rakefile
+  - lib/telnet_q.rb
+  - lib/telnet_q/base.rb
+  - lib/telnet_q/sm.rb
+  - lib/telnet_q/socket_q.rb
+  - lib/telnet_q/version.rb
+  - telnet_q.gemspec
+  - test/base_test.rb
+  - test/socket_test.rb
+  - test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: telnet_q
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: The Q Method of Implementing TELNET Option Negotiation (RFC 1143)
+test_files: 
+  - test/base_test.rb
+  - test/socket_test.rb
+  - test/test_helper.rb