cimd 0.0.1

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+script: bundle exec rspec spec
+rvm:
+  - 1.9.3
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    cimd (0.0.1)
+      eventmachine (>= 0.12)
+      thor
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    eventmachine (0.12.10)
+    ffi (1.0.11)
+    guard (1.3.2)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-rspec (1.2.1)
+      guard (>= 1.1)
+    listen (0.5.0)
+    rake (0.9.2.2)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    thor (0.16.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cimd!
+  guard (>= 1.3)
+  guard-rspec (>= 1.2)
+  rake
+  rb-inotify (>= 0.8.8)
+  rspec

data/Guardfile

@@ -0,0 +1,35 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+#guard 'coffeescript', :input => 'app/assets/javascripts'
+
+#guard 'livereload' do
+  #watch(%r{app/views/.+\.(erb|haml|slim)})
+  #watch(%r{app/helpers/.+\.rb})
+  #watch(%r{public/.+\.(css|js|html)})
+  #watch(%r{config/locales/.+\.yml})
+  ## Rails Assets Pipeline
+  #watch(%r{(app|vendor)/assets/\w+/(.+\.(css|js|html)).*})  { |m| "/assets/#{m[2]}" }
+#end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/lib/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/cimd_spec.rb" }
+  #watch('spec/spec_helper.rb')  { "spec" }
+
+  ## Rails example
+  #watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  #watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  #watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  #watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  #watch('config/routes.rb')                           { "spec/routing" }
+  #watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  ## Capybara request specs
+  #watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  ## Turnip features and steps
+  #watch(%r{^spec/acceptance/(.+)\.feature$})
+  #watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -0,0 +1,49 @@
+[![Dependency Status](https://gemnasium.com/musashimm/cimd.png)](https://gemnasium.com/musashimm/cimd)
+[![Build Status](https://secure.travis-ci.org/musashimm/cimd.png)](http://travis-ci.org/musashimm/cimd)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/musashimm/cimd)
+
+CIMD
+======
+
+Overview
+--------
+
+Classes and binaries to handle SMS Cimd protocol.
+
+Usage
+-----
+
+### cimd_cli.rb receivesms ###
+`cimd_cli.rb receivesms` receives smses endlessly. If You want to stop reciving just press ^C.
+
+    cimd_cli.rb receivesms --msisdn=MSISDN --password=PASSWORD --server=SERVER --user-identity=USER_IDENTITY
+
+    Options:
+      --server=SERVER                            # Address of SMSC server (can be DNS name)
+      [--port=PORT]                              # Port number for CIMD protocol
+                                                 # Default: 9971
+      --user-identity=USER_IDENTITY              # Username of CIMD account
+      --password=PASSWORD                        # Password for CIMD account USERNAME
+      [--message=MESSAGE]                        # Message to be send
+                                                 # Default: SMS test message
+      --msisdn=MSISDN                            # MSISDN number to be send
+      [--alpha-orig-address=ALPHA_ORIG_ADDRESS]  # Identity of sender
+                                                 # Default: Sms Service
+### cimd_cli.rb sendsms ###
+`cimd_cli.rb sendsms` sends text SMS to MSISDN number
+
+    cimd_cli.rb sendsms --msisdn=MSISDN --password=PASSWORD --server=SERVER --user-identity=USER_IDENTITY
+
+    Options:
+        --server=SERVER                            # Address of SMSC server (can be DNS name)
+        [--port=PORT]                              # Port number for CIMD protocol
+                                                   # Default: 9971
+        --user-identity=USER_IDENTITY              # Username of CIMD account
+        --password=PASSWORD                        # Password for CIMD account USERNAME
+        [--message=MESSAGE]                        # Message to be send
+                                                   # Default: SMS test message
+        --msisdn=MSISDN                            # MSISDN number to be send
+        [--alpha-orig-address=ALPHA_ORIG_ADDRESS]  # Identity of sender
+                                                   # Default: Sms Service
+
+    

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/cimd_cli.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'eventmachine'
+require 'cimd'
+require 'thor'
+
+module CIMD
+
+  def self.start_eventmachine(conn,messages,options)
+    EventMachine.run do
+      Signal.trap("INT") { CIMD::Loop.logout_request }
+      Signal.trap("TERM") { CIMD::Loop.logout_request }
+      EventMachine.connect conn.server, conn.port, CIMD::Loop do |c|
+        c.messages = messages
+        c.conn = conn
+        c.options = options
+      end
+    end
+  end
+
+  class MyCLI < Thor
+
+    desc "sendsms", "Sends text SMS to MSISDN number"
+    option :server, :required => true,:desc => "Address of SMSC server (can be DNS name)"
+    option :port, :desc => "Port number for CIMD protocol",:default => 9971
+    option :user_identity, :required => true,:desc => "Username of CIMD account"
+    option :password, :required => true,:desc => "Password for CIMD account USERNAME"
+    option :message, :desc => "Message to be send",:default=>"SMS test message"
+    option :msisdn, :required => true,:desc => "MSISDN number to be send"
+    option :alpha_orig_address, :desc => "Identity of sender",:default => "Sms Service"
+    def sendsms()
+      puts "Sending sms message: #{options[:message]} to #{options[:msisdn]}"
+      conn = CIMD::Connection.new(options[:server],options[:port],options[:user_identity],options[:password],options[:alpha_orig_address],1,60)
+      messages = EM::Queue.new
+      messages.push(CIMD::login_message(conn))
+      messages.push(CIMD::submit_text_message(conn,options[:msisdn],options[:message]))
+      messages.push(CIMD::logout_message)
+      CIMD::start_eventmachine(conn,messages,{})
+    end
+
+    desc "receivesms", "Receives smses and sends echo"
+    long_desc <<-LONGDESC
+    `cimd_cli.rb receivesms` receives smses endlessly. If You want to stop
+    reciving just press ^C.
+    LONGDESC
+    option :server, :required => true,:desc => "Address of SMSC server (can be DNS name)"
+    option :port, :desc => "Port number for CIMD protocol",:default => 9971
+    option :user_identity, :required => true,:desc => "Username of CIMD account"
+    option :password, :required => true,:desc => "Password for CIMD account USERNAME"
+    option :message, :desc => "Message to be send",:default=>"SMS test message"
+    option :msisdn, :required => true,:desc => "MSISDN number to be send"
+    option :alpha_orig_address, :desc => "Identity of sender",:default => "Sms Service"
+    def receivesms()
+      puts "Start receiving"
+      conn = CIMD::Connection.new(options[:server],options[:port],options[:user_identity],options[:password],options[:alpha_orig_address],1,60)
+      messages = EM::Queue.new
+      messages.push(CIMD::login_message(conn))
+      CIMD::start_eventmachine(conn,messages,{})
+    end
+
+  end
+
+end
+
+CIMD::MyCLI.start(ARGV)
+
+
+
+

data/cimd.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cimd/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cimd"
+  s.version     = CIMD::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Wojciech Todryk"]
+  s.email       = ["wojciech@todryk.pl"]
+  s.homepage    = "http://todryk.pl/cimd"
+  s.summary     = %q{Utils for CIMD protocol}
+  s.description = %q{Utils for CIMD protocol}
+
+  s.rubyforge_project = "cimd"
+
+  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"]
+  s.add_dependency "eventmachine", [">= 0.12"]
+  s.add_dependency "thor", [">= 0"]
+  s.add_development_dependency "rspec", [">= 0"]
+  s.add_development_dependency "rake", [">= 0"]
+  s.add_development_dependency "guard", [">= 1.3"]
+  s.add_development_dependency "guard-rspec", [">= 1.2"]
+  s.add_development_dependency "rb-inotify", [">= 0.8.8"]
+
+end

data/lib/cimd.rb

@@ -0,0 +1,4 @@
+require 'cimd_constants'
+require 'cimd_structures'
+require 'cimd_messages'
+require 'cimd_loop'

data/lib/cimd/version.rb

@@ -0,0 +1,5 @@
+# Set of extensions
+module CIMD
+  # Gem version
+  VERSION = "0.0.1"
+end

data/lib/cimd_constants.rb

@@ -0,0 +1,91 @@
+module CIMD
+
+  STX = 0x02
+  ETX = 0x03
+  TAB = "\t"
+  CC = 0xFF
+  PARAM_SEP = ":"
+
+  # OP - OPERATION CODES
+  OP_LOGIN = 1
+  OP_LOGOUT = 2
+  OP_SUBMIT= 3
+  OP_ENQUIRE_MESSAGE_STATUS = 4
+  OP_DELIVERY_REQUEST = 5
+  OP_CANCEL_MESSAGE = 6
+  OP_SET = 8
+  OP_GET = 9
+  OP_DELIVERY_MESSAGE = 20
+  OP_DELIVERY_STATUS_REPORT = 23
+  OP_ALIVE = 40
+  OP_LOGIN_RESPONSE = 51
+  OP_LOGOUT_RESPONSE = 52
+  OP_SUBMIT_RESPONSE = 53
+  OP_ENQUIRE_MESSAGE_STATUS_RESPONSE = 54
+  OP_DELIVERY_REQUEST_RESPONSE = 55
+  OP_CANCEL_MESSAGE_RESPONSE = 56
+  OP_SET_RESPONSE = 58
+  OP_GET_RESPONSE = 59
+  OP_DELIVERY_MESSAGE_RESPONSE = 70
+  OP_DELIVERY_STATUS_REPORT_RESPONSE = 73
+  OP_ALIVE_RESPONSE = 90
+  OP_GENERAL_ERROR_RESPONSE = 98
+  OP_NACK = 99
+
+  def self.opcode_description(op_code)
+    descs = {
+      OP_LOGIN => "OP_LOGIN",
+      OP_LOGOUT => "OP_LOGOUT",
+      OP_SUBMIT=> "OP_SUBMIT",
+      OP_ENQUIRE_MESSAGE_STATUS => "OP_ENQUIRE_MESSAGE_STATUS",
+      OP_DELIVERY_REQUEST => "OP_DELIVERY_REQUEST",
+      OP_CANCEL_MESSAGE => "OP_CANCEL_MESSAGE",
+      OP_SET => "OP_SET",
+      OP_GET => "OP_GET",
+      OP_DELIVERY_MESSAGE => "OP_DELIVERY_MESSAGE",
+      OP_DELIVERY_STATUS_REPORT => "OP_DELIVERY_STATUS_REPORT",
+      OP_ALIVE => "OP_ALIVE",
+      OP_LOGIN_RESPONSE => "OP_LOGIN_RESPONSE",
+      OP_LOGOUT_RESPONSE => "OP_LOGOUT_RESPONSE",
+      OP_SUBMIT_RESPONSE => "OP_SUBMIT_RESPONSE",
+      OP_ENQUIRE_MESSAGE_STATUS_RESPONSE => "OP_ENQUIRE_MESSAGE_STATUS_RESPONSE",
+      OP_DELIVERY_REQUEST_RESPONSE => "OP_DELIVERY_REQUEST_RESPONSE",
+      OP_CANCEL_MESSAGE_RESPONSE => "OP_CANCEL_MESSAGE_RESPONSE",
+      OP_SET_RESPONSE => "OP_SET_RESPONSE",
+      OP_GET_RESPONSE => "OP_GET_RESPONSE",
+      OP_DELIVERY_MESSAGE_RESPONSE => "OP_DELIVERY_MESSAGE_RESPONSE",
+      OP_DELIVERY_STATUS_REPORT_RESPONSE => "OP_DELIVERY_STATUS_REPORT_RESPONSE",
+      OP_ALIVE_RESPONSE => "OP_ALIVE_RESPONSE",
+      OP_GENERAL_ERROR_RESPONSE => "OP_GENERAL_ERROR_RESPONSE",
+      OP_NACK => "",
+    }
+    return descs.has_key?(op_code) ? "(#{descs[op_code]})" : "(UNKNOWN)"
+  end
+  
+  # P - PARAMETER
+  P_USER_IDENTITY = 10
+  P_PASSWORD = 11
+  P_SUBADDR = 12
+  P_WINDOW_SIZE = 19
+  P_DESTINATION_ADDRESS = 21
+  P_ORIGINATOR_ADDRESS = 23
+  P_ALPHA_ORIG_ADDRESS = 27
+  P_DATA_CODING_SCHEME = 30
+  P_USER_DATA_HEADER = 32
+  P_USER_DATA = 33
+  P_USER_DATA_BINARY = 34
+  P_PROTOCOL_IDENTIFIER = 52
+  P_SERVICE_CENTRE_TIME_STAMP = 60
+  P_ERROR_CODE = 900
+  P_ERROR_TEXT = 901
+  
+  DEFAULT_WINDOW_SIZE = 1
+  DEFAULT_KEEP_ALIVE = 60
+  
+  ALPHABET_DEFAULT = 0
+  ALPHABET_8BIT = 1
+  ALPHABET_UCS2 = 2
+  ALPHABET_RESERVED = 3
+  
+  ALPHABET_BINARY = 8
+end

data/lib/cimd_loop.rb

@@ -0,0 +1,173 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+require 'eventmachine'
+require 'cimd'
+
+module CIMD
+
+  class Loop < EventMachine::Connection
+  
+    @@logout_request = false
+  
+    STATE=[:not_connected,:connected,:banner_received,:ready_to_send,:suspend]
+    MAX_NO_ACTIVITY_TIME = 180
+    attr_accessor :state
+    attr_accessor :messages
+    attr_accessor :conn
+    attr_accessor :keep_alive_counter
+    attr_accessor :no_activity_counter
+    attr_accessor :options
+    attr_accessor :logfile
+    attr_accessor :debug
+
+    def to_log(message)
+      #puts @debug
+      #puts @logfile
+      puts "#{Time.now.strftime("%Y-%m-%d/%H:%M:%S")} #{message}"
+      #puts message if @debug
+      #@logfile.puts message if @logfile
+      $stdout.flush
+    end
+  
+    def change_state(new_state)
+      if @state != new_state
+        to_log("#### Transition: #{@state.to_s} ==> #{new_state.to_s} (no_act:#{ Time.now.tv_sec - @no_activity_counter}, keep:#{Time.now.tv_sec - @keep_alive_counter}, queue:#{@messages.size})")
+        @state = new_state
+      end
+    end
+   
+    def self.logout_request
+      @@logout_request = true
+    end
+    
+    def initialize
+      @state = :not_connected
+      @debug = false
+      @log = nil
+      @keep_alive_counter = Time.now.tv_sec
+      @no_activity_counter = Time.now.tv_sec
+      #@debug = true if @options[:debug]
+      #begin
+      #  @log = File.new("ss", "w") if options[:logfile]
+      #rescue Exception => e
+      #  puts e.to_s
+      #  exit
+      #end
+    end
+  
+    def post_init
+      
+      @timer = EM.add_periodic_timer(1) do
+  
+      if @@logout_request == true 
+        change_state(:logout_request)
+        @@logout_request = false
+      end
+  
+      change_state(:alive) if Time.now.tv_sec - @keep_alive_counter > @conn.keep_alive
+      change_state(:no_activity) if Time.now.tv_sec - @no_activity_counter > MAX_NO_ACTIVITY_TIME
+  
+      #puts "No act:#{ Time.now.tv_sec - @no_activity_counter} Keep:#{Time.now.tv_sec - @keep_alive_counter} Queue: #{@messages.size}"
+      case @state
+        when :banner_received
+          change_state(:login_request)
+          @messages.pop{ |message|  sending_message(message)}
+        when :login_sucessfull
+          change_state(:ready_to_send)
+        when :ready_to_send
+          change_state(:suspend)
+          @messages.pop{ |message|  sending_message(message)}
+        when :no_activity,:logout_done
+          close_connection
+        when :alive
+          change_state(:suspend)
+          to_log("<<<< #{CIMD::alive_message}")
+          sending_message(CIMD::alive_message)
+        when :logout_request
+          @messages = EM::Queue.new
+          to_log("<<<< #{CIMD::logout_message}")
+          messages.push(CIMD::logout_message);
+          change_state(:ready_to_send)
+        when :suspend
+          #puts "Suspend"
+        end
+      end
+  
+    end # post_init
+    
+    def sending_message(message)
+      message.packet_number = @conn.packet_number!
+      to_log("<<<< #{message.to_s}")
+      send_data message.to_binary
+      @keep_alive_counter = Time.now.tv_sec
+    end
+  
+    def sending_response_message(message)
+      m = CIMD::only_response_message(message)
+      to_log("<<<< #{m.to_s}")
+      send_data m.to_binary
+    end
+    
+    def connection_completed
+      change_state(:connected)
+    end
+  
+    def receive_data(data)
+    #puts "Received plain data: #{data}"
+  
+      case data
+        when /CIMD2-A/
+          change_state(:banner_received)
+        else
+      
+          (@buffer ||= BufferedTokenizer.new("\003")).extract(data).each do |line|
+          message = Message.parse(line)
+      
+          to_log(">>>> #{message.to_s}")
+          # sprawdzic checsum
+          if message.is_binary?
+            message.parse_binary_data
+            to_log("**** Decoded binary: #{message.to_s}")
+          end
+          @no_activity_counter = Time.now.tv_sec
+      
+          case message.operation_code
+            when CIMD::OP_LOGIN_RESPONSE
+              if message.has_error?
+                to_log("!!!! Error: #{message.error}")
+                close_connection
+              else
+                change_state(:login_sucessfull)
+              end
+            when CIMD::OP_SUBMIT_RESPONSE
+              if message.has_error?
+                to_log("!!!! Error: #{message.error}")
+              end
+              change_state(:ready_to_send)
+            when CIMD::OP_DELIVERY_STATUS_REPORT
+              sending_response_message(message)
+            when CIMD::OP_DELIVERY_MESSAGE
+              sending_response_message(message)
+              messages.push(CIMD::submit_text_message(@conn,message.parameter_value(CIMD::P_ORIGINATOR_ADDRESS),message.parameter_value(CIMD::P_USER_DATA)))
+            when CIMD::OP_LOGOUT_RESPONSE
+              change_state(:logout_done)
+            when CIMD::OP_ALIVE_RESPONSE
+            when CIMD::OP_GENERAL_ERROR_RESPONSE
+              to_log("!!!! Error: #{message.error}")
+              close_connection
+          else
+            to_log("???? Unknown message type: #{data}")
+          end # case message.operation_code
+        end
+      end # case data
+    end # receive_data
+    
+    def unbind
+      @logfile.close unless @logfile.nil?
+      change_state(:not_connected)
+      EventMachine.stop_event_loop
+    end
+    
+  end # class Loop
+
+end # module CIMD

data/lib/cimd_messages.rb

@@ -0,0 +1,56 @@
+module CIMD
+
+  def self.login_message(connection)
+    m = Message.new(OP_LOGIN)
+    p_login = Parameter.new(P_USER_IDENTITY,connection.user_identity)
+    p_password = Parameter.new(P_PASSWORD,connection.password)
+    m.add(p_login)
+    m.add(p_password)
+    return m
+  end
+  
+  def self.logout_message
+    m = Message.new(OP_LOGOUT)
+    return m
+  end
+  
+  def self.submit_text_message(connection,msisdn,text)
+    m = Message.new(OP_SUBMIT)
+    p_msisdn = Parameter.new(P_DESTINATION_ADDRESS,msisdn)
+    p_text = Parameter.new(P_USER_DATA,text)
+    m.add(p_msisdn)
+    m.add(p_text)
+    unless connection.alpha_orig_address.nil?
+      p_orig = Parameter.new(P_ALPHA_ORIG_ADDRESS,connection.alpha_orig_address)
+      m.add(p_orig)
+    end
+    return m
+  end
+  
+  def self.submit_binary_message(connection,msisdn,binary_text)
+    m = Message.new(OP_SUBMIT)
+    p_msisdn = Parameter.new(P_DESTINATION_ADDRESS,msisdn)
+    p_text = Parameter.new(P_USER_DATA_BINARY,binary_text)
+    p_dcs = Parameter.new(P_DATA_CODING_SCHEME,ALPHABET_BINARY)
+    m.add(p_msisdn)
+    m.add(p_text)
+    m.add(p_dcs)
+    unless connection.alpha_orig_address.nil?
+      p_orig = Parameter.new(P_ALPHA_ORIG_ADDRESS,connection.alpha_orig_address)
+      m.add(p_orig)
+    end
+    return m
+  end
+  
+  def self.only_response_message(message)
+    m = Message.new(message.operation_code + 50)
+    m.packet_number = message.packet_number
+    return m
+  end
+  
+  def self.alive_message
+    m = Message.new(OP_ALIVE)
+    return m
+  end
+
+end

data/lib/cimd_structures.rb

@@ -0,0 +1,237 @@
+module CIMD
+
+  class Connection
+  
+    attr_accessor :server
+    attr_accessor :port
+    attr_accessor :user_identity
+    attr_accessor :password
+    attr_accessor :keep_alive
+    attr_accessor :packet_number
+    attr_accessor :window_size
+    attr_accessor :alpha_orig_address
+  
+    def initialize(server,port,user_identity,password,alpha_orig_address,window_size,keep_alive)
+      @server = server
+      @port = port
+      @user_identity = user_identity
+      @password = password
+      @keep_alive = keep_alive
+      @packet_number = 1
+      @alpha_orig_address = alpha_orig_address
+      @window_size = window_size
+    end
+  
+    def to_s
+      return sprintf "\n\n*** Connection object:\nServer: %s\n,Port: %s\n,User identity: %s\nPassword: %s\nKeep Alive: %3d\nAlpha Orig Address: %s\n Packet number: %d\n\n",@server,@port,@user_identity,@password,@keep_alive,@alpha_orig_address,@packet_number
+    end
+  
+    def packet_number?
+      return @packet_number
+    end
+  
+    def packet_number!
+      f = @packet_number
+      (@packet_number += 2) > 255 ? @packet_number = 1 : @packet_number
+      return f
+    end
+  
+  end #connection
+
+  class Parameter
+    
+    attr_accessor :code
+    attr_accessor :value
+
+    def initialize(code,value)
+      @code = code
+      @value = value
+    end
+
+    def to_s
+      return sprintf "%03d:%s",@code,@value
+    end
+
+    def self.parse(data)
+      fields = data.split(":")
+      p = Parameter.new((fields[0]).to_i,fields[1])
+      return p
+    end
+
+  end #parameter
+
+  class Dcs
+
+    attr_accessor :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def set_value(value)
+      @value = value.to_i
+    end
+
+    def coding_group
+      return @value & 0xF0
+    end
+
+    def has_coding_group_zero?
+      (@value & 0b11000000).zero?
+    end
+
+    def has_default_alphabet?
+      value.zero?
+    end
+
+    def alphabet
+      if has_coding_group_zero?
+        return (@value & 0b00001100) >> 2
+      else
+        return 0
+      end
+    end
+
+    def alphabet_set_UCS2
+      value = 8
+    end
+
+  end #dcs
+
+  class Message
+
+    attr_accessor :operation_code
+    attr_accessor :parameters
+    attr_accessor :packet_number
+    attr_accessor :checksum
+    attr_accessor :dcs
+
+    def initialize(operation_code)
+      @operation_code = operation_code
+      @packet_number = 1
+      @parameters = Array.new
+      @checksum = 0
+      @dcs = Dcs.new(0)
+    end
+
+    def alphabet
+      @dcs.alphabet
+    end
+
+    def has_alphabet_ucs2?
+      @dcs.alphabet == ALPHABET_UCS2
+    end
+
+    def has_error?
+      return has_parameter?(P_ERROR_CODE) ? true : false
+    end
+
+    def error
+      return has_error? ? "(#{parameter_value(CIMD::P_ERROR_CODE)}) #{parameter_value(CIMD::P_ERROR_TEXT)}" : nil
+    end
+
+    def calc_checksum
+      checksum = 0
+      s = String.new
+      s << STX
+      s << (sprintf "%02d:%03d",@operation_code,@packet_number)
+      s << TAB
+      @parameters.each do |p|
+        s << p.to_s
+        s << TAB
+      end
+
+      s.each_byte do |b|
+        checksum += b
+        checksum &= 0xFF
+      end
+      return checksum
+    end
+
+    def add(parameter)
+      @parameters.push(parameter)
+    end
+
+    def to_s
+      s = sprintf "<STX>%02d:%03d<TAB>",@operation_code,@packet_number
+      #add(Parameter.new(P_DATA_CODING_SCHEME,@dcs.value)) @operation_code == OP_SUBMIT
+      @parameters.each do |p|
+        s << p.to_s
+        s << "<TAB>"
+      end
+      s << (sprintf "%02x",@checksum).upcase
+      s << "<ETX> "
+      s << CIMD::opcode_description(@operation_code)
+      return s
+    end
+
+    def to_binary
+      s = String.new
+      s << STX
+      s << (sprintf "%02d:%03d",@operation_code,@packet_number)
+      s << TAB
+      #add(Parameter.new(P_DATA_CODING_SCHEME,@dcs.value)) if @operation_code == OP_SUBMIT
+      @parameters.each do |p|
+        s << p.to_s
+        s << TAB
+      end
+      s << (sprintf "%02x",calc_checksum)
+      s << ETX
+      return s
+    end
+
+    def is_binary?
+      has_parameter?(P_USER_DATA_BINARY)
+    end
+
+    def self.parse(data)
+      data.slice!(0)
+      fields = data.split(TAB)
+      header = fields[0].split(PARAM_SEP)
+      operation_code = header[0].to_i
+      m = Message.new(operation_code)
+      m.packet_number = header[1].to_i
+      fields.delete_at(0)
+      m.checksum = (fields.delete_at(fields.size - 1)).hex.to_i
+      fields.each do |p|
+          m.parameters << Parameter.parse(p)
+      end
+      m.dcs.set_value(m.parameter_value(P_DATA_CODING_SCHEME)) if m.has_parameter?(P_DATA_CODING_SCHEME)
+      return m
+    end
+
+    def parse_binary_data
+      if has_alphabet_ucs2? and @operation_code == OP_DELIVERY_MESSAGE
+        data = parameter_value(P_USER_DATA_BINARY)
+        i = 0
+        s = ""
+        while i < data.length do
+          s << data[i,2].hex
+          i += 2
+        end
+        p = Parameter.new(P_USER_DATA,Iconv.iconv("UTF-8", "UCS-2BE",s).first)
+        add(p)
+      end
+    end
+
+    def has_parameter?(code)
+      @parameters.each do |p|
+        return true if p.code == code
+      end
+      return false
+    end
+
+    def parameter_value(code)
+      @parameters.each do |p|
+        return p.value if p.code == code
+      end
+      return nil
+    end
+
+  end # message
+
+end # CIMD
+
+
+
+

data/spec/lib/cimd_spec.rb

@@ -0,0 +1,158 @@
+require 'cimd'
+require 'iconv'
+
+describe CIMD do
+
+  it "has constants" do
+    CIMD::OP_LOGIN.should == 1
+    CIMD::OP_LOGOUT.should == 2
+    CIMD::OP_SUBMIT.should == 3
+    CIMD::ALPHABET_BINARY.should == 8
+  end
+
+  context CIMD::Connection do
+
+    let(:cn) { CIMD::Connection.new('server',1234,'user1','password1',nil,1,120) }
+    let(:c) { CIMD::Connection.new('server',1234,'user1','password1','alpha',1,120) }
+
+    it "returns connection object with nil alpha orig number" do
+      cn.user_identity.should eq('user1')
+      cn.password.should eq('password1')
+      cn.server.should eq('server')
+      cn.port.should eq(1234)
+      cn.alpha_orig_address.should be_nil
+      cn.window_size.should eq(1)
+      cn.keep_alive.should eq(120)
+    end
+
+    it "returns connection object with not nil alpha orig number" do
+      c.user_identity.should eq('user1')
+      c.password.should eq('password1')
+      c.alpha_orig_address.should eq('alpha')
+    end
+  
+    it "returns first packet number" do
+      c.packet_number?.should eq(1)
+    end
+
+    it "returns 10th packet number" do
+      10.times { c.packet_number! }
+      c.packet_number?.should eq(21)
+    end
+
+    it "returns 130th packet number" do
+      130.times { c.packet_number! }
+      c.packet_number?.should eq(5)
+    end
+
+    it "opcode description" do
+      CIMD::opcode_description("as").should eq("(UNKNOWN)")
+      CIMD::opcode_description(CIMD::OP_LOGIN).should eq("(OP_LOGIN)")
+    end
+
+
+  end # context CIMD::Connection
+
+  context CIMD::Message do
+
+    let(:cn) { CIMD::Connection.new('server',1234,'user1','password1',nil,1,120) }
+    let(:c) { CIMD::Connection.new('server',1234,'user1','password1','alpha',1,120) }
+    let(:lm) { CIMD::login_message(cn) }
+    let(:lo) { CIMD::logout_message }
+    let(:submitn) { CIMD::submit_text_message(cn,'1234567789','textn') }
+    let(:submit) {CIMD::submit_text_message(c,'1234567789','text') }
+
+    it "returns login message" do
+      lm.has_parameter?(CIMD::P_USER_IDENTITY).should be_true
+      lm.has_parameter?(CIMD::P_PASSWORD).should be_true
+      lm.parameter_value(CIMD::P_USER_IDENTITY).should eq('user1')
+      lm.parameter_value(CIMD::P_PASSWORD).should eq('password1')
+      lm.has_parameter?(CIMD::P_DESTINATION_ADDRESS).should be_false
+      lm.parameter_value(CIMD::P_DESTINATION_ADDRESS).should be_nil
+    end
+
+    it "returns logout message" do
+      lo.parameters.size.should eq(0)
+    end
+
+    it "to_s" do
+      submit.to_s.should eq("<STX>03:001<TAB>021:1234567789<TAB>033:text<TAB>027:alpha<TAB>00<ETX> (OP_SUBMIT)")
+      submitn.to_s.should eq("<STX>03:001<TAB>021:1234567789<TAB>033:textn<TAB>00<ETX> (OP_SUBMIT)")
+    end
+
+    it "submit message with no alpha" do
+      #puts submitn
+      submitn.parameters.size.should eq(2)
+      submitn.has_parameter?(CIMD::P_ALPHA_ORIG_ADDRESS).should be_false
+    end
+
+    it "submit message with alpha" do
+      #puts submit
+      submit.parameters.size.should eq(3)
+      submit.has_parameter?(CIMD::P_ALPHA_ORIG_ADDRESS).should be_true
+      submit.parameter_value(CIMD::P_ALPHA_ORIG_ADDRESS).should eq('alpha')
+    end
+
+    it "return confirmation frame" do
+      submit.packet_number = 5
+      m = CIMD::only_response_message(submit)
+      m.packet_number.should eq(submit.packet_number)
+      m.operation_code.should eq(submit.operation_code+50)
+    end
+
+    it "inserts packet number to message" do
+      10.times { c.packet_number! }
+      submit.packet_number = c.packet_number!
+      submit.packet_number.should eq(21)
+    end
+
+    it "calculates checksum test" do
+      m = CIMD::Message.new(CIMD::OP_GENERAL_ERROR_RESPONSE)
+      m.packet_number = 1
+      m.add(CIMD::Parameter.new(CIMD::P_ERROR_CODE,'2'))
+      m.add(CIMD::Parameter.new(CIMD::P_ERROR_TEXT,'Syntax error'))
+      sprintf("%02x",m.calc_checksum).upcase.should eq('03')
+    end
+
+    it "parses message" do
+      s = ""
+      s << CIMD::STX
+      s << (sprintf("%02d:%03d\t",1,23))
+      s << (sprintf("%03d:%s\t",11,'admin1'))
+      s << (sprintf("%03d:%s\t",10,'jan'))
+      s << "57"
+      s << CIMD::ETX
+      m = CIMD::Message.parse(s)
+      m.operation_code.should eq(1)
+      m.packet_number.should eq(23)
+      m.parameter_value(CIMD::P_USER_IDENTITY).should eq('jan')
+      m.parameter_value(CIMD::P_PASSWORD).should eq('admin1')
+      sprintf("%02x",m.calc_checksum).upcase.should eq('57')
+    end
+
+    it "parses binary message" do
+      s ="\00220:000\t021:48661001723\t023:48601130651\t060:120210100902\t034:0044006600760067006700720067006200760142006400660076007600660105\t052:0\t030:8\t1A\003"
+      m = CIMD::Message.parse(s)
+      sprintf("%02x",m.calc_checksum).upcase.should eq('1A')
+      m.is_binary?.should be_true
+      m.dcs.coding_group.should be_zero
+      m.dcs.has_coding_group_zero?.should be_true
+      m.alphabet.should eq(2)
+      m.has_alphabet_ucs2?.should be_true
+      m.parse_binary_data
+      m.parameter_value(CIMD::P_USER_DATA).should match(/^D/)
+    end
+
+  end
+
+  #context CIMD::Loop do
+    #let(:loop) { CIMD::Loop.new({}) }
+
+    #it ("create new loop instance") do
+      #puts loop
+    #end
+
+  #end
+
+end
+

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: cimd
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Wojciech Todryk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+description: Utils for CIMD protocol
+email:
+- wojciech@todryk.pl
+executables:
+- cimd_cli.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- bin/cimd_cli.rb
+- cimd.gemspec
+- lib/cimd.rb
+- lib/cimd/version.rb
+- lib/cimd_constants.rb
+- lib/cimd_loop.rb
+- lib/cimd_messages.rb
+- lib/cimd_structures.rb
+- spec/lib/cimd_spec.rb
+homepage: http://todryk.pl/cimd
+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: cimd
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Utils for CIMD protocol
+test_files:
+- spec/lib/cimd_spec.rb