ruby-sml 0.2

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011, Prof. MAAD
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/ruby-sml.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'ruby-sml/transport-binary'
+require 'ruby-sml/encoding-binary'
+
+require 'ruby-sml/sml-attention'
+require 'ruby-sml/sml-file'
+require 'ruby-sml/sml-getlist'
+require 'ruby-sml/sml-getprocparameter'
+require 'ruby-sml/sml-getprofilelist'
+require 'ruby-sml/sml-getprofilepack'
+require 'ruby-sml/sml-listentry'
+require 'ruby-sml/sml-messagebody'
+require 'ruby-sml/sml-message'
+require 'ruby-sml/sml-periodentry'
+require 'ruby-sml/sml-procparametervalue'
+require 'ruby-sml/sml-profileobjectheaderentry'
+require 'ruby-sml/sml-profileobjectperiodentry'
+require 'ruby-sml/sml-publicclose'
+require 'ruby-sml/sml-publicopen'
+require 'ruby-sml/sml-setprocparameter'
+require 'ruby-sml/sml-time'
+require 'ruby-sml/sml-treepath'
+require 'ruby-sml/sml-tree'
+require 'ruby-sml/sml-tupelentry'
+require 'ruby-sml/sml-valueentry'
+
+require 'ruby-sml/units'
+require 'ruby-sml/obis'
+require 'ruby-sml/helpers'

data/lib/ruby-sml/crc16.rb

@@ -0,0 +1,47 @@
+# taken from http://www.hadermann.be/blog/32/ruby-crc16-implementation/
+
+module CRC16
+  
+  def self.crc16(buf, crc=0xffff)
+    buf.each_byte{|x| crc = (crc >> 8) ^ CCITT_16[(crc ^ x) & 0xff]}
+    return crc
+  end
+  
+  private
+  
+  CCITT_16 = [             
+              0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 
+              0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 
+              0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 
+              0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 
+              0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 
+              0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 
+              0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 
+              0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 
+              0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 
+              0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 
+              0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 
+              0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 
+              0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 
+              0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 
+              0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 
+              0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 
+              0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 
+              0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 
+              0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 
+              0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 
+              0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 
+              0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 
+              0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 
+              0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 
+              0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 
+              0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 
+              0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 
+              0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 
+              0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 
+              0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 
+              0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 
+              0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
+             ]
+
+end

data/lib/ruby-sml/encoding-binary.rb

@@ -0,0 +1,262 @@
+module SML
+
+  class BinaryEncoding
+
+    def self.decode_file(file)
+      source = String.new(file)
+      sml_file = []
+      position = 0
+      
+      list_length = []
+      list_depth = 0
+      parent = []
+      current_list = sml_file
+
+      while not source.empty?
+        type = nil
+        value = nil
+        header_length = 0
+        length = 0
+        tl_byte = source.slice!(0,1).unpack('C')[0]
+        break if tl_byte.nil?
+        
+        # check for special cases
+        if tl_byte == 0x00
+#           puts "end of message"
+#           puts "--------------"
+          list_length = []
+          list_depth = 0
+
+          current_list << :end_of_message
+
+          current_list = sml_file
+          parent = []
+
+          next
+        end
+        if tl_byte == 0x01
+#           list_depth.times do print "\t" end
+#           puts "?"
+
+          current_list << nil
+
+          if not list_length.empty?
+            l = list_length.pop
+            l -= 1
+            list_length.push(l)
+          end
+          while list_length.last == 0
+            list_length.pop
+            list_depth -= 1
+            current_list = parent.pop
+          end
+
+          next
+        end
+
+        # parse tl field   
+        type_bits = (tl_byte & 0b01110000) >> 4
+        case type_bits
+        when 0b000
+          type = :string
+        when 0b100
+          type = :bool
+        when 0b101
+          type = :signed
+        when 0b110
+          type = :unsigned
+        when 0b111
+          type = :list
+        else
+          type = nil
+#          puts "type: unknown (0b#{type_bits.to_s(2)})"
+          exit
+        end
+
+        list_depth.times do
+#           print "\t"
+        end
+
+        if not list_length.empty?
+          l = list_length.pop
+          l -= 1
+          list_length.push(l)
+        end
+        
+        length = tl_byte & 0b00001111
+        header_length += 1
+        while (tl_byte & 0b10000000) != 0
+          length = length << 4
+          tl_byte = source.slice!(0,1).unpack('C')[0]
+          length |= (tl_byte & 0b00001111)
+          header_length += 1
+        end
+        
+        length -= header_length unless type == :list
+ 
+        # we know what to expect, lets get it
+        case type
+        when :string
+          value = source.slice!(0,length)
+#           puts "string(#{length}): #{value}"
+          current_list << value
+        when :bool
+          value = source.slice!(0,1).unpack('C')[0]
+          if value == 0
+            value = false
+          else
+            value = true
+          end
+#           puts "bool: #{value}"
+          current_list << value << :bool
+        when :signed
+          value = 0
+          bytes_left = length
+          while bytes_left > 0
+            byte = source.slice!(0,1).unpack('C')[0]
+            value = value << 8
+            value |= byte
+            bytes_left -= 1
+          end
+          value = to_signed(value, length*8)
+#           puts "int#{length*8}: #{value}"
+          current_list << value << "int#{length*8}".to_sym
+        when :unsigned
+          value = 0
+          bytes_left = length
+          while bytes_left > 0
+            byte = source.slice!(0,1).unpack('C')[0]
+            value = value << 8
+            value |= byte
+            bytes_left -= 1
+          end
+#           puts "uint#{length*8}: #{value}"
+          current_list << value << "uint#{length*8}".to_sym
+        when :list
+#           puts "list: #{length} elements"
+          list_depth += 1
+          list_length.push(length)
+          new_list = []
+          current_list << new_list
+          parent.push(current_list)
+          current_list = new_list
+        end
+
+        while list_length.last == 0
+          list_length.pop
+          list_depth -= 1
+          current_list = parent.pop
+        end
+      end
+
+      return sml_file
+    end
+
+    def self.encode_file(file)
+      result = String.new
+
+      array_rep = Array.new(file)
+      array_rep.each do |message|
+        result << encode_value(message, :array) << 0x00
+      end
+
+      return result
+    end
+
+    def self.encode_value(value, type)
+      result = String.new
+
+      case type
+      when :array
+        entries_with_type = []
+        while not value.empty?
+          entry = value.shift
+          type = case entry
+                 when Array
+                   :array
+                 when String
+                   :string
+                 when NilClass
+                   :nil
+                 when Fixnum
+                   value.shift
+                 end
+
+          entries_with_type << [entry, type]
+        end
+        
+        tl_bytes = encode_length(entries_with_type.length, false)
+        tl_bytes[0] = 0b01110000 + tl_bytes[0]
+        tl_bytes.each do |byte|
+          result << byte
+        end
+        entries_with_type.each do |entry, type|
+          result << encode_value(entry,type)
+        end
+      when :string
+        tl_bytes = encode_length(value.length, true)
+        tl_bytes[0] = 0b00000000 + tl_bytes[0]
+        tl_bytes.each do |byte|
+          result << byte
+        end
+        result << value
+      when :int8
+        result << 0x52 << [value].pack('c')
+      when :int16
+        result << 0x53
+        result << [value].pack('s').reverse
+      when :int32
+        result << 0x55
+        result << [value].pack('l').reverse
+      when :int64
+        result << 0x59
+        result << [value].pack('q').reverse
+      when :uint8
+        result << 0x62 << [value].pack('C')
+      when :uint16
+        result << 0x63 << [value].pack('n')
+      when :uint32
+        result << 0x65 << [value].pack('N')
+      when :uint64
+        result << 0x69 << [value].pack('Q').reverse
+      when :bool
+        if value == 0
+          result << 0x42 << 0x00
+        else          
+          result << 0x42 << 0x01
+        end
+      when :nil
+        result << 0x01
+      end
+      
+      return result
+    end
+    def self.encode_length(length, include_header)
+      result = []
+
+      header_length = 1
+      while (length+(include_header ? header_length : 0)) >= 2**(4*header_length)
+        header_length += 1        
+      end
+      total_length = length + (include_header ? header_length : 0)
+
+      while header_length > 0
+        mask = 0xf << (header_length-1)*4
+        if header_length > 1
+          result << (0b10000000 | ((total_length & mask) >> (header_length-1)*4))
+        else
+          result << ((total_length & mask) >> (header_length-1)*4)          
+        end
+        header_length -= 1
+      end
+
+      return result
+    end
+
+    def self.to_signed(int, bits)  
+      mask = (1 << (bits - 1))
+      return (int & ~mask) - (int & mask)
+    end
+   
+  end
+end

data/lib/ruby-sml/helpers.rb

@@ -0,0 +1,58 @@
+require 'ruby-sml/sml-listentry'
+require 'ruby-sml/sml-periodentry'
+require 'ruby-sml/sml-tree'
+
+require 'ruby-sml/obis.rb'
+
+module SML
+
+  module Helpers
+
+    def self.hex_to_s(hex)
+      result = ""
+      hex.each_byte do |byte|
+        result << byte.to_s(16) << ":"
+      end
+      result.slice!(-1)
+
+      return result
+    end
+
+    def self.print_entry(entry)
+      return unless (entry.class == SML::ListEntry or entry.class == SML::PeriodEntry)
+
+      name = entry.name
+      value = entry.value
+      scaler = entry.scaler
+      unit = entry.unit
+
+      name = SML::OBIS::resolve(name)
+      value = value * (10**entry.scaler) if ((value.class == Fixnum) and not (scaler.nil?))
+      value = value.to_f if (value.class == Fixnum)
+      unit = SML::Units[unit]["unit"] unless (unit.nil? or SML::Units[unit].nil?)
+
+      puts "#{name}: #{value} #{unit}"
+    end
+
+    def self.print_tree(tree)
+      return unless tree.class == SML::Tree
+      print_tree_internal(tree, 0)
+    end
+    def self.print_tree_internal(tree, level)
+      name = tree.parameter_name
+      name = SML::OBIS::resolve(name)
+
+      if level > 0
+        (level*4).times do print " " end
+        print "|-> " unless level == 0
+      end
+      puts "#{name} : #{tree.parameter_value}"
+
+      tree.child_list.each do |child|
+        print_tree_internal(child, level+1)
+      end
+    end
+    
+  end
+
+end

data/lib/ruby-sml/nilclass-mixin.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def to_a
+    return nil
+  end
+end

data/lib/ruby-sml/obis.rb

@@ -0,0 +1,139 @@
+require 'ruby-sml/helpers'
+
+module SML
+
+  module OBIS
+
+    def self.resolve(obis)
+      if SML::OBIS::Lookup[obis].nil?
+        return SML::Helpers::hex_to_s(obis)
+      else
+        return SML::OBIS::Lookup[obis]
+      end
+    end
+
+    Lookup = {}
+
+    Lookup["\x81\x81\xc7\x82\x01\xff"] = "Device Properties Root"
+    Lookup["\x81\x81\xc7\x82\x02\xff"] = "Device Class"
+    Lookup["\x81\x81\xc7\x82\x03\xff"] = "Manufacturer"
+    Lookup["\x81\x81\xc7\x82\x05\xff"] = "Public Key"
+
+    Lookup["\x01\x00\x00\x00\x09\xff"] = "Device ID"
+    Lookup["\x01\x00\x00\x02\x00\xff"] = "Firmware Version"
+    Lookup["\x01\x00\x00\x02\x02\xff"] = "Control Program Nr"
+
+    Lookup["\x81\x81\xc7\x89\xe1\xff"] = "Event Log"
+    Lookup["\x81\x81\xc7\x89\xe2\xff"] = "Event ID"
+
+    Lookup["\x81\x81\xc7\x8c\x01\xff"] = "INFO interface active"
+    Lookup["\x81\x81\xc7\x8c\x02\xff"] = "EDL40 mode"
+    Lookup["\x81\x81\xc7\x8c\x03\xff"] = "Delete old usage values"
+    Lookup["\x81\x81\xc7\x8c\x04\xff"] = "Display old usage values"
+    Lookup["\x81\x81\xc7\x8c\x06\xff"] = "Display Text on INFO display"
+    Lookup["\x81\x81\xc7\x8c\x07\xff"] = "Displayed Tariff Registers Bitmask"
+    Lookup["\x81\x81\xc7\x8c\x08\xff"] = "Advanced Manufacturer Dataset on MSB"
+    Lookup["\x81\x81\xc7\x8c\x09\xff"] = "History Delete via Blinken- Interface enabled"
+    Lookup["\x81\x81\xc7\x8c\x0a\xff"] = "Display PIN Protected enabled"
+    Lookup["\x81\x81\xc7\x8c\x0b\xff"] = "Display PIN Code"
+    Lookup["\x81\x81\xc7\x8c\x0c\xff"] = "Number of Manipulation Attempts"
+    Lookup["\x81\x81\xc7\x8c\x0d\xff"] = "Automatic PIN Protected after Timeout enabled"
+
+    Lookup["\x01\x00\x01\x08\x00\xff"] = "Current Value - Overall Register"
+    Lookup["\x01\x00\x01\x08\x01\xff"] = "Current Value - Register Tariff 1"
+    Lookup["\x01\x00\x01\x08\x02\xff"] = "Current Value - Register Tariff 2"
+    Lookup["\x01\x00\x01\x11\x00\xff"] = "Last signed overall Register Value"
+    Lookup["\x01\x00\x0f\x07\x00\xff"] = "Current Meter Reading"
+
+    Lookup["\x01\x00\x01\x08\x00\x60"] = "Usage History - last Day"
+    Lookup["\x01\x00\x01\x08\x00\x61"] = "Usage History - last 7 Days"
+    Lookup["\x01\x00\x01\x08\x00\x62"] = "Usage History - last 30 Days"
+    Lookup["\x01\x00\x01\x08\x00\x63"] = "Usage History - last 365 Days"
+
+    Lookup["\x01\x00\x00\x09\x0b\x00"] = "Current Time"
+    Lookup["\x01\x00\x00\x09\x0b\x01"] = "Former Time"
+    Lookup["\x00\x00\x60\x08\x00\xff"] = "Seconds counter"
+    Lookup["\x81\x00\x00\x09\x0b\x01"] = "Timezone Offset"
+
+    Lookup["\x00\x00\x60\x0e\x00\xff"] = "Selected Tariff"
+
+    Lookup["\x81\x81\x27\x32\x07\x01"] = "Log Entry Period"
+    
+    Lookup["\x81\x00\x60\x05\x00\x00"] = "Status word"
+
+    Lookup["\x81\x01\x00\x00\x01\x00"] = "Interface name"
+    Lookup["\x81\x03\x00\x00\x01\x00"] = "Interface name"
+
+    Lookup["\x81\x81\x81\x60\xff\xff"] = "Rights and Roles Root"
+    Lookup["\x81\x81\x81\x60\x01\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x02\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x03\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x04\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x05\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x06\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x07\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x08\xff"] = "Role"
+    Lookup["\x81\x81\x81\x60\x01\x01"] = "Access Right" # actualle all of \x81\x81\x81\x60\x0[1-8]\x[01-fe]
+    Lookup["\x81\x81\x81\x61\xff\xff"] = "Username"
+    Lookup["\x81\x81\x81\x62\xff\xff"] = "Password"
+    Lookup["\x81\x81\x81\x63\xff\xff"] = "Public Key for User Access"
+    Lookup["\x81\x81\x81\x64\x01\x01"] = "ACL for Server ID" # actually all ending with \x01 to \xfe
+
+    Lookup["\x81\x02\x00\x07\x00\xff"] = "Enduser Interface Root"
+    Lookup["\x81\x02\x00\x07\x01\xff"] = "Enduser IP Acquisition Method"
+    Lookup["\x81\x02\x17\x07\x00\x01"] = "Enduser manually assigned IP Address"
+    Lookup["\x81\x02\x17\x07\x01\x01"] = "Enduser manually assigned Network Mask"
+    Lookup["\x81\x02\x00\x07\x02\xff"] = "Enduser DHCP Server active"
+    Lookup["\x81\x02\x00\x07\x02\x01"] = "Enduser DHCP Local Netmask"
+    Lookup["\x81\x02\x00\x07\x02\x02"] = "Enduser DHCP Default Gateway"
+    Lookup["\x81\x02\x00\x07\x02\x03"] = "Enduser DHCP DNS Server"
+    Lookup["\x81\x02\x00\x07\x02\x04"] = "Enduser DHCP IP Pool Start"
+    Lookup["\x81\x02\x00\x07\x02\x05"] = "Enduser DHCP IP Pool End"
+    Lookup["\x81\x02\x00\x07\x10\xff"] = "Enduser Interface Status Root"
+    Lookup["\x81\x02\x17\x07\x00\x00"] = "Enduser Current IP Address"
+
+    Lookup["\x81\x04\x00\x06\x00\xff"] = "WAN Interface Status Root"
+    Lookup["\x81\x04\x00\x00\x01\x00"] = "WAN Interface Name"
+    Lookup["\x81\x04\x00\x02\x00\x00"] = "WAN Interface Firmware Version"
+    Lookup["\x81\x04\x00\x07\x00\xff"] = "WAN Interface Parameter Root"
+    Lookup["\x81\x04\x27\x32\x03\x01"] = "WAN Interface automatic Reboot"
+    Lookup["\x81\x42\x64\x3c\x01\x01"] = "WAN Interface Max. Inter Message Timeout"
+    Lookup["\x81\x42\x64\x3c\x01\x02"] = "WAN Interface Max. Timeout from Close-Request to Open-Response"
+
+    Lookup["\x81\x04\x02\x07\x00\xff"] = "GSM Parameter Root"
+    Lookup["\x81\x04\x00\x32\x01\x01"] = "GSM SIM PIN"
+    Lookup["\x81\x04\x00\x32\x04\x01"] = "GSM Provider Selection Method"
+    Lookup["\x81\x04\x00\x32\x08\x01"] = "GSM Bearer Service Type"
+    Lookup["\x81\x04\x00\x32\x09\x01"] = "GSM Quality of Service"
+    Lookup["\x81\x04\x27\x32\x01\x01"] = "GSM Max. Connection Length"
+    Lookup["\x81\x04\x27\x32\x02\x01"] = "GSM Connection Idle Time"
+    Lookup["\x81\x04\x31\x32\x01\x01"] = "GSM Number of Rings until Call pickup"
+
+    Lookup["\x81\x49\x0d\x06\x00\xff"] = "IPT Status Root"
+    Lookup["\x81\x49\x17\x07\x00\x00"] = "IPT Current Master Target IP Address"
+    Lookup["\x81\x49\x1a\x07\x00\x00"] = "IPT Current Master Target Port"
+    Lookup["\x81\x49\x19\x07\x00\x00"] = "IPT Current Master Source Port"
+    Lookup["\x81\x49\x0d\x07\x00\xff"] = "IPT Parameter Root"
+    Lookup["\x81\x49\x0d\x07\x00\x01"] = "IPT Primary Master Root"
+    Lookup["\x81\x49\x17\x07\x00\x01"] = "IPT Primary Master Target IP Address"
+    Lookup["\x81\x49\x1a\x07\x00\x01"] = "IPT Primary Master Target Port"
+    Lookup["\x81\x49\x19\x07\x00\x01"] = "IPT Primary Master Source Port"
+    Lookup["\x81\x49\x63\x3c\x01\x01"] = "IPT Primary Master Username"
+    Lookup["\x81\x49\x63\x3c\x02\x01"] = "IPT Primary Master Password"
+    Lookup["\x81\x49\x0d\x07\x00\x02"] = "IPT Secondary Master Root"
+    Lookup["\x81\x49\x17\x07\x00\x02"] = "IPT Secondary Master Target IP Address"
+    Lookup["\x81\x49\x1a\x07\x00\x02"] = "IPT Secondary Master Target Port"
+    Lookup["\x81\x49\x19\x07\x00\x02"] = "IPT Secondary Master Source Port"
+    Lookup["\x81\x49\x63\x3c\x01\x02"] = "IPT Secondary Master Username"
+    Lookup["\x81\x49\x63\x3c\x02\x02"] = "IPT Secondary Master Password"
+    Lookup["\x81\x48\x27\x32\x06\x01"] = "IPT Connection Retry Timeout"
+    Lookup["\x81\x48\x31\x32\x02\x01"] = "IPT Max. Connection Retries"
+
+    Lookup["\x81\x04\x00\x33\x01\xff"] = "AT-Hayes-Strings Root"
+    Lookup["\x81\x04\x00\x33\x01\x01"] = "AT-Hayes-String after Modem Power-On, before PIN-Entry"
+    Lookup["\x81\x04\x00\x33\x02\x01"] = "AT-Hayes-String after PIN-Entry"
+    Lookup["\x81\x04\x00\x33\x03\x01"] = "AT-Hayes-String GPRS Initialization"
+
+  end
+
+end