net-telnet-rfc2217 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0b5b2b5e014b1fc9906ae0be1e7d33fb5d3971cce0b4eda74332e6a1ee24a9e
+  data.tar.gz: b56a17ffee69e60c4c8f805fd5fb16a0195a95719ed3b93a4fc5417c1dbb0e2f
+SHA512:
+  metadata.gz: 1b4b82e214841d59828c733e9c15a65d2e623ee807f42df97353054564cb6bd7991f6900182ecd35cedebf83876c9388ecdce8574639a86b0e4d237e3e8f0a96
+  data.tar.gz: 35da8ce422ca87cfc75ad2c4461582d9ec54f8335f74bb381fe178d12890bae4f5034e7338488187c07cdfb6a900e2eb89f95909c7cdd536a33581062b0c5861

data/lib/net-telnet-rfc2217.rb

@@ -0,0 +1 @@
+require 'net/telnet/rfc2217'

data/lib/net/telnet/rfc2217.rb

@@ -0,0 +1,219 @@
+require 'net/telnet'
+require 'byebug'
+
+# have to patch Telnet to allow us to read control sequences
+require 'net/telnet/rfc2217/telnet'
+Net::Telnet.prepend(Net::Telnet::RFC2217::TelnetExtensions)
+
+module Net
+  class Telnet
+    class RFC2217
+      class WaitReadable < RuntimeError
+        include ::IO::WaitReadable
+      end
+
+      attr_reader :telnet
+
+      COM_PORT_OPTION = 44.chr
+
+      SET_BAUDRATE = 1.chr
+      SET_DATASIZE = 2.chr
+      SET_PARITY = 3.chr
+      SET_STOPSIZE = 4.chr
+      SET_CONTROL = 5.chr
+      NOTIFY_LINESTATE = 6.chr
+      NOTIFY_MODEMSTATE = 7.chr
+      FLOWCONTROL_SUSPEND = 8.chr
+      SET_LINESTATE_MASK = 10.chr
+      SET_MODEMSTATE_MASK = 11.chr
+      PURGE_DATA = 12.chr
+
+      SET_BAUDRATE_RESPONSE = 101.chr
+      SET_DATASIZE_RESPONSE = 102.chr
+      SET_PARITY_RESPONSE = 103.chr
+      SET_STOPSIZE_RESPONSE = 104.chr
+      SET_CONTROL_RESPONSE = 105.chr
+      NOTIFY_LINESTATE_RESPONSE = 106.chr
+      NOTIFY_MODEMSTATE_RESPONSE = 107.chr
+      FLOWCONTROL_SUSPEND_RESPONSE = 108.chr
+      SET_LINESTATE_MASK_RESPONSE = 110.chr
+      SET_MODEMSTATE_MASK_RESPONSE = 111.chr
+      PURGE_DATA_RESPONSE = 112.chr
+
+      NONE = 1
+      ODD = 2
+      EVEN = 3
+      MARK = 4
+      SPACE = 5
+
+      SERIAL_PORT_PARAMS = %w{baud data_bits stop_bits parity}.freeze
+
+      class << self
+        def open(options)
+          sp = new(options)
+          if block_given?
+            begin
+              yield sp
+            ensure
+              sp.close
+            end
+            nil
+          else
+            nil
+          end
+        end
+      end
+
+      def initialize(options = {}, &block)
+        set_modem_params(options.slice(*SERIAL_PORT_PARAMS))
+
+        options['Binmode'] = true
+        options['Telnetmode'] = false
+        @telnet = Telnet.new(options, &block)
+        telnet.write(IAC + WILL + COM_PORT_OPTION)
+        sock.flush
+        @buffer = ''
+        readpartial(0)
+      end
+
+      def get_modem_params
+        @modem_params
+      end
+
+      def set_modem_params(modem_params)
+        @modem_params = modem_params.dup
+        @modem_params['baud'] = 115200 unless @modem_params.key?('baud')
+        @modem_params['data_bits'] = 8 unless @modem_params.key?('data_bits')
+        @modem_params['stop_bits'] = 1 unless @modem_params.key?('stop_bits')
+        unless @modem_params.key?('parity')
+          @modem_params['parity'] = (data_bits == 8 ? NONE : EVEN)
+        end
+        write_modem_params if telnet
+      end
+
+      def baud
+        get_modem_params['baud']
+      end
+
+      def data_bits
+        get_modem_params['data_bits']
+      end
+
+      def stop_bits
+        get_modem_params['stop_bits']
+      end
+
+      def parity
+        get_modem_params['parity']
+      end
+
+      def sock
+        @telnet.sock
+      end
+
+      def read(length, outbuf = '')
+        readpartial(length, outbuf)
+        while outbuf.length < length
+          outbuf.concat(length - outbuf.length)
+        end
+        outbuf
+      end
+
+      def readpartial(length, outbuf = '')
+        loop do
+          # 0 is special and means 'read at least one control sequence'
+          break if length != 0 || @buffer.length != 0
+
+          data = sock.sysread([length - @buffer.length, 64 * 1024].max)
+
+          # avoid getting caught in the middle of a control sequence
+          while (data[-1] == IAC && sock.wait_readable(0))
+            data.concat(sock.sysread(16))
+          end
+
+          saw_control = false
+          data = @telnet.preprocess(data) do |control|
+            saw_control = true
+            if DO[0] == control[0] && COM_PORT_OPTION == control[1]
+              # start negotiation
+              write_modem_params
+              true
+            elsif DONT[0] == control[0] && COM_PORT_OPTION == control[1]
+              raise "Serial port control not supported"
+            elsif (WILL[0] == control[0] || DONT[0] == control[0]) && OPT_ECHO == control[1]
+              # just ignore echo requests
+              true
+            else
+              false
+            end
+          end
+          @buffer.concat(data)
+          break if length == 0 && saw_control
+        end
+
+        length = [length, @buffer.length].min
+        outbuf.replace(@buffer[0...length])
+        @buffer = @buffer[length..-1]
+        outbuf
+      end
+
+      def read_nonblock(length, outbuf = '', options = {})
+        if outbuf == ({ exception: false })
+          options = outbuf
+          outbuf = ''
+        end
+        loop do
+          result = wait_readable(0)
+          if result == nil
+            raise WaitReadable unless options[:exception] == false
+            return :wait_readable
+          end
+          # we have to try to consume control characters first
+          readpartial(0)
+          # and then only do a real read if we have something
+          return readpartial(length, outbuf) unless @buffer.empty?
+          # otherwise loop and see if there's more there
+        end
+      end
+
+      def wait_readable(timeout = nil)
+        return true unless @buffer.empty?
+        result = sock.wait_readable(timeout)
+        result = self if result == sock
+        result
+      end
+
+      def ungetbyte(b)
+        @buffer.insert(0, b.chr)
+      end
+
+      def ungetc(c)
+        @buffer.insert(0, c)
+      end
+
+      def write(string)
+        string = string.gsub(/#{IAC}/no, IAC + IAC)
+        telnet.write(string)
+      end
+
+      def flush
+        sock.flush
+      end
+
+      def close
+        telnet.close
+      end
+
+      private
+
+      def write_modem_params
+        telnet.write(
+          IAC + SB + COM_PORT_OPTION + SET_BAUDRATE + [baud].pack("N") + IAC + SE +
+          IAC + SB + COM_PORT_OPTION + SET_DATASIZE + data_bits.chr + IAC + SE +
+          IAC + SB + COM_PORT_OPTION + SET_STOPSIZE + stop_bits.chr + IAC + SE +
+          IAC + SB + COM_PORT_OPTION + SET_PARITY + parity.chr + IAC + SE)
+        sock.flush
+      end
+    end
+  end
+end

data/lib/net/telnet/rfc2217/telnet.rb

@@ -0,0 +1,80 @@
+module Net
+  class Telnet
+    class RFC2217
+      module TelnetExtensions
+        def preprocess(string)
+          # combine CR+NULL into CR
+          string = string.gsub(/#{CR}#{NULL}/no, CR) if @options["Telnetmode"]
+
+          # combine EOL into "\n"
+          string = string.gsub(/#{EOL}/no, "\n") unless @options["Binmode"]
+
+          # remove NULL
+          string = string.gsub(/#{NULL}/no, '') unless @options["Binmode"]
+
+          string.gsub(/#{IAC}(
+                      [#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]|
+                      [#{DO}#{DONT}#{WILL}#{WONT}]
+                        [#{OPT_BINARY}-#{OPT_NEW_ENVIRON}#{44.chr}#{OPT_EXOPL}]|
+                      #{SB}[^#{IAC}]*#{IAC}#{SE}
+                    )/xno) do
+            if block_given? && IAC != $1
+              # already handled; don't handle it ourselves
+              next '' if yield $1
+            end
+
+            if    IAC == $1  # handle escaped IAC characters
+              IAC
+            elsif AYT == $1  # respond to "IAC AYT" (are you there)
+              self.write("nobody here but us pigeons" + EOL)
+              ''
+            elsif DO[0] == $1[0]  # respond to "IAC DO x"
+              if OPT_BINARY[0] == $1[1]
+                unless @telnet_option["BINARY"] == true
+                  @telnet_option["BINARY"] = true
+                  self.write(IAC + WILL + OPT_BINARY)
+                end
+              else
+                self.write(IAC + WONT + $1[1..1])
+              end
+              ''
+            elsif DONT[0] == $1[0]  # respond to "IAC DON'T x" with "IAC WON'T x"
+              self.write(IAC + WONT + $1[1..1])
+              ''
+            elsif WILL[0] == $1[0]  # respond to "IAC WILL x"
+              if    OPT_BINARY[0] == $1[1]
+                self.write(IAC + DO + OPT_BINARY)
+              elsif OPT_ECHO[0] == $1[1]
+                self.write(IAC + DO + OPT_ECHO)
+              elsif OPT_SGA[0]  == $1[1]
+                unless @telnet_option["SGA"]
+                  @telnet_option["SGA"] = true
+                  self.write(IAC + DO + OPT_SGA)
+                end
+              else
+                self.write(IAC + DONT + $1[1..1])
+              end
+              ''
+            elsif WONT[0] == $1[0]  # respond to "IAC WON'T x"
+              if    OPT_ECHO[0] == $1[1]
+                self.write(IAC + DONT + OPT_ECHO)
+              elsif OPT_SGA[0]  == $1[1]
+                unless @telnet_option["SGA"] == false
+                  @telnet_option["SGA"] = false
+                  self.write(IAC + DONT + OPT_SGA)
+                end
+              else
+                self.write(IAC + DONT + $1[1..1])
+              end
+              ''
+            elsif SB[0] == $1[0] # yield sub option
+              ''
+            else
+              ''
+            end
+          end
+        end # preprocess
+      end
+    end
+  end
+end

data/lib/net/telnet/rfc2217/version.rb

@@ -0,0 +1,7 @@
+module Net
+  class Telnet
+    class RFC2217
+      VERSION = '0.0.2'
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: net-telnet-rfc2217
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Cody Cutrer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-telnet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 
+email: cody@cutrer.com'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/net-telnet-rfc2217.rb
+- lib/net/telnet/rfc2217.rb
+- lib/net/telnet/rfc2217/telnet.rb
+- lib/net/telnet/rfc2217/version.rb
+homepage: https://github.com/ccutrer/net-telnet-2217
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Library for getting an IO-like object for a remote serial port
+test_files: []