npn47_iso8583 0.1.5.a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4490ebe6f888fd296deba7834184d8ec4301ad49
+  data.tar.gz: 90f4dba0b5e7f3272dbac6e82472d3067223661c
+SHA512:
+  metadata.gz: 5c0880e8ae9b03c7664fca0907199e206182e07b3e64d83a1cb1333a17f7d7b306d05a769095f209aa7ffb8809bcd3b3a371ec4a941e92be5108f4b8d8e9a492
+  data.tar.gz: 4a17f409d7eeb87e82b2c8f6a5393b7dec64a108c3139278e56612838168ffd71eb3f86fdb50d50631de8094f2007ca2002929d34aa14e76bcdafc272477931d

data/lib/8583.rb

@@ -0,0 +1,5 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# DEPRECATED
+require 'iso8583'

data/lib/iso8583/berlin.rb

@@ -0,0 +1,82 @@
+# Copyright 2009 by Tim Becker (tim.becker@kuriostaet.de)
+# MIT License, for details, see the LICENSE file accompaning
+# this distribution
+
+require 'lib/iso8583'
+
+
+# Example of a protocol specification based on:
+# http://www.berlin-group.org/documents/BG_Authorisation_3.0.pdf
+# The Berlin Groups Authorisation Interface specification.
+# No gurantees are made that this is an accurate implemenation.
+# It currently serves as an example only.
+
+module ISO8583
+
+  class BerlinMessage < Message
+    mti_format N, :length => 4
+    mti 1100, "Authorization Request Acquirer Gateway"
+    mti 1110, "Authorization Request Response Issuer Gateway"
+    mti 1420, "Reversal Advice Acquirer Gateway" 
+    mti 1421, "Reversal Advice Repeat Acquirer Gateway" 
+    mti 1430, "Reversal Advice Response Issuer Gateway" 
+    mti 1804, "Network Management Request Acquirer Gateway or Issuer Gateway"
+    mti 1814, "Network Management Request Response Issuer Gateway or Acquirer Gateway"
+
+    bmp  2, "Primary Account Number (PAN)",               LLVAR_N,   :max    => 19
+    bmp  3,  "Processing Code",                           N,         :length =>  6
+    bmp  4,  "Amount (Transaction)",                      N,         :length => 12
+    bmp  6,  "Amount, Cardholder Billing" ,               N,         :length => 12
+    bmp  7,  "Date and Time, Transmission"  ,             MMDDhhmmss
+    bmp 10, "Conversion Rate, Cardholder Billing",        N,         :length =>  8
+    bmp 11, "System Trace Audit Number (STAN)",           N,         :length =>  6
+    bmp 12, "Date and Time, Local Transaction",           YYMMDDhhmmss
+    bmp 14, "Date, Expiration",                           YYMM
+    bmp 22, "POS Data Code",                              AN,        :length => 12
+    bmp 23, "Card Sequence Number",                       N,         :length =>  3
+    bmp 24, "Function Code",                              N,         :length =>  3
+    bmp 25, "Message Reason Code",                        N,         :length =>  4
+    bmp 26, "Card Acceptor Business Code",                N,         :length =>  4
+    bmp 30, "Amounts, Original",                          N,         :length => 24
+    bmp 32, "Acquiring Institution Identification Code",  LLVAR_N,   :max    => 11
+    bmp 35, "Track 2 Data",                               LLVAR_Z,   :max    => 37
+    bmp 37, "Retrieval Reference Number",                 ANP,       :length => 12
+    bmp 38, "Approval Code",                              ANP,       :length =>  6
+    bmp 39, "Action Code",                                N,         :length =>  3
+    bmp 41, "Card Acceptor Terminal Identification",      ANS,       :length =>  8
+    bmp 42, "Card Acceptor Identification Code",          ANS,       :length => 15
+    bmp 43, "Card Acceptor Name/Location",                LLVAR_ANS, :max    => 56
+    bmp 49, "Currency Code, Transaction",                 N,         :length =>  3
+    bmp 51, "Currency Code, Cardholder Billing",          N,         :length =>  3
+    bmp 52, "Personal Identification Number (PIN) Data",  B,         :length =>  8
+    bmp 53, "Security Related Control Information",       LLVAR_B,   :max    => 48
+    bmp 54, "Amounts, Additional",                        LLLVAR_ANS,:max    => 40
+
+    bmp 55, "Integrated Circuit Card (ICC) System Related Data", LLLVAR_B,   :max    => 255
+    bmp 56, "Original Data Elements",                            LLVAR_N,    :max    => 35
+    bmp 58, "Authorizing Agent Institution Identification Code", LLVAR_N,    :max    => 11
+    bmp 59, "Additional Data - Private",                         LLLVAR_ANS, :max    => 67
+    bmp 64, "Message Authentication Code (MAC) Field",           B,          :length => 8
+    
+    bmp_alias  2, :pan
+    bmp_alias  3, :proc_code
+    bmp_alias  4, :amount
+    bmp_alias 12, :exp_date
+  end
+
+end
+
+if __FILE__==$0
+  mes = ISO8583::BerlinMessage.new
+  mes.mti = 1110
+  mes[2] = 474747474747
+  mes["Processing Code"] = "123456"
+
+  pan = mes["Primary Account Number (PAN)"]
+  #mes.pan = 47474747474747
+
+  #puts mes.pan
+  puts mes.to_b
+  puts mes.to_s
+  #mes2 = BerlinMessage.parse input
+end

data/lib/iso8583/bitmap.rb

@@ -0,0 +1,117 @@
+# Copyright 2009 by Tim Becker (tim.becker@kuriostaet.de)
+# MIT License, for details, see the LICENSE file accompaning
+# this distribution
+
+module ISO8583
+
+  # This class constructs an object for handling bitmaps
+  # with which ISO8583 messages typically begin.
+  # Bitmaps are either 8 or 16 bytes long, an extended length
+  # bitmap is indicated by the first bit being set.
+  # In all likelyhood, you won't be using this class much, it's used
+  # transparently by the Message class.
+  class Bitmap
+
+    # create a new Bitmap object. In case an iso message
+    # is passed in, that messages bitmap will be parsed. If
+    # not, this initializes and empty bitmap.
+    def initialize(message = nil)
+      @bmp = Array.new(128, false)
+      if !message
+
+      else
+        initialize_from_message message
+      end
+    end
+    
+    # yield once with the number of each set field.
+    def each #:yields: each bit set in the bitmap.
+      @bmp.each_with_index {|set, i| yield i+1 if set}
+    end
+    
+    # Returns whether the bit is set or not.
+    def [](i)
+      @bmp[i-1]
+    end
+
+    # Set the bit to the indicated value. Only `true` sets the
+    # bit, any other value unsets it.
+    def []=(i, value)
+      if i > 128 
+        raise ISO8583Exception.new("Bits > 128 are not permitted.")
+      elsif i < 2
+        raise ISO8583Exception.new("Bits < 2 are not permitted (continutation bit is set automatically)")
+      end
+      @bmp[i-1] = (value == true)
+    end
+
+    # Sets bit #i
+    def set(i)
+      self[i] = true
+    end
+    
+    # Unsets bit #i
+    def unset(i)
+      self[i] = false
+    end
+
+    # Generate the bytes representing this bitmap.
+    def to_bytes
+      arr = [self.to_s]
+      # tricky and ugly, setting bit[1] only when generating to_s...
+      count = self[1] ? 128 : 64
+      arr.pack("B#{count}")
+    end
+    alias_method :to_b, :to_bytes
+
+    # Generate a String representation of this bitmap in the form:
+    #	01001100110000011010110110010100100110011000001101011011001010
+    def to_s
+      #check whether any `high` bits are set
+      @bmp[0] = false
+      65.upto(128) {|i|
+        if self[i]
+          # if so, set continuation bit
+          @bmp[0] = true
+          break
+        end
+      }
+      str = ""
+      1.upto(self[1] ? 128 : 64) {|i|
+        str << (self[i] ? "1" : "0")
+      }
+      str
+    end
+
+
+    private
+
+    def initialize_from_message(message)
+      bmp = message.unpack("B64")[0]
+      if bmp[0,1] == "1"
+        bmp = message.unpack("B128")[0]
+      end
+
+      0.upto(bmp.length-1) do |i|
+        @bmp[i] = (bmp[i,1] == "1")
+      end
+    end
+
+    class << self
+      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
+      # after the bitmap is taken away.
+      def parse(str)
+        bmp  = Bitmap.new(str)
+        rest = bmp[1] ? str[16, str.length] : str[8, str.length]
+        [ bmp, rest ]
+      end
+    end
+    
+  end
+end
+
+if __FILE__==$0
+  mp = ISO8583::Bitmap.new
+  20.step(128,7) {|i| mp.set(i)}
+  print mp.to_bytes
+end

data/lib/iso8583/codec.rb

@@ -0,0 +1,196 @@
+# Copyright 2009 by Tim Becker (tim.becker@kuriostaet.de)
+# MIT License, for details, see the LICENSE file accompaning
+# this distribution
+
+require 'date'
+
+module ISO8583
+
+  # Codec provides functionality to encode and decode values, codecs are
+  # used internally by Field instances in order to do character conversions
+  # and checking for proper values.
+  # Although they are used internally, you will probably need to write
+  # your own Codec sooner or later. The codecs used by Field instances are
+  # typically instances of Codec, it may or may not be usefull to subclass
+  # Codec.
+  # 
+  # Say, for example, a text field needs to be encoded in EBCDIC in the
+  # message, this is how a corresponding codec would be constructed:
+  #
+  #    EBCDIC_Codec = Codec.new
+  #    EBCDIC_Codec.encoder = lambda {|ascii_str|
+  #       raise ISO8583Exception.new("String (#{ascii_str})not valid!") unless =~ /someregexp/
+  #       ascii2ebcdic ascii_str  # implementing ascii_str is left as an excercise
+  #    }
+  #    EBCDIC_Codec.decode = lambda {|ebcdic_str|
+  #       # you may or may not want to raise exceptions at this point ....
+  #       # strip removes any padding...
+  #       ebcdic2ascii(ebcdic_str).strip
+  #    }
+  #
+  # This instance of Codec would then be used be the corresponding Field
+  # encoder/decoder, which may look similar to this:
+  #
+  #    EBCDIC         = Field.new
+  #    EBCDIC.codec   = EBCDIC_Codec
+  #    EBCDIC.padding = PADDING_LEFT_JUSTIFIED_SPACES
+  #
+  # Notice there is a bit of inconsistancy: the padding is added by the
+  # field, but removed by the codec. I would like to find a better
+  # solution to this...
+  #
+  # See also: Field, link:files/lib/fields_rb.html
+  #
+  # The following codecs are already implemented:
+  # [+ASCII_Number+]      encodes either a Number or String representation of 
+  #                       a number to the ASCII represenation of the number, 
+  #                       decodes ASCII  numerals to a number
+  # [+A_Codec+]           passes through ASCII string checking they conform to [A-Za-z]
+  #                       during encoding, no validity check during decoding. 
+  # [+AN_Codec+]          passes through ASCII string checking they conform to [A-Za-z0-9]
+  #                       during encoding, no validity check during decoding. 
+  # [+ANP_Codec+]         passes through ASCII string checking they conform to [A-Za-z0-9 ] 
+  #                       during encoding, no validity check during decoding. 
+  # [+ANS_Codec+]         passes through ASCII string checking they conform to [\x20-\x7E]
+  #                       during encoding, no validity check during decoding.
+  # [+Null_Codec+]        passes anything along untouched.
+  # [<tt>Track2</tt>]     rudimentary check that string conforms to Track2
+  # [+MMDDhhmmssCodec+]   encodes Time, Datetime or String to the described date format, checking 
+  #                       that it is a valid date. Decodes to a DateTime instance, decoding and 
+  #                       encoding perform validity checks!
+  # [+YYMMDDhhmmssCodec+] encodes Time, Datetime or String to the described date format, checking 
+  #                       that it is a valid date. Decodes to a DateTime instance, decoding and 
+  #                       encoding perform validity checks!
+  # [+YYMMCodec+]         encodes Time, Datetime or String to the described date format (exp date), 
+  #                       checking that it is a valid date. Decodes to a DateTime instance, decoding
+  #                       and encoding perform validity checks!
+  #
+  class Codec
+    attr_accessor :encoder
+    attr_accessor :decoder
+
+    def decode(raw)
+      decoder.call(raw)
+    end
+
+    # length is either a fixnum or a lenth encoder.
+    def encode(value)
+      encoder.call(value)
+    end
+  end
+
+  # ASCII_Number
+  ASCII_Number = Codec.new
+  ASCII_Number.encoder= lambda{|num|
+    enc = num.to_s
+    raise ISO8583Exception.new("Invalid value: #{enc} must be numeric!") unless enc =~ /^[0-9]*$/
+    enc
+  }
+
+  ASCII_Number.decoder = lambda{|raw|
+    raw.to_i
+  }
+
+  PASS_THROUGH_DECODER = lambda{|str|
+    str.strip # remove padding
+  }
+
+  # Takes a number or str representation of a number and BCD encodes it, e.g.
+  # "1234" => "\x12\x34"
+  # 3456   => "\x34\x56"
+  #
+  # right justified with null ... (correct to do this? almost certainly not...)
+  Packed_Number = Codec.new
+  Packed_Number.encoder = lambda { |val|
+    val = val.to_s
+    val = val.length % 2 == 0 ? val : "0"+val
+    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9]*$/
+    [val].pack("H*")
+  }
+  Packed_Number.decoder = lambda{|encoded|
+    d = encoded.unpack("H*")[0].to_i
+  }
+
+  A_Codec = Codec.new
+  A_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-z]") unless str =~ /^[A-Za-z]*$/
+    str
+  }
+  A_Codec.decoder = PASS_THROUGH_DECODER
+
+  AN_Codec = Codec.new
+  AN_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-y0-9]") unless str =~ /^[A-Za-z0-9]*$/
+    str
+  }
+  AN_Codec.decoder = PASS_THROUGH_DECODER
+
+  ANP_Codec = Codec.new
+  ANP_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [A-Za-y0-9 ]") unless str =~ /^[A-Za-z0-9 ]*$/
+    str
+  }
+  ANP_Codec.decoder = PASS_THROUGH_DECODER
+
+  ANS_Codec = Codec.new
+  ANS_Codec.encoder = lambda{|str|
+    raise ISO8583Exception.new("Invalid value: #{str} must be [\x20-\x7E]") unless str =~ /^[\x20-\x7E]*$/
+    str
+  }
+  ANS_Codec.decoder = PASS_THROUGH_DECODER
+
+  Null_Codec = Codec.new
+  Null_Codec.encoder = lambda {|str|
+    str
+  }
+  Null_Codec.decoder = lambda {|str|
+    str.gsub(/\000*$/, '')
+  } 
+
+  Track2 = Codec.new
+  Track2.encoder = lambda{|track2|
+    #SS | PAN | FS | Expiration Date | Service Code | Discretionary Data | ES | LRC
+    # SS = ;
+    # PAN = up to 19 digits (at least 9?)
+    # FS = '='
+    # Exp Date = YYMM
+    # SC: 3 digits or =
+    # ES = ?
+    # lrc : 1byte
+    raise ISO8583Exception.new("Invalid Track2 data: #{track2}") unless track2 =~ /^;*(\d{9,19})=(.*)\?.$/
+    track2
+  }
+  Track2.decoder = PASS_THROUGH_DECODER
+
+  def self._date_codec(fmt) 
+    c = Codec.new
+    c.encoder = lambda {|date|
+      enc = case date
+            when DateTime, Date, Time
+              date.strftime(fmt)
+            when String
+              begin
+                dt = DateTime.strptime(date, fmt)
+                dt.strftime(fmt)
+              rescue
+                raise ISO8583Exception.new("Invalid format encoding: #{date}, must be #{fmt}.")
+              end
+            else  
+              raise ISO8583Exception.new("Don't know how to encode: #{date.class} to a time.")
+            end
+      return enc
+    }
+    c.decoder = lambda {|str|
+      begin
+        DateTime.strptime(str, fmt)
+      rescue
+        raise ISO8583Exception.new("Invalid format decoding: #{str}, must be #{fmt}.")
+      end
+    }
+
+    c
+  end
+
+  YYYYMMDDHHcodec   = _date_codec("%Y%m%d%H")
+  YYYYMMDDHH24MISScodec = _date_codec("YYYYMMDDHH24MISScodec")
+end

data/lib/iso8583/exception.rb

@@ -0,0 +1,4 @@
+module ISO8583
+  class ISO8583Exception < Exception; end
+  class ISO8583ParseException < ISO8583Exception; end
+end

data/lib/iso8583/field.rb

@@ -0,0 +1,90 @@
+module ISO8583
+
+  class Field
+    # may either be some other Field in which the length is encoded or a Fixnum for
+    # fixed length fields. Length should always be the length of the *encoded* value.
+    # A 6 digit BCD field will require a length 3, as will a 5 digit BCD field.
+    # The subclass BCDField handles this to keep things consistant.
+    attr_accessor :length
+    attr_accessor :codec
+    attr_accessor :padding
+    attr_accessor :max
+
+    attr_writer   :name
+    attr_accessor :bmp
+
+    def name
+      "BMP #{bmp}: #{@name}"
+    end
+
+    def parse(raw)
+      len, raw = case length
+                 when Fixnum
+                   [length, raw]
+                 when Field
+                   length.parse(raw)
+                 else
+                   raise ISO8583Exception.new("Cannot determine the length of '#{name}' field")
+                 end
+
+      raw_value = raw[0,len]
+      
+      # make sure we have enough data ...
+      if raw_value.length != len
+        mes = "Field has incorrect length! field: #{raw_value} len/expected: #{raw_value.length}/#{len}"
+        raise ISO8583ParseException.new(mes)
+      end
+
+      rest = raw[len, raw.length]
+      begin
+        real_value = codec.decode(raw_value)
+      rescue
+        raise ISO8583ParseException.new($!.message+" (#{name})")
+      end
+
+      [ real_value, rest ]
+    end
+    
+
+    # Encoding needs to consider length representation, the actual encoding (such as charset or BCD) 
+    # and padding. 
+    # The order may be important! This impl calls codec.encode and then pads, in case you need the other 
+    # special treatment, you may need to override this method alltogether.
+    # In other cases, the padding has to be implemented by the codec, such as BCD with an odd number of nibbles.
+    def encode(value)
+      encoded_value = codec.encode(value) 
+
+      if padding
+        if padding.arity == 1
+          encoded_value = padding.call(encoded_value)
+        elsif padding.arity == 2
+          encoded_value = padding.call(encoded_value, length)
+        end
+      end
+
+      len_str = case length
+                when Fixnum
+                  raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
+                  raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
+                  "" 
+                when Field
+                  raise ISO8583Exception.new("Max lenth exceeded: #{value}, max: #{max}") if max && encoded_value.length > max
+                  length.encode(encoded_value.length)
+                else
+                  raise ISO8583Exception.new("Invalid length (#{length}) for '#{name}' field")
+                end
+
+      len_str + encoded_value
+    end
+  end
+
+  class BCDField < Field
+    # This corrects the length for BCD fields, as their encoded length is half (+ parity) of the
+    # content length. E.g. 123 (length = 3) encodes to "\x01\x23" (length 2)
+    def length
+      _length = super
+      (_length % 2) != 0 ? (_length / 2) + 1 : _length / 2
+    end
+  end
+
+end

data/lib/iso8583/fields.rb

@@ -0,0 +1,75 @@
+module ISO8583
+
+  # This file contains a number of preinstantiated Field definitions. You
+  # will probably need to create own fields in your implementation, please
+  # see Field and Codec for further discussion on how to do this.
+  # The fields currently available are those necessary to implement the 
+  # BankAway spec.
+  #
+  # The following field types are available:
+  #
+  # [LLVAR_N]      two byte variable length ASCII numeral, payload ASCII numerals
+  # [LLVAR_ANS]    two byte variable length ASCII numeral, payload ASCII
+  # [ANS]            fixed length letters, represented in ASCII
+  # [N]            fixed lengh numerals, repesented in ASCII, padding right justified using zeros
+  # [B]            binary data, padding left using nulls (0x00)
+  # [YYYYMMDDHH]   Date, formatted as described in ASCII numerals
+  # [YYYYMMDDHH24MISS] Date, formatted as named in ASCII numerals
+
+  # Special form to de/encode variable length indicators, two bytes ASCII numerals 
+  LL         = Field.new
+  LL.name    = "LL"
+  LL.length  = 2
+  LL.codec   = ASCII_Number
+  LL.padding = lambda {|value|
+    sprintf("%02d", value)
+  }
+
+  # Two byte variable length ASCII numeral, payload ASCII numerals
+  LLVAR_N        = Field.new
+  LLVAR_N.length = LL
+  LLVAR_N.codec  = ASCII_Number
+
+  # Two byte variable length alpha-numeric with special characters.
+  LLVAR_ANS      = Field.new
+  LLVAR_ANS.length = LL
+  LLVAR_ANS.codec = ANS_Codec
+  LLVAR_ANS.padding = PADDING_LEFT_JUSTIFIED_SPACES
+
+  # Two byte variable length ASCII letters
+  # Fixed lengh numerals, repesented in ASCII, padding right justified using zeros
+  N = Field.new
+  N.codec = ASCII_Number
+  N.padding = lambda {|val, len|
+    sprintf("%0#{len}d", val)
+  }
+
+  PADDING_LEFT_JUSTIFIED_SPACES = lambda {|val, len|
+    sprintf "%-#{len}s", val
+  }
+
+  # Fixed length ASCII letters [A-Za-z]
+  ANS = Field.new
+  ANS.codec = ANS_Codec
+
+  # Binary data, padding left using nulls (0x00)
+  B = Field.new
+  B.codec = Null_Codec
+  B.padding = lambda {|val, len|
+    while val.length < len
+      val = val + "\000"
+    end
+    val
+  }
+
+  # Date, formatted as described in Bankaway
+  YYYYMMDDHH        = Field.new
+  YYYYMMDDHH.codec  = YYYYMMDDHHcodec
+  YYYYMMDDHH.length = 8
+
+  #Date, formatted as described in Bankaway
+  YYYYMMDDHH24MISS        = Field.new
+  YYYYMMDDHH24MISS.codec  = YYYYMMDDHH24MISScodec
+  YYYYMMDDHH24MISS.length = 14
+
+end