anachronism 0.2.0

data/lib/anachronism.rb

@@ -0,0 +1,9 @@
+require "ffi"
+
+module Anachronism
+  require 'anachronism/version'
+  
+  require 'anachronism/native'
+  require 'anachronism/nvt'
+  require 'anachronism/channel'
+end

data/lib/anachronism/channel.rb

@@ -0,0 +1,59 @@
+class Anachronism::Channel
+  attr_reader :telnet, :telopt
+  
+  def initialize (telopt, telnet)
+    telnet.bind(telopt, self)
+    
+    @telnet = telnet
+    @telopt = telopt
+  end
+  
+  def send (data)
+    @telnet.send_subnegotiation(@telopt, data)
+  end
+  
+  
+  def request_remote_enable (opts={})
+    @telnet.request_remote_enable(@telopt, opts)
+  end
+  
+  def request_remote_disable
+    @telnet.request_remote_disable(@telopt)
+  end
+  
+  def request_local_enable (opts={})
+    @telnet.request_local_enable(@telopt, opts)
+  end
+  
+  def request_local_disable
+    @telnet.request_local_disable(@telopt)
+  end
+  
+  
+  def local_enabled?
+    @telnet.local_enabled?(@telopt)
+  end
+  
+  def remote_enabled?
+    @telnet.remote_enabled?(@telopt)
+  end
+  
+  
+  #
+  # Callbacks
+  ##
+  def on_focus
+  end
+  
+  def on_blur
+  end
+  
+  def on_text (text)
+  end
+  
+  def on_local_toggle (active)
+  end
+  
+  def on_remote_toggle (active)
+  end
+end

data/lib/anachronism/native.rb

@@ -0,0 +1,139 @@
+require "ffi"
+
+module Anachronism::Native
+  extend FFI::Library
+  ffi_lib 'anachronism'
+  
+  typedef :pointer, :nvt
+  typedef :uchar, :telopt
+  
+  enum :error, [
+    :bad_parser, -3,
+    :bad_nvt,
+    :invalid_command,
+    :alloc,
+    :ok,
+    :interrupt,
+  ]
+  
+  enum :telopt_mode, [
+    :off,
+    :on,
+    :lazy,
+  ]
+  
+  enum :telopt_location, [
+    :local,
+    :remote
+  ]
+  
+  
+  #
+  # NVT Events
+  ##
+  enum :nvt_event_type, [
+    :data,
+    :command,
+    :warning,
+    :send,
+  ]
+  
+  class Event < FFI::Struct
+    layout(
+      :type, :nvt_event_type
+    )
+  end
+  
+  class DataEvent < FFI::Struct
+    layout(
+      :SUPER_, Event,
+      :data, :pointer,
+      :length, :size_t
+    )
+  end
+  
+  class CommandEvent < FFI::Struct
+    layout(
+      :SUPER_, Event,
+      :command, :uchar
+    )
+  end
+  
+  class WarningEvent < FFI::Struct
+    layout(
+      :SUPER_, Event,
+      :message, :string,
+      :position, :size_t
+    )
+  end
+  
+  class SendEvent < FFI::Struct
+    layout(
+      :SUPER_, Event,
+      :data, :pointer,
+      :length, :size_t
+    )
+  end
+  
+  #
+  # Telopt Events
+  ##
+  enum :telopt_event_type, [
+    :toggle,
+    :focus,
+    :data,
+  ]
+  
+  class TeloptEvent < FFI::Struct
+    layout(
+      :type, :telopt_event_type
+    )
+  end
+  
+  class ToggleTeloptEvent < FFI::Struct
+    layout(
+      :SUPER_, TeloptEvent,
+      :where, :telopt_location,
+      :status, :telopt_mode
+    )
+  end
+  
+  class FocusTeloptEvent < FFI::Struct
+    layout(
+      :SUPER_, TeloptEvent,
+      :focus, :uchar
+    )
+  end
+  
+  class DataTeloptEvent < FFI::Struct
+    layout(
+      :SUPER_, TeloptEvent,
+      :data, :pointer,
+      :length, :size_t
+    )
+  end
+  
+  
+  # Event callbacks
+  callback :nvt_event_callback, [:nvt, :pointer], :void
+  callback :telopt_event_callback, [:nvt, :telopt, :pointer], :void
+  
+  # NVT
+  attach_function :new_nvt,  :telnet_nvt_new,  [:nvt_event_callback, :telopt_event_callback, :pointer], :nvt
+  attach_function :free_nvt, :telnet_nvt_free, [:nvt], :void
+  
+  attach_function :get_userdata, :telnet_get_userdata, [:nvt, :pointer], :error
+  attach_function :interrupt,    :telnet_interrupt,    [:nvt],           :error
+  
+  attach_function :receive,             :telnet_receive,             [:nvt, :buffer_in, :size_t, :pointer], :error
+  attach_function :send_data,           :telnet_send_data,           [:nvt, :buffer_in, :size_t],           :error
+  attach_function :send_command,        :telnet_send_command,        [:nvt, :uchar],                        :error
+  attach_function :send_subnegotiation, :telnet_send_subnegotiation, [:nvt, :telopt, :buffer_in, :size_t],  :error
+  
+  attach_function :telopt_enable_local,   :telnet_telopt_enable_local,   [:nvt, :telopt, :uchar],   :error
+  attach_function :telopt_enable_remote,  :telnet_telopt_enable_remote,  [:nvt, :telopt, :uchar],   :error
+  attach_function :telopt_disable_local,  :telnet_telopt_disable_local,  [:nvt, :telopt],           :error
+  attach_function :telopt_disable_remote, :telnet_telopt_disable_remote, [:nvt, :telopt],           :error
+  attach_function :telopt_status_local,   :telnet_telopt_status_local,   [:nvt, :telopt, :pointer], :error
+  attach_function :telopt_status_remote,  :telnet_telopt_status_remote,  [:nvt, :telopt, :pointer], :error
+end

data/lib/anachronism/nvt.rb

@@ -0,0 +1,150 @@
+class Anachronism::Telnet
+  def initialize
+    # Make sure these aren't GC'd while the object exists.
+    @_on_nvt_event = proc {|_, ev| process_nvt_event(ev)}
+    @_on_telopt_event = proc {|_, telopt, ev| process_telopt_event(telopt, ev)}
+    
+    @telnet_nvt = Anachronism::Native.new_nvt(
+      @_on_nvt_event,
+      @_on_telopt_event,
+      FFI::Pointer.new(0))
+    raise NoMemoryError if @telnet_nvt == FFI::Pointer.new(0)
+    @telopt_callbacks = Array.new(256)
+  end
+  
+  def receive (data)
+    ptr = FFI::MemoryPointer.new :pointer
+    err = Anachronism::Native.receive(@telnet_nvt, data, data.length, ptr)
+    raise NoMemoryError if err == :alloc
+    data[ptr.read_int..-1]
+  end
+  
+  # Halts the Telnet parser at the current point, usually so the remainder of
+  # the data can be preprocessed before continuing.
+  def interrupt_parser
+    Anachronism::Native.interrupt(@telnet_nvt)
+    nil
+  end
+  
+  
+  def send_text (data)
+    err = Anachronism::Native.send_data(@telnet_nvt, data, data.length)
+    raise NoMemoryError if err == :alloc
+  end
+  
+  def send_command (command)
+    err = Anachronism::Native.send_command(@telnet_nvt, command)
+    raise ArgumentError, "#{command} is not a valid single-byte command" if err == :invalid_command
+  end
+  
+  def send_subnegotiation (telopt, data)
+    err = Anachronism::Native.send_subnegotiation(@telnet_nvt, telopt, data, data.length)
+    raise NoMemoryError if err == :alloc
+  end
+  
+  
+  def request_local_enable (telopt, opts={})
+    Anachronism::Native.telopt_enable_local(@telnet_nvt, telopt, (opts[:lazy]) ? 1 : 0)
+    nil
+  end
+  
+  def request_local_disable (telopt)
+    Anachronism::Native.telopt_disable_local(@telnet_nvt, telopt)
+    nil
+  end
+  
+  def request_remote_enable (telopt, opts={})
+    Anachronism::Native.telopt_enable_remote(@telnet_nvt, telopt, (opts[:lazy]) ? 1 : 0)
+    nil
+  end
+  
+  def request_remote_disable (telopt)
+    Anachronism::Native.telopt_disable_remote(@telnet_nvt, telopt)
+    nil
+  end
+  
+  
+  def remote_enabled? (telopt)
+    ptr = FFI::MemoryPointer.new :int
+    Anachronism::Native.telopt_status_local(@telnet_nvt, telopt, ptr)
+    !!ptr.read_int
+  end
+  
+  def local_enabled? (telopt)
+    ptr = FFI::MemoryPointer.new :int
+    Anachronism::Native.telopt_status_remote(@telnet_nvt, telopt, ptr)
+    !!ptr.read_int
+  end
+  
+  
+  def bind (telopt, receiver)
+    raise "Can't bind to a bound telopt." if @telopt_callbacks[telopt]
+    @telopt_callbacks[telopt] = receiver
+  end
+  
+  def unbind (telopt)
+    @telopt_callbacks[telopt] = nil
+  end
+  
+  
+  #
+  # Callbacks
+  ##
+  def on_text (text)
+  end
+  
+  def on_command (command)
+  end
+  
+  def on_send (data)
+  end
+  
+  def on_warning (message, position)
+  end
+  
+
+  def process_nvt_event (event_ptr) # :nodoc:
+    ev = Anachronism::Native::Event.new(event_ptr)
+    
+    case ev[:type]
+    when :data
+      ev = Anachronism::Native::DataEvent.new(event_ptr)
+      on_text ev[:data].read_string(ev[:length])
+    when :command
+      ev = Anachronism::Native::CommandEvent.new(event_ptr)
+      on_command ev[:command]
+    when :send
+      ev = Anachronism::Native::SendEvent.new(event_ptr)
+      on_send ev[:data].read_string(ev[:length])
+    when :warning
+      ev = Anachronism::Native::WarningEvent.new(event_ptr)
+      on_warning ev[:message], ev[:position]
+    end
+  end
+  
+  def process_telopt_event (telopt, event_ptr) # :nodoc:
+    receiver = @telopt_callbacks[telopt]
+    return unless receiver
+    
+    ev = Anachronism::Native::TeloptEvent.new(event_ptr)
+    case ev[:type]
+    when :toggle
+      ev = Anachronism::Native::ToggleTeloptEvent.new(event_ptr)
+      if ev[:where] == :local
+        receiver.on_local_toggle(ev[:status] == :on)
+      elsif ev[:where] == :remote
+        receiver.on_remote_toggle(ev[:status] == :on)
+      end
+    when :focus
+      ev = Anachronism::Native::FocusTeloptEvent.new(event_ptr)
+      if ev[:focus] == 0
+        receiver.on_blur
+      else
+        receiver.on_focus
+      end
+    when :data
+      ev = Anachronism::Native::DataTeloptEvent.new(event_ptr)
+      receiver.on_text ev[:data].read_string(ev[:length])
+    end
+  end
+end

data/lib/anachronism/version.rb

@@ -0,0 +1,3 @@
+module Anachronism
+  VERSION = "0.2.0"
+end

data/lib/anachronism/version.rbc

@@ -0,0 +1,130 @@
+!RBIX
+14718323382541880341
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+28
+99
+7
+0
+65
+49
+1
+2
+13
+99
+12
+7
+2
+12
+7
+3
+12
+65
+12
+49
+4
+4
+15
+49
+2
+0
+15
+2
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+5
+x
+11
+Anachronism
+x
+11
+open_module
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+11
+Anachronism
+i
+12
+5
+66
+65
+7
+0
+7
+1
+64
+49
+2
+2
+11
+I
+3
+I
+0
+I
+0
+I
+0
+n
+p
+3
+x
+7
+VERSION
+s
+5
+0.2.0
+x
+9
+const_set
+p
+3
+I
+2
+I
+2
+I
+c
+x
+65
+/home/jonathan/Projects/anachronism-rb/lib/anachronism/version.rb
+p
+0
+x
+13
+attach_method
+p
+3
+I
+0
+I
+1
+I
+1c
+x
+65
+/home/jonathan/Projects/anachronism-rb/lib/anachronism/version.rb
+p
+0

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: anachronism
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Jonathan Castello
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 0
+        - 7
+        version: 1.0.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 0
+        - 7
+        version: 1.0.7
+  type: :development
+  version_requirements: *id002
+description: Anachronism provides a simple Ruby interface to the Telnet protocol.
+email: jonathan@jonathan.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/anachronism.rb
+- lib/anachronism/native.rb
+- lib/anachronism/nvt.rb
+- lib/anachronism/libanachronism.so
+- lib/anachronism/channel.rb
+- lib/anachronism/version.rbc
+- lib/anachronism/version.rb
+has_rdoc: true
+homepage: https://github.com/Twisol/anachronism
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      hash: 51
+      segments: 
+      - 1
+      - 9
+      - 0
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A binding to libanachronism, a Telnet processing library.
+test_files: []
+