mikrotik 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+.bundle
+.idea
+.redcar
+.yardoc
+Gemfile.lock
+pkg
+doc
+!doc/setup.rb
+*.gem

data/.yardopts

@@ -0,0 +1 @@
+--no-private -e ./doc/setup.rb

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'eventmachine'
+
+group :development do
+  gem 'rspec'
+  gem 'yard'
+  gem 'jeweler'
+  gem 'guard'
+  gem 'guard-yard'
+end

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+  watch(%r{ext/.+\.c})
+end

data/README.markdown

@@ -0,0 +1,4 @@
+Mikrotik API Client
+===================
+
+*   **API Documentation**: [View Online](http://ominiom.github.com/mikrotik/)

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mikrotik"
+    gem.summary = %Q{Mikrotik API protocol client in Ruby}
+    gem.description = %Q{An implementation of the Mikrotik API protocol in Ruby/EventMachine}
+    gem.email = "iain@ominiom.com"
+    gem.homepage = "http://github.com/ominiom/mikrotik"
+    gem.authors = ["Iain Wilson"]
+    gem.files = FileList["lib/*.rb", "lib/*/*.rb", "lib/*/*/*.rb"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/examples/bandwidth_monitor.rb

@@ -0,0 +1,34 @@
+# Add lib to load path
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mikrotik'
+
+EventMachine.run do
+  client = Mikrotik.connect :host => "192.168.1.254", :port => 8728, :username => "admin", :password => "debUwu8A"
+  
+  puts "Connecting..."
+  
+  client.on_login_success do |client|
+    puts "Login successful"
+    
+    # Run a command every 5 seconds
+    EM.add_timer(EM::PeriodicTimer.new(5) do      
+      client.execute(client.command(:interface, :print).returning(:name, :bytes).where(:name => :ether1).on_reply do |reply|
+        # Sum up the in and out counts
+        bytes = reply.result(:bytes).split('/').map(&:to_i).inject(0) { |i, n| i = i + n }
+        # Format nicely
+        total = sprintf "%.2f", (bytes / 1024.0 / 1024.0)
+        # Output
+        puts "Interface '#{reply.result :name}' has transferred #{total} MB"      
+      end)
+    end)
+    
+  end
+  
+  trap 'SIGINT' do
+    client.disconnect
+    puts "Disconnected from #{client.options[:host]}"
+    exit
+  end
+  
+end

data/examples/dhcp.rb

@@ -0,0 +1,8 @@
+client.execute(client.command(:ip, :dhcp_server, :lease, :getall).on_done do |replies|
+  puts replies.collect { |reply| "IP '#{reply.result :address}' assigned to MAC #{reply.result('mac-address')}" }
+end)
+
+client.on_pending_complete do |client|
+  puts "All commands completed, closing session..."
+  client.disconnect
+end

data/examples/uptime.rb

@@ -0,0 +1,8 @@
+    client.execute(client.command(:system, :resource, :print).returning(:uptime).on_reply do |reply|
+      puts "System uptime is #{reply.result :uptime}"
+    end)
+    
+    client.on_pending_complete do |client|
+      puts "All commands completed, closing session..."
+      client.disconnect
+    end

data/lib/extensions/events.rb

@@ -0,0 +1,41 @@
+# @private
+module Events
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  # @return [Boolean] If the event has a handler registered
+  def has_event_handler?(event)
+    @events ||= {}
+    !@events["on_#{event}".to_sym].nil?
+  end
+  
+  module ClassMethods
+
+    # @param [Array<String, Symbol>] events Array of event names
+    # @example
+    #   has_events :delete, :create
+    def has_events(*events)
+      events.map { |event| event.to_s }.each do |event|
+        self.class_eval <<-"END"
+          def on_#{event}(*args, &block)
+            @events ||= {}
+            if block_given? then
+              @events[:on_#{event}] = block.to_proc              
+            else
+              @events[:on_#{event}].call(*args) unless @events[:on_#{event}].nil?
+            end
+            return self
+          end
+        END
+      end
+    end
+
+    def has_event(event)
+      has_events(*[event])
+    end
+
+  end
+  
+end

data/lib/extensions/string.rb

@@ -0,0 +1,27 @@
+# @private
+class String
+
+  def to_mikrotik_word
+     str = self.dup
+     if RUBY_VERSION >= '1.9.0'
+       str.force_encoding(Encoding::BINARY)
+     end
+     if str.length < 0x80
+       return str.length.chr + str
+     elsif str.length < 0x4000
+       return Microtik::Utilities.bytepack(str.length | 0x8000, 2) + str
+     elsif str.length < 0x200000
+       return Microtik::Utilities.bytepack(str.length | 0xc00000, 3) + str
+     elsif str.length < 0x10000000
+       return Microtik::Utilities.bytepack(str.length | 0xe0000000, 4) + str
+     elsif str.length < 0x0100000000
+       return 0xf0.chr + Microtik::Utilities.bytepack(str.length, 5) + str
+     else
+       raise RuntimeError.new(
+         "String is too long to be encoded for " +
+         "the MikroTik API using a 4-byte length!"
+       )
+     end
+   end
+
+end

data/lib/mikrotik.rb

@@ -0,0 +1,42 @@
+require 'eventmachine'
+require 'digest/md5'
+
+# TODO : Allow underscores to be used instead of dashes in command paths and properties - e.g. in dhcp-server and mac-address
+
+module Mikrotik
+
+  module Protocol; end;
+  
+  # @return [Boolean] Whether debugging prints are enabled or not
+  def self.debugging
+    false
+  end
+
+  # Prints message if debugging is enabled
+  # @param [Array<String>] message Parts of the message 
+  def self.debug(message)
+    puts message.join(' ') if debugging
+  end
+
+  # Shorthand for Mikrotik::Client.connect
+  # @return [Mikrotik::Client]
+  def self.connect(*args)
+    Client.connect(*args)
+  end
+
+end
+
+# Add ourselves to the load path
+$: << File.dirname(__FILE__)
+
+# Load up the code
+require 'extensions/string'
+require 'extensions/events'
+require 'mikrotik/version'
+require 'mikrotik/errors'
+require 'mikrotik/client'
+require 'mikrotik/connection'
+require 'mikrotik/command'
+require 'mikrotik/utilities'
+require 'mikrotik/protocol/parser'
+require 'mikrotik/protocol/sentence'

data/lib/mikrotik/client.rb

@@ -0,0 +1,124 @@
+# Contains all methods for interacting with a device
+# such as logging in and executing commands
+#
+# @see Mikrotik::Client.connect
+module Mikrotik::Client
+  include Events
+
+  # Fired when the API login command has returned successfully.
+  # After this event has fired it is safe to start sending commands
+  has_event :login_success
+  
+  # Fired when the API login command returns an error -
+  # for example in cases where the credentials were wrong
+  has_event :login_failure
+  
+  # Fired when the queue of commands awaiting completion
+  # becomes empty
+  has_event :pending_complete
+
+  # @return [Hash] Options used for the connection
+  # @see Client#connect
+  attr_reader :options
+
+  # Connects to a RouterOS device. Required options are +:host+
+  # and +:password+ - +:username+ and +:port+ default
+  # to +admin+ and +8728+ respectively
+  #
+  # @param [Hash] options +:test+ Hash of connection options
+  # @option options [String] :host Device's IP address
+  # @option options [Integer] :port (8728) Port of the API service on the device
+  # @option options [String] :username ('admin') API username to authenticate with
+  # @option options [String] :password Password for the given username
+  # @return [Client]
+  # @raise [ArgumentError] If not all required options are given
+  # @example Connection with minimum options set
+  #   Mikrotik::Client.connect({
+  #     :host => '192.168.1.1',  
+  #     :password => 'topsecret'
+  #   })
+  # @example Connection with all options set to override defaults
+  #   Mikrotik::Client.connect({
+  #     :host => '10.200.0.21',
+  #     :port => 3450,
+  #     :username => 'apiuser',
+  #     :password => 'topsecret'
+  #   })
+  # 
+  def self.connect(options = { :username => 'admin', :port => 8728 })
+    defaults = { :username => 'admin', :port => 8728 }
+    options = defaults.merge(options)
+    # Check required options have been given
+    all_required_options = !([:host, :port, :username, :password].map { |option|
+      options.key?(option) && !options[option].nil?
+    }.include?(false))
+    raise ArgumentError, "Options for host and password must be given" unless all_required_options
+
+    c = EM.connect options[:host], options[:port], self, options
+    c.pending_connect_timeout = 10.0
+    c
+  end
+  
+  # Logs in to the device. This is called automatically when
+  # the TCP connection succeeds. To be sure the device is ready
+  # to +execute+ commands before sending any register an event handler
+  # on +on_login_success+ and send commands from there
+  def login
+    execute command(:login).on_reply { |reply|
+
+      challenge = Mikrotik::Utilities.hex_to_bin(reply.result :ret) 
+      response = "00" + Digest::MD5.hexdigest(0.chr + @options[:password] + challenge)
+
+      execute command(:login).with(
+        :name => @options[:username],
+        :response => response
+      ).on_done { |replies|
+        Mikrotik.debug [:client, :on_login_success]
+        @logged_in = true
+        on_login_success(self)
+      }.on_trap { |trap|
+        Mikrotik.debug [:client, :on_login_failure]
+        if has_event_handler? :on_login_failure then
+          on_login_failure(self)
+        else
+          raise Mikrotik::Errors::UnhandledTrap, 'Login failed'
+        end
+      }
+
+    }
+  end
+
+  # Sends a command to the device
+  # @param command [Mikrotik::Command] The command to be executed
+  # @return [Mikrotik::Command] The command executed
+  def execute(command)
+    send command
+  end
+
+  # @return [Boolean] Status of the session login
+  def logged_in?
+    @logged_in
+  end
+  
+  # Shortcut for creating a Mikrotik::Command
+  # @return Mikrotik::Command
+  # @see Mikrotik::Command
+  def command(*path)
+    Mikrotik::Command.new(*path)
+  end
+
+  def inspect
+    "#<#{self.class.name}:0x#{self.object_id} host=#{@options[:host]}>"
+  end
+
+  def initialize(opts = {})
+    @closing = false
+    @logged_in = false
+    @options = opts
+    @events = {}
+    @buffer = ""
+    @next_tag = 1
+    extend Mikrotik::Connection 
+  end
+
+end

data/lib/mikrotik/command.rb

@@ -0,0 +1,81 @@
+# Class encapsulating a API command to be executed on the device
+class Mikrotik::Command
+  include Events
+
+  # Fired when the command completes
+  # @yield [replies] 
+  # @yieldparam [false, Array<Mikrotik::Protocol::Sentence>] replies All replies received from the device for this command
+  has_events :done
+
+  # Fired on each reply received from the command
+  # @yield [reply]
+  # @yieldparam [false, Mikrotik::Protocol::Sentence] reply The sentence received in reply
+  has_event :reply
+
+  # Fired when an error response is received from the command
+  # @yield [error_message]
+  # @yieldparam [false, String] error_message Error description
+  has_event :trap
+
+  # @return [Array<Mikrotik::Protocol::Sentence>] All sentences sent in response to this command so far
+  attr_reader :replies
+
+  # @return [Hash] All option name/value pairs set on the command
+  attr_reader :options
+
+  # @return [String] Path to the command
+  attr_reader :command
+
+  # Creates a new command object
+  # @param [Array<String, Symbol>] path Path of the API command
+  def initialize(*command_path)    
+    @command = command_path.collect { |part| "#{part}".gsub('_', '-') }.join('/')
+    @command = "/#{@command}" unless @command.start_with?('/')
+    @options = {}
+    @replies = []
+  end
+  
+  # Adds property names and values to the command
+  # @param [Hash] options
+  def with(options = {})
+    options.each_pair do |option, value|
+      @options["=#{option}"] = value
+    end
+    self
+  end
+  
+  # Adds querying conditions to the command
+  # @param [Hash] conditions
+  def where(conditions = {})
+    conditions.each_pair do |property, value|
+      @options["?#{property}"] = value
+    end
+    self
+  end  
+  
+  # Specifies what properties should be returned by the device in response to this command
+  # 
+  # @param [Array<String, Symbol>] properties List of the names of properties to request in response 
+  # @return [self]
+  def returning(*properties)
+    @options['=.proplist'] ||= []
+    properties.each do |property|
+      @options['=.proplist'] << "#{property}"
+    end
+    self
+  end
+
+  # Encodes the command for transmission
+  # @return [String] Command encoded as an API sentence in binary string format
+  def encoded    
+    @command.to_mikrotik_word + @options.collect { |key, value|
+      case value.class.name
+      when 'Array'        
+        [key, value.collect { |item| "#{item}" }.join(',')].join '='        
+      else
+        "#{key}=#{value}"
+      end
+    }.map { |option| option.to_mikrotik_word }.join + 0x00.chr
+  end
+
+end

data/lib/mikrotik/connection.rb

@@ -0,0 +1,84 @@
+# Contains logic for sending and receiving data to and from the device
+module Mikrotik::Connection
+
+  # @private
+  def connection_completed
+    @commands = {}
+    @sentences = []
+    @parser = Mikrotik::Protocol::Parser.new
+    @parser.on_sentence do |sentence|
+      handle_reply(sentence)
+    end
+    login
+  end
+
+  # Disconnects from the device
+  def disconnect
+    Mikrotik.debug [:connection, :disconnect]
+    @closing = true
+    close_connection(true)
+  end
+
+  # @private
+  def send(command)
+    command.options['.tag'] = @next_tag
+    Mikrotik.debug [:connection, :send, command.encoded]
+    @commands[@next_tag] = command
+    send_data(command.encoded)
+    @next_tag = @next_tag + 1
+    command
+  end
+
+  # @private
+  def receive_data(data)
+    Mikrotik.debug [:connection, :receive, data.size, data]
+    @parser << data
+  end
+  
+  # @private
+  def unbind
+    raise Mikrotik::Errors::ConnectionDropped unless @closing
+  end
+
+  private
+
+  # @private
+  def handle_reply(reply)
+    unless reply.tagged? then
+      Mikrotik.debug [:connection, :handle_reply, :untagged]
+      return
+    end
+    Mikrotik.debug [:connection, :handle_reply, :tagged, reply.tag]
+    # Retreive the command this reply is intended for by its tag
+    command = @commands[reply.tag]
+    command.replies << reply unless reply.completely_done?
+    # Catch those nasty errors
+    if reply.trap? then
+      Mikrotik.debug [:command, :on_trap]
+      # If there's an error handler, fire it...
+      if command.has_event_handler?(:on_trap) then
+        command.on_trap(reply.param(:message))
+      else
+        # ...if not, raise an error
+        raise Mikrotik::Errors::UnhandledTrap, reply.result(:message) || "Unknown error"
+      end
+      return
+    end
+    # Still fire on_reply events for done messages that contain more data
+    unless reply.completely_done? then
+      Mikrotik.debug [:command, :on_reply]
+      command.on_reply(reply)
+    end    
+    # If this was the last reply, fire the on_done event handler
+    if reply.done? then
+      Mikrotik.debug [:command, :on_done, reply.tag]
+      command.on_done(command.replies)
+      # As the command has completed remove it from the list of active commands
+      @commands.delete(reply.tag)
+      Mikrotik.debug [:client, :commands, :size, @commands.size]
+    end
+    # If there are no more active commands fire the event
+    on_pending_complete(self) if @commands.empty?
+  end
+
+end

data/lib/mikrotik/errors.rb

@@ -0,0 +1,11 @@
+module Mikrotik::Errors
+  
+  # Raised when an error response is received to a 
+  # command with no on_trap event handler
+  class UnhandledTrap < RuntimeError; end;
+  
+  # Raised when the connection to the device
+  # disconnects unexpectedly
+  class ConnectionDropped < RuntimeError; end;
+  
+end

data/lib/mikrotik/protocol/parser.rb

@@ -0,0 +1,126 @@
+# Responsible for extracting replies from API sentence data
+class Mikrotik::Protocol::Parser
+  include Events
+
+  # Fired when the parser extracts a complete API sentence
+  # @yield [Mikrotik::Protocol::Sentence] sentence
+  has_event :sentence
+
+  def initialize
+    @data = ''
+    @data.force_encoding(Encoding::BINARY) if RUBY_VERSION > '1.9'
+    reset!
+  end
+
+  # Discards the sentence currently being parsed
+  def reset!
+    @sentence = Mikrotik::Protocol::Sentence.new
+  end
+
+  # Adds data to the parser buffer and runs the parser
+  def <<(data)
+    @data << data
+    success = true
+    success = get_sentence while success
+  end
+
+  PAIR = /^(.+)=(.+)$/
+
+  # Indentifies the size of the length field in bits
+  # @return boolean, integer
+  def get_length_size
+    return false if @data.empty?
+
+    # High bits used for length type
+    # Low bits used as first bits of length
+    
+    # 0xxxxxxx = 7  bit length
+    # 10xxxxxx = 14 bit length
+    # 110xxxxx = 21 bit length
+    # 1110xxxx = 28 bit length
+    # 11110000 = 32 bit length follows
+
+    t = @data.unpack('C').first
+
+    return  7 if t &  0b10000000 == 0
+    return 14 if t &  0b01000000 == 0
+    return 21 if t &  0b00100000 == 0
+    return 28 if t &  0b00010000 == 0
+    return 32 if t == 0b11110000
+
+    raise ArgumentError, "Invalid length type encoding"
+  end
+
+  def get_length
+    size = get_length_size
+
+    return false unless size
+
+    need = bytes(size + 1)
+    return false unless @data.size >= need
+
+    length = nil
+    field = @data[0, need].unpack('C*')
+
+    case size
+      when 7
+        length = field[0] & 0x7f
+      when 14
+        length = ((field[0] & 0x3f) <<  8) | field[1]
+      when 21
+        length = ((field[0] & 0x1f) << 16) | field[1] <<  8 | field[2]
+      when 28
+        length = ((field[0] & 0x0f) << 24) | field[1] << 16 | field[2] << 8 | field[3]
+      when 32
+        length = field[1..4].pack('C4').unpack('N').first
+    end
+
+    if length
+      return length
+    else
+      raise ArgumentError, "Invalid word length"
+    end
+  end
+
+  def get_word
+    return false if @data.empty?
+    length_size = bytes(get_length_size + 1)
+    length      = get_length
+    
+    total_size  = length_size + length
+    
+    if length && @data.size >= total_size
+      @data.slice!(0, length_size)
+      word = @data.slice!(0, length)
+      Mikrotik.debug [:parser, :got_word, word]
+      return word
+    end
+
+    return false
+  end
+
+  def get_sentence
+    while word = get_word 
+      if word.empty?
+        Mikrotik.debug [:parser, :got_sentence, @sentence]
+        on_sentence(@sentence)
+        reset!
+        return true
+      else
+        if word =~ PAIR
+          key, value = word.scan(PAIR).flatten
+          @sentence[key] = value
+        else
+          @sentence[word] = nil
+        end
+      end
+    end
+
+    return false
+  end
+
+  def bytes(bits)
+    (bits / 8.0).ceil
+  end
+
+end

data/lib/mikrotik/protocol/sentence.rb

@@ -0,0 +1,70 @@
+class Mikrotik::Protocol::Sentence < Hash
+
+  # Sentence only contains a zero length word
+  # @return [Boolean]
+  def empty?
+    super || false
+  end
+
+  # Is this the last reply for a command?
+  # @return [Boolean]
+  def done?
+    key?('!done')
+  end
+  
+  # Is this reply only informing that a command is done, and contains no other data?
+  # @return [Boolean]
+  def completely_done?
+    size == 2 and done? and tagged?
+  end
+
+  # Is this informing of an error that should be trapped?
+  # @return [Boolean]
+  def trap?
+    key?('!trap')
+  end
+
+  # Does the reply have a command tag associated with it?
+  # @return [Boolean]
+  def tagged?
+    key?('.tag')
+  end
+
+  # Retreives the reply's command tag
+  #
+  # @return [nil] If the command is not tagged
+  # @return [Integer] tag If the command is tagged
+  def tag
+    tagged? ? self['.tag'] : nil
+  end
+
+  # Fetches a returned property
+  # @return value
+  def result(key)
+    self["=#{key}"]
+  end
+
+  # Fetches any returned value in this reply, converting it to a ruby type first
+  def [](key)
+    return nil unless key?(key)
+    case key
+    when '.tag'
+      fetch(key).to_i
+    else
+      value = fetch(key)
+      #case value
+      #when /\d+/
+      #  value.to_i
+      #when /\d+.\d+/
+      #  value.to_f
+      #when 'true'
+      #  true
+      #when 'false'
+      #  false
+      #else
+      #  value
+      #end
+    end
+  end
+
+end

data/lib/mikrotik/utilities.rb

@@ -0,0 +1,22 @@
+# @private
+class Mikrotik::Utilities
+
+  def self.hex_to_bin(input)
+    padding = input.size.even? ? '' : '0'
+    [padding + input].pack('H*')
+  end
+  
+  def self.bytepack(num, size)
+    s = String.new
+    s.force_encoding(Encoding::BINARY) if RUBY_VERSION >= '1.9.0'    
+    x = num < 0 ? -num : num  # Treat as unsigned
+    while size > 0
+      size -= 1
+      s = (x & 0xff).chr + s
+      x >>= 8
+    end
+    raise RuntimeError, "Number #{num} is too large to fit in #{size} bytes." if x > 0
+    return s
+  end
+
+end

data/lib/mikrotik/version.rb

@@ -0,0 +1,3 @@
+module Mikrotik
+  VERSION = "0.0.1"
+end

data/mikrotik.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mikrotik/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mikrotik"
+  s.version     = Mikrotik::VERSION
+  s.authors     = ["Iain Wilson"]
+  s.homepage    = "http://github.com/ominiom/mikrotik"
+  s.summary     = %q{A Mikrotik RouterOS API client using EventMachine} 
+  s.description = %q{Provides an interface to run commands and collect results from a RouterOS device}
+
+  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/spec/helper.rb

@@ -0,0 +1 @@
+require './lib/mikrotik.rb'

data/spec/parser.rb

@@ -0,0 +1,52 @@
+require 'helper'
+
+describe Mikrotik::Protocol::Parser do
+
+  before :each do
+    @parser = Mikrotik::Protocol::Parser.new
+  end
+
+  describe '#get_length_size' do
+
+    it "returns 7 for 1 byte lengths" do
+      @parser.instance_variable_set(:@data, 0b01111111.chr)
+      @parser.send(:get_length_size).should eq(7)
+    end
+
+    it "returns 14 for 2 byte lengths" do
+      @parser.instance_variable_set(:@data, 0b10111111.chr)
+      @parser.send(:get_length_size).should eq(14)
+    end
+
+    it "returns 21 for 3 byte lengths" do
+      @parser.instance_variable_set(:@data, 0b11011111.chr)
+      @parser.send(:get_length_size).should eq(21)
+    end
+
+    it "returns 28 for 28 bit lengths" do
+      @parser.instance_variable_set(:@data, 0b11101111.chr)
+      @parser.send(:get_length_size).should eq(28)
+    end
+
+    it "returns 32 for 32 bit lengths" do
+      @parser.instance_variable_set(:@data, 0b11110000.chr)
+      @parser.send(:get_length_size).should eq(32)
+    end
+
+  end
+
+  describe '#get_length' do
+    
+    it "handles 7 bit lengths" do
+      @parser.instance_variable_set(:@data, 0b01111101.chr)
+      @parser.send(:get_length).should eq(0b1111101)
+    end
+
+    it "handles 14 bit lengths" do
+      @parser.instance_variable_set(:@data, 0b10111111.chr + 0b11111111.chr)
+      @parser.send(:get_length).should eq(63 * 256 + 255)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: mikrotik
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Iain Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-18 00:00:00.000000000 Z
+dependencies: []
+description: Provides an interface to run commands and collect results from a RouterOS
+  device
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- Guardfile
+- README.markdown
+- Rakefile
+- doc/setup.rb
+- examples/bandwidth_monitor.rb
+- examples/dhcp.rb
+- examples/uptime.rb
+- lib/extensions/events.rb
+- lib/extensions/string.rb
+- lib/mikrotik.rb
+- lib/mikrotik/client.rb
+- lib/mikrotik/command.rb
+- lib/mikrotik/connection.rb
+- lib/mikrotik/errors.rb
+- lib/mikrotik/protocol/parser.rb
+- lib/mikrotik/protocol/sentence.rb
+- lib/mikrotik/utilities.rb
+- lib/mikrotik/version.rb
+- mikrotik.gemspec
+- spec/helper.rb
+- spec/parser.rb
+homepage: http://github.com/ominiom/mikrotik
+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: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A Mikrotik RouterOS API client using EventMachine
+test_files: []
+has_rdoc: