ruby-sml 0.2

data/lib/ruby-sml/sml-listentry.rb

@@ -0,0 +1,98 @@
+require 'digest/sha2'
+require 'openssl'
+
+require 'ruby-sml/nilclass-mixin'
+require 'ruby-sml/sml-time'
+
+module SML
+
+  class ListEntry
+    attr_accessor :name, :status, :status_type, :value_time, :unit, :scaler, :value, :value_type, :signature
+
+    def initialize(name, status, status_type, value_time, unit, scaler, value, value_type, signature)
+      @name = name
+      @status = status
+      @status_type = status_type
+      @value_time = value_time
+      @unit = unit
+      @scaler = scaler
+      @value = value
+      @value_type = value_type
+      @signature = signature
+    end
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      name = array_rep.shift
+      status = array_rep.shift
+      status_type = array_rep.shift unless status.nil?
+      value_time = SML::Time.construct(array_rep.shift)
+      unit = array_rep.shift
+      array_rep.shift unless unit.nil?
+      scaler = array_rep.shift
+      array_rep.shift unless scaler.nil?
+      value = array_rep.shift
+      case value
+      when Fixnum
+        value_type = array_rep.shift
+      when String
+        value_type = :string
+      end
+      signature = array_rep.shift
+
+      return nil if (value.nil? or name.nil?)
+      return SML::ListEntry.new(name, status, status_type, value_time, unit, scaler, value, value_type, signature)
+    end
+
+    def self.pconstruct(o={})
+      return SML::ListEntry.new(o[:name], o[:status], o[:status_type], o[:value_time], o[:unit], o[:scaler], o[:value], o[:value_type], o[:signature])
+    end
+
+    def to_a
+      result = [] << name << status << status_type << value_time.to_a << unit << :uint8 << scaler << :int8 << value
+      result << value_type if value.class == Fixnum
+      return result << signature
+    end
+
+    def calculate_hash(server_id)
+      return nil unless [:int8, :int16, :int32, :int64, :uint8, :uint16, :uint32, :uint64].include?(@value_type)
+      return nil unless @value_time.type == :timestamp
+      return nil unless @name.length == 6
+
+      bytes = String.new
+      bytes += server_id
+      (10-server_id.length).times do
+        bytes += [0x00].pack('c')
+      end
+      bytes += [@value_time.value].pack('N')
+      bytes += [@status].pack('c')
+      bytes += @name
+      bytes += [@unit].pack('c')
+      bytes += [@scaler].pack('c')
+      bytes += [(@value & 0xffff0000) >> 32,(@value & 0x0000ffff)].pack('NN')
+      17.times do
+        bytes += [0x00].pack('c')
+      end
+
+      hash = Digest::SHA2.new(256).digest(bytes)[0,24]
+      
+      return hash
+    end
+    def sign(server_id, private_key)
+      hash = calculate_hash(server_id)
+      return nil if hash.nil?
+
+      signature = OpenSSL::PKey::EC.new(private_key).dsa_sign_asn1(hash)
+
+      @signature = signature
+    end
+    def verify(server_id, public_key)
+      hash = calculate_hash(server_id)
+      return nil if hash.nil?
+      
+      return OpenSSL::PKey::EC.new(public_key).dsa_verify_asn1(hash,@signature)
+    end
+        
+  end
+
+end

data/lib/ruby-sml/sml-message.rb

@@ -0,0 +1,87 @@
+require 'ruby-sml/nilclass-mixin'
+require 'ruby-sml/sml-messagebody'
+
+require 'ruby-sml/encoding-binary'
+
+module SML
+
+  class Message
+    attr_accessor :transaction_id, :group_no, :abort_on_error, :body, :checksum
+
+    def initialize(transaction_id, group_no, abort_on_error, body, checksum)
+      @transaction_id = transaction_id
+      @group_no = group_no
+      @abort_on_error = abort_on_error
+      @body = body
+      @checksum = checksum
+    end
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      transaction_id = array_rep.shift
+      group_no = array_rep.shift
+      array_rep.shift unless group_no.nil?
+      abort_on_error_code = array_rep.shift
+      array_rep.shift unless abort_on_error_code.nil?
+      abort_on_error = nil
+      abort_on_error = case abort_on_error_code
+                       when 0x00
+                         :continue
+                       when 0x01
+                         :continue_with_next_group
+                       when 0x02
+                         :finish_group
+                       when 0xff
+                         :abort
+                       end
+      body = SML::MessageBody.construct(array_rep.shift)
+      return nil if body.nil?
+      checksum = array_rep.shift
+      array_rep.shift unless checksum.nil?
+
+      return nil unless array_rep.shift == :end_of_message
+      return SML::Message.new(transaction_id, group_no, abort_on_error, body, checksum)
+    end
+
+    def self.pconstruct(o={})
+      return SML::Message.new(o[:transaction_id], o[:group_no], o[:abord_on_error], o[:body], o[:checksum])
+    end
+
+    def to_a
+      calculate_checksum
+      return to_a_internal
+    end
+
+    def to_a_internal
+      abort_on_error_code = case abort_on_error
+                            when :continue
+                              0x00
+                            when :continue_with_next_group
+                              0x01
+                            when :finish_group
+                              0x02
+                            when :abort
+                              0xff
+                            end
+      
+      result = [] << transaction_id << group_no
+      result << :uint8 unless group_no.nil?
+      result << abort_on_error_code
+      result << :uint8 unless abort_on_error_code.nil?
+      result << SML::MessageBody.to_a(body) << checksum
+      result << :uint16 unless checksum.nil?
+      return result << :end_of_message
+    end
+
+    def calculate_checksum
+      encoded = SML::BinaryEncoding.encode_value(self.to_a_internal, :array)
+      encoded.slice!(-3,3)
+      calculated_checksum = CRC16.crc16(encoded)
+      calculated_checksum = (calculated_checksum ^ 0xffff)
+      calculated_checksum = ((calculated_checksum & 0xff00) >> 8) | ((calculated_checksum & 0x00ff) << 8)
+      @checksum = calculated_checksum   
+    end
+
+  end
+
+end

data/lib/ruby-sml/sml-messagebody.rb

@@ -0,0 +1,95 @@
+require 'ruby-sml/nilclass-mixin'
+require 'ruby-sml/sml-publicopen'
+require 'ruby-sml/sml-publicclose'
+require 'ruby-sml/sml-getprofilepack'
+require 'ruby-sml/sml-getprofilelist'
+require 'ruby-sml/sml-getprocparameter'
+require 'ruby-sml/sml-setprocparameter'
+require 'ruby-sml/sml-getlist'
+require 'ruby-sml/sml-attention'
+
+module SML
+
+  class MessageBody
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      choice = array_rep.shift
+      array_rep.shift unless choice.nil?
+      body_array = array_rep.shift
+      return case choice
+             when 0x0100
+               SML::PublicOpen::Request.construct(body_array)
+             when 0x0101
+               SML::PublicOpen::Response.construct(body_array)
+             when 0x0200
+               SML::PublicClose::Request.construct(body_array)
+             when 0x0201
+               SML::PublicClose::Response.construct(body_array)
+             when 0x0300
+               SML::GetProfilePack::Request.construct(body_array)
+             when 0x0301
+               SML::GetProfilePack::Response.construct(body_array)
+             when 0x0400
+               SML::GetProfileList::Request.construct(body_array)
+             when 0x0401
+               SML::GetProfileList::Response.construct(body_array)
+             when 0x0500
+               SML::GetProcParameter::Request.construct(body_array)
+             when 0x0501
+               SML::GetProcParameter::Response.construct(body_array)
+             when 0x0600
+               SML::SetProcParameter::Request.construct(body_array)
+             when 0x0601
+               nil
+               # SML::SetProcParameter::Response.construct(body_array)
+               # SML_SetProcParameter.Res is supposed to exist, but the standard doesn't define it
+               # respones to SetProcParameter.Req are supposed to be SML_Attention.Res'
+             when 0x0700
+               SML::GetList::Request.construct(body_array)
+             when 0x0701
+               SML::GetList::Response.construct(body_array)
+             when 0xff01
+               SML::Attention::Response.construct(body_array)
+             end      
+    end
+    def self.to_a(object)
+      choice = case object
+               when SML::PublicOpen::Request
+                 0x0100
+               when SML::PublicOpen::Response
+                 0x0101
+               when SML::PublicClose::Request
+                 0x0200
+               when SML::PublicClose::Response
+                 0x0201
+               when SML::GetProfilePack::Request
+                 0x0300
+               when SML::GetProfilePack::Response
+                 0x0301
+               when SML::GetProfileList::Request
+                 0x0400
+               when SML::GetProfileList::Response
+                 0x0401
+               when SML::GetProcParameter::Request
+                 0x0500
+               when SML::GetProcParameter::Response
+                 0x0501
+               when SML::SetProcParameter::Request
+                 0x0600
+               when SML::GetList::Request
+                 0x0700
+               when SML::GetList::Response
+                 0x0701
+               when SML::Attention::Response
+                 0xff01
+               end
+
+      result = [] << choice
+      result << :uint32 unless choice.nil?
+      return result << object.to_a
+    end
+
+  end
+
+end

data/lib/ruby-sml/sml-periodentry.rb

@@ -0,0 +1,38 @@
+require 'ruby-sml/nilclass-mixin'
+
+module SML
+
+  class PeriodEntry
+    attr_accessor :name, :unit, :scaler, :value, :value_type, :signature
+
+    def initialize(name, unit, scaler, value, value_type, signature)
+      @name = name
+      @unit = unit
+      @scaler = scaler
+      @value = value
+      @value_type = value_type
+      @signature = signature
+    end
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      name = array_rep.shift
+      unit = array_rep.shift
+      scaler = array_rep.shift
+      array_rep.shift unless scaler.nil?
+      value = array_rep.shift
+      value_type = array_rep.shift
+      signature = array_rep.shift
+
+      return nil if value.nil?
+      return SML::PeriodEntry.new(name, unit, scaler, value, value_type, signature)
+    end
+    def to_a
+      result = [] << name << unit << scaler
+      result << :int8 unless scaler.nil?
+      return result << value << value_type << signature
+    end
+
+  end
+
+end

data/lib/ruby-sml/sml-procparametervalue.rb

@@ -0,0 +1,46 @@
+require 'ruby-sml/nilclass-mixin'
+require 'ruby-sml/sml-periodentry'
+require 'ruby-sml/sml-tupelentry'
+require 'ruby-sml/sml-time'
+
+module SML
+
+  class ProcParameterValue
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      choice = array_rep.shift
+      array_rep.shift unless choice.nil?
+      body_rep = array_rep.shift
+
+      return case choice
+             when 0x01
+               body_rep
+             when 0x02
+               SML::PeriodEntry.construct(body_rep)
+             when 0x03
+               SML::TupelEntry.construct(body_rep)
+             when 0x04
+               SML::Time.construct(body_rep)
+             end
+    end
+    def self.to_a(object)
+      choice = case object
+               when SML::PeriodEntry
+                 0x02
+               when SML::TupelEntry
+                 0x03
+               when SML::Time
+                 0x04
+               else
+                 0x01
+               end
+
+      result = [] << choice
+      result << :uint8 unless choice.nil?
+      return result << object
+    end
+
+  end
+
+end

data/lib/ruby-sml/sml-profileobjectheaderentry.rb

@@ -0,0 +1,31 @@
+require 'ruby-sml/nilclass-mixin'
+
+module SML
+
+  class ProfileObjectHeaderEntry
+    attr_accessor :name, :unit, :scaler
+    
+    def initialize(name, unit, scaler)
+      @name = name
+      @unit = unit
+      @scaler = scaler
+    end
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      name = array_rep.shift
+      unit = array_rep.shift
+      scaler = array_rep.shift
+      array_rep.shift unless scaler.nil?
+
+      return SML::ProfileObjectHeaderEntry.new(name, unit, scaler)
+    end
+    def to_a
+      result = [] << name << unit << scaler
+      result << :int8 unless scaler.nil?
+      return result
+    end
+
+  end
+
+end

data/lib/ruby-sml/sml-profileobjectperiodentry.rb

@@ -0,0 +1,46 @@
+require 'ruby-sml/nilclass-mixin'
+require 'ruby-sml/sml-time'
+require 'ruby-sml/sml-valueentry'
+
+module SML
+  
+  class ProfileObjectPeriodEntry
+    attr_accessor :val_time, :status, :value_list, :period_signature
+
+    def initialize(val_time, status, value_list, period_signature)
+      @val_time = val_time
+      @status = status
+      @value_list = value_list
+      @period_signature = period_signature
+    end
+
+    def self.construct(array_rep)
+      return nil if array_rep.nil?
+      val_time = SML::Time.construct(array_rep.shift)
+      status = array_rep.shift
+      array_rep.shift unless status.nil?
+      value_list = []
+      array_rep.shift.each do |entry_array_rep|
+        entry = SML::ValueEntry.construct(entry_array_rep)
+        return nil if entry.nil?
+        value_list << entry
+      end
+      period_signature = array_rep.shift
+
+      return nil if val_time.nil?
+      return SML::ProfileObjectPeriodEntry.new(val_time, status, value_list, period_signature)
+    end
+    def to_a
+      value_list_array = []
+      value_list.each do |entry|
+        value_list_array << entry.to_a
+      end
+
+      result = [] << val_time.to_a << status
+      result << :uint64 unless status.nil?
+      return result << value_list_array << period_signature
+    end
+
+  end
+
+end