pdu_tools 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: d1b59db9f41bc1d37660c6af01c3d7fda3cc2800
+  data.tar.gz: 64d571e2f9da156852825a43a967171fc107eae7
+SHA512: 
+  metadata.gz: 4b8ec02cc0b4c1fb1eedc474877812cdce0906d61233f1ed5bae8bd47b9943e82f1bd7c9071b4158f33bfe8d12c97a54c101db40926003e102ff5e6dde2b687b
+  data.tar.gz: c337b899ae90c7435a1ff38696861ecdf99fda21db98e8aa7e0c90fbd1133c55dad0777fabb47beef86951c5de0ea854efd6380f3daa8f0080af532532337bd4

data/lib/pdu_tools.rb

@@ -0,0 +1,20 @@
+require 'phone'
+require 'active_support/all'
+
+require_relative './pdu_tools/helpers'
+require_relative './pdu_tools/pdu'
+require_relative './pdu_tools/message_part'
+require_relative './pdu_tools/decoder'
+require_relative './pdu_tools/encoder'
+
+module PDUTools
+  ALPHABETS = {
+      a7bit: '00',
+      a8bit: '01',
+      a16bit: '10'
+  }
+
+  MAX_MESSAGE_LENGTH = 39015
+  MAX_GSM_MESSAGE_7BIT_PART_LENGTH = 152
+  MAX_GSM_MESSAGE_16BIT_PART_LENGTH = 66
+end

data/lib/pdu_tools/decoder.rb

@@ -0,0 +1,197 @@
+
+module PDUTools
+  class Decoder
+    include Helpers
+    # http://read.pudn.com/downloads150/sourcecode/embed/646395/Short%20Message%20in%20PDU%20Encoding.pdf
+    def initialize pdu_hex, direction=:sc_to_ms
+      @pdu_hex = pdu_hex
+      @direction = direction
+    end
+
+    def decode
+      @sca_length = take(2, :integer) * 2                # Service center address length
+      if @sca_length > 0
+        @sca_type = parse_address_type take(2)            # Service center address type
+        @sca = parse_address take(@sca_length - 2), @sca_type          # Service center address
+      end
+      @pdu_type = parse_pdu_type take(2, :binary)   # PDU type octet
+      @message_reference = take(2) if @pdu_type[:mti] == :sms_submit
+      @address_length = take(2, :integer)
+      @address_type = parse_address_type take(2)
+      @address = parse_address take(@address_length), @address_type
+      @pid = take(2)
+      @data_coding_scheme = parse_data_coding_scheme take(2, :binary)
+      @sc_timestamp = parse_7byte_timestamp take(14) if @pdu_type[:mti] == :sms_deliver
+      case @pdu_type[:vpf]
+      when :absolute
+        @validity_period = parse_7byte_timestamp take(14)
+      when :relative
+        @validity_period = parse_validity_period take(2, :integer)
+      end
+      @user_data_length = take(2, :integer)
+      parse_user_data @user_data_length
+
+      MessagePart.new @address, @message, @sc_timestamp, @validity_period, @user_data_header
+    end
+
+    def inspect2
+      r = "<PDUTools::Decoder"
+      r << "PDU: #{@pdu_hex}\n"
+      r << "SCA LENGTH: #{@sca_length}\n"
+      r << "SCA TYPE: #{@sca_type}\n"
+      r << "SCA: #{@sca}\n"
+      r << "PDU TYPE: #{@pdu_type}\n"
+      r << "MESSAGE REFERENCE: #{@message_reference}\n" if @message_reference
+      r << ">"
+      r
+    end
+
+    private
+
+    def take n, format=:string, data=@pdu_hex
+      part = data.slice!(0,n)
+      case format
+      when :string
+        return part
+      when :integer
+        return part.to_i(16)
+      when :binary
+        bytes = n/2
+        return "%0#{bytes*8}b" %  part.to_i(16)
+      end
+    end
+
+    def parse_address_type type
+      case type
+      when "91"
+        :international
+      when "81"
+        :national
+      else
+        raise StandardError, "unknown address type"
+      end
+    end
+
+    def parse_address address, type
+      address = swapped2normal address
+      if type == :international
+        address.prepend "+"
+      end
+      address
+    end
+
+    def parse_pdu_type pdu_type
+      rp = pdu_type.slice!(0,1) == "1"
+      udhi = pdu_type.slice!(0,1) == "1"
+      srr_or_sri = pdu_type.slice!(0,1) == "1"
+      vpf = (case pdu_type.slice!(0,2)
+           when "00", "01"
+             :none
+           when "10"
+             :relative
+           when "11"
+             :absolute
+           end)
+      rd_or_mms = pdu_type.slice!(0,1)
+      mti = pdu_type.slice!(0,2)
+
+      type = { rp: rp, udhi: udhi, vpf: vpf }
+      case @direction
+      when :sc_to_ms
+        type[:mti] = case mti
+                     when "00"
+                       :sms_deliver
+                     when "01"
+                       :sms_submit_report
+                     when "10"
+                       :sms_status_report
+                     when "11"
+                       :reserved
+                     end
+        type[:sri] = srr_or_sri
+        type[:mms] = rd_or_mms == "0"
+      when :ms_to_sc
+        type[:mti] = case mti
+                     when "00"
+                       :sms_deliver_report
+                     when "01"
+                       :sms_submit
+                     when "10"
+                       :sms_command
+                     when "11"
+                       :reserved
+                     end
+        type[:srr] = srr_or_sri
+        type[:rd] = rd_or_mms == "0"
+      end
+      type
+    end
+
+    def parse_data_coding_scheme scheme
+      {
+        coding_group: scheme.slice!(0,2),
+        compresion: scheme.slice!(0,1) == "1",
+        klass_meaning: scheme.slice!(0,1) == "1",
+        alphabet: ALPHABETS.key(scheme.slice!(0,2)),
+        klass: scheme.slice!(0,2)
+      }
+    end
+
+    def parse_7byte_timestamp timestamp
+      year, month, day, hour, minute, second, zone = swapped2normal(timestamp).split('').in_groups_of(2).collect(&:join)
+      d = "#{year}-#{month}-#{day} #{hour}:#{minute}:#{second} +%02d:00" % (zone.to_i / 4)
+      Time.parse(d)
+    end
+
+    def parse_validity_period period
+      case period
+      when 0..143
+        ((period + 1) * 5).minutes
+      when 144..167
+        12.hours + ((period - 143) * 30).minutes
+      when 168..196
+        (period - 166).days
+      when 197..255
+        (period - 192).weeks
+      end
+    end
+
+    def parse_user_data data_length
+      if @pdu_type[:udhi]
+        @udh_length = take(2, :integer) * 2
+        udh = take(@udh_length)
+        @user_data_header = parse_user_data_header udh
+      end
+      case @data_coding_scheme[:alphabet]
+      when :a7bit
+        @message = decode7bit @pdu_hex, data_length
+      when :a8bit
+        @message = decode8bit @pdu_hex, data_length
+      when :a16bit
+        @message = decode16bit @pdu_hex, data_length
+      end
+    end
+
+    def parse_user_data_header header
+      iei = take 2, :string, header
+      header_length = take 2, :integer, header
+      case iei
+      when "00"
+        reference = take 2, :integer, header
+      when "08"
+        reference = take 4, :integer, header
+      else
+        binding.pry
+        raise StandardError, "unsupported Information Element Identifier in User Data Header: #{iei}"
+      end
+      parts = take 2, :integer, header
+      part_number = take 2, :integer, header
+      {
+          reference: reference,
+          parts: parts,
+          part_number: part_number
+      }
+    end
+
+  end
+end

data/lib/pdu_tools/encoder.rb

@@ -0,0 +1,161 @@
+module PDUTools
+  class Encoder
+    include Helpers
+
+    DEFAULT_OPTIONS = {
+        klass: nil,
+        require_receipt: false,
+        expiry_seconds: nil
+    }
+
+    MessagePart = Struct.new(:data, :length)
+
+    # PDU structure - http://read.pudn.com/downloads150/sourcecode/embed/646395/Short%20Message%20in%20PDU%20Encoding.pdf
+    # X Bytes - SMSC - Service Center Address
+    # 1 Byte  - Flags / PDU Type
+    #     - 1 bit  Reply Path parameter indicator
+    #     - 1 bit  User Data Header Indicator
+    #     - 1 bit  Status Request Report
+    #     - 2 bits Validity Period Format
+    #     - 1 bit  Reject Duplicates
+    #     - 2 bits Message Type Indicator
+    # 2 Bytes - Message Reference
+    # X Bytes - Address length and address
+    # 1 Byte  - Protocol identificator (PID)
+    # 1 Byte  - Data Coding Scheme
+    # X Bytes - Validity Period
+    # 1 Byte  - User Data Length
+    # X Bytes - User Data
+
+    def initialize options
+      raise ArgumentError, :recipient unless options[:recipient]
+      raise ArgumentError, :message unless options[:message]
+      @options = DEFAULT_OPTIONS.merge options
+
+      @smsc = '00' # Phone Specified
+      @message_parts, @alphabet = prepare_message options[:message]
+      @pdu_type = pdu_type @concatenated_message_reference, options[:require_receipt], options[:expiry_seconds]
+      @message_reference = '00' # Phone Specified
+      @address = prepare_recipient options[:recipient]
+      @protocol_identifier = '00' # SMS
+      @data_coding_scheme = data_coding_scheme options[:klass], @alphabet
+      @validity_period = validity_period options[:expiry_seconds]
+    end
+
+    def encode
+      head = ""
+      head << @smsc
+      head << @pdu_type
+      head << @message_reference
+      head << @address
+      head << @protocol_identifier
+      head << @data_coding_scheme
+      head << @validity_period
+      pdus = []
+      @message_parts.each do |part|
+        pdus << PDU.new(head + part.length + part.data)
+      end
+      pdus
+    end
+
+    private
+    def prepare_message message
+      if message.ascii_only?
+        # parts = message.scan(/.{1,#{MAX_GSM_MESSAGE_7BIT_PART_LENGTH}}/)
+        parts = message.split('').in_groups_of(MAX_GSM_MESSAGE_7BIT_PART_LENGTH).collect(&:join)
+        message_parts = []
+        parts.each_with_index do |part, i|
+          part_gsm0338 = utf8_to_gsm0338 part
+          part_7bit = encode7bit(part_gsm0338)
+          udh = user_data_header parts.size, i+1
+          udh_length = (udh.present? ? (udh.length / 2) + 1 : 0)
+          part_length = "%02X" % (part_gsm0338.length + udh_length)
+          message_parts << MessagePart.new((udh + part_7bit), part_length)
+        end
+        [message_parts, :a7bit]
+      else
+        parts = message.split('').in_groups_of(MAX_GSM_MESSAGE_16BIT_PART_LENGTH).collect(&:join)
+        message_parts = []
+        parts.each_with_index do |part, i|
+          part_8bit = encode8bit(part)
+          udh = user_data_header parts.size, i+1
+          part_length = "%02X" % ((udh + part_8bit).length / 2)
+          message_parts << MessagePart.new((udh + part_8bit), part_length)
+        end
+        [message_parts, :a16bit]
+      end
+    end
+
+    # http://en.wikipedia.org/wiki/Concatenated_SMS#Sending_a_concatenated_SMS_using_a_User_Data_Header
+    def user_data_header parts_count, part_number
+      return '' if parts_count == 1
+      @concatenated_message_reference ||= rand((2**16)-1)
+      udh =  '06' # Length of User Data Header
+      udh << '08' # Concatenated short messages, 16-bit reference number
+      udh << '04' # Length of the header, excluding the first two fields
+      udh << "%04X" % @concatenated_message_reference
+      udh << "%02X" % parts_count
+      udh << "%02X" % part_number
+      udh
+    end
+
+    def prepare_recipient recipient
+      Phoner::Phone.default_country_code ||= "421"
+
+      address_type = "91" # International
+      address = Phoner::Phone.parse(recipient).format("%c%a%n")
+      address_length = "%02X" % address.length
+      address_encoded = normal2swapped address
+      address_length + address_type + address_encoded
+    end
+
+    def data_coding_scheme klass, alphabet
+      if klass
+        klass_meaning = '1'
+        klass = ("%02b" % klass)[-2,2]
+      else
+        klass_meaning = '0'
+        klass = '00'
+      end
+
+      scheme_bin = ""
+      scheme_bin << '00'                # 2 bits - coding_group
+      scheme_bin << '0'                 # 1 bit  - compression
+      scheme_bin << klass_meaning       # 1 bit  - klass meaning flag
+      scheme_bin << ALPHABETS[alphabet] # 2 bits - alphabet
+      scheme_bin << klass               # 2 bits - klass
+
+      data_coding_scheme_dec = scheme_bin.to_i(2)
+      dec2hexbyte data_coding_scheme_dec
+    end
+
+    def pdu_type uhdi, srr, vpf
+      reply_path = '0'
+      uhdi_flag = (uhdi ? '1' : '0') # User Data Header indicator
+      srr_flag = (srr ? '1' : '0')   # Status Request Report
+      vpf_flag = (vpf ? '10' : '00') # Validity Period Format
+      rj = '0'                       # Reject Duplicates
+      mti = '01'                     # Message Type Indicator (SMS-SUBMIT)
+      first_octet_dec = (reply_path + uhdi_flag + srr_flag + vpf_flag + rj + mti).to_i(2)
+      dec2hexbyte first_octet_dec
+    end
+
+    def validity_period expiry_seconds
+      return '' unless expiry_seconds
+      raise ArgumentError, "Expiry must be at least 300 seconds (5 minutes)" if expiry_seconds < 5.minutes
+      validity_period_dec = case expiry_seconds
+                            when 5.minutes..12.hours
+                              (expiry_seconds / 5.minutes) - 1
+                            when 12.hours..24.hours
+                              ((expiry_seconds - 12.hours) / 5.minutes) + 143
+                            when 24.hours..30.days
+                              (expiry_seconds / 24.hours) + 166
+                            when 30.days..63.weeks
+                              (expiry_seconds / 1.week) + 192
+                            else
+                              raise ArgumentError, "Expiry must be 38102400 seconds (63 weeks) or less"
+                            end
+      dec2hexbyte validity_period_dec.ceil
+    end
+  end
+end

data/lib/pdu_tools/helpers.rb

@@ -0,0 +1,111 @@
+module PDUTools
+  module Helpers
+    GSM_03_38_ESCAPES = {
+        "@" => "\x00",
+        "$" => "\x02",
+        "_" => "\x11",
+        "^" => "\x1B\x14",
+        "{" => "\x1B\x28",
+        "}" => "\x1B\x29",
+        "\\" => "\x1B\x2F",
+        "[" => "\x1B\x3C",
+        "~" => "\x1B\x3D",
+        "]" => "\x1B\x3E",
+        "|" => "\x1B\x40"
+        # "\x80" => "\x1B\x65"
+    }
+
+    def utf8_to_gsm0338 string
+      GSM_03_38_ESCAPES.each do |find, replace|
+        string.gsub! find, replace
+      end
+      string
+    end
+
+    def dec2hexbyte dec
+      "%02X" % dec
+    end
+
+    def encode7bit string, padding=0
+      current_byte = 0
+      offset = padding
+      packed = []
+      string.chars.to_a.each_with_index do |char, i|
+        # cap off any excess bytes
+        septet = char.ord & 0x7F
+        # append the septet and then cap off excess bytes
+        current_byte |= (septet << offset) & 0xFF
+        offset += 7
+        if offset > 7
+          # the current byte is full, add it to the encoded data.
+          packed << current_byte
+          # shift left and append the left shifted septet to the current byte
+          septet = septet >> (7 - (offset - 8 ))
+          current_byte = septet
+          # update offset
+          offset -= 8
+        end
+      end
+      packed << current_byte if offset > 0 # append the last byte
+      packed.collect{|c| "%02X" % c }.join
+    end
+
+    def encode8bit string
+      string.chars.to_a.collect do |char|
+        "%04X" % char.ord
+      end.join
+    end
+
+    def normal2swapped string
+      string << "F" if string.length.odd?
+      string.scan(/../).collect(&:reverse).join
+    end
+
+    def swapped2normal string
+      string.scan(/../).collect(&:reverse).join.gsub(/F$/,'')
+    end
+
+    # def decode7bit data, length
+    #   septets = data.to_i(16).to_s(2).split('').in_groups_of(7).collect(&:join)[0,length]
+    #   septets.collect do |s|
+    #     s.to_i(2).chr
+    #   end.join
+    # end
+
+    def decode7bit textdata, length
+      bytes = []
+      textdata.split('').each_slice(2) do |s|
+        bytes << "%08b" % s.join.to_i(16)
+      end
+      bit = (bytes.size % 7)
+      bytes.reverse!
+      bytes.each_with_index do |byte, index|
+        if bit == 0 or index == 0
+          bytes.insert(index, "")
+          bit = 7 if bit == 0
+          next
+        else
+          bytes[index-1] = "#{bytes[index-1]}#{(bytes[index]||"")[0,bit]}"
+          bytes[index] = bytes[index][bit..-1] if bytes[index]
+          bit -= 1
+        end
+      end
+      bytes = bytes.reverse.collect{|b| "0#{b}".to_i(2) }.collect{|b| b.zero? ? nil : b }.compact
+      bytes.collect{|b| b.chr }.join
+    end
+
+    def decode8bit data, length
+      octets = data.split('').in_groups_of(2).collect(&:join)[0, length]
+      octets.collect do |o|
+        o.to_i(16).chr
+      end.join
+    end
+
+    def decode16bit data, length
+      dobule_octets = data.split('').in_groups_of(4).collect(&:join)[0, length/2]
+      dobule_octets.collect do |o|
+        [o.to_i(16)].pack("U")
+      end.join
+    end
+  end
+end

data/lib/pdu_tools/message_part.rb

@@ -0,0 +1,21 @@
+module PDUTools
+  class MessagePart
+    attr_reader :address, :body, :timestamp, :validity_period, :user_data_header
+    def initialize address, body, timestamp, validity_period, user_data_header
+      @address = address
+      @body = body
+      @timestamp = timestamp
+      @validity_period = validity_period
+      @user_data_header = user_data_header
+    end
+
+    def complete?
+      return true unless @user_data_header
+      if @user_data_header[:parts] > 1
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/pdu_tools/pdu.rb

@@ -0,0 +1,19 @@
+module PDUTools
+  class PDU
+    attr_reader :pdu_hex
+    def initialize pdu_hex
+      @pdu_hex = pdu_hex
+    end
+
+    def checksum
+      @checksum ||= begin
+        sum = @pdu_hex.scan(/../).collect{|c| c.to_i(16)}.sum
+        "%02X" % (sum & 0xFF)
+      end
+    end
+
+    def length
+      @length ||= (@pdu_hex.length / 2) - 1
+    end
+  end
+end

data/spec/decoder_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'spec_helper'
+
+
+describe PDUTools::Decoder do
+  let(:decoder) { PDUTools::Decoder.new pdu, :ms_to_sc }
+
+  context "7 bit data" do
+    let(:pdu) { "0001000C9124910001100000001654747A0E4ACF416110BD3CA783DAE5F93C7C2E03" }
+    it "should decode" do
+      message_part = decoder.decode
+      expect(message_part.body).to eq "This is a test message"
+      expect(message_part.address).to eq "+421900100100"
+    end
+  end
+
+  context "16 bit data" do
+    let(:pdu) { "0001000C9124910001100000083E0054006800690073002000690073002000640069006100630072006900740069006300730020013E0161010D0165017E00FD00E100ED00E400FA00F40148" }
+    it "should decode" do
+      message_part = decoder.decode
+      expect(message_part.body).to eq "This is diacritics ľščťžýáíäúôň"
+      expect(message_part.address).to eq "+421900100100"
+    end
+  end
+
+  context "user data header" do
+    let(:pdu) { "0041000C912491000110000000A0060804C643020154747A0E4ACF416110BD3CA783DAE5F93C7C2E53D1E939283D078541F4F29C0E6A97E7F3F0B94C45A7E7A0F41C1406D1CB733AA85D9ECFC3E732159D9E83D2735018442FCFE9A076793E0F9FCB54747A0E4ACF416110BD3CA783DAE5F93C7C2E53D1E939283D078541F4F29C0E6A97E7F3F0B94C45A7E7A0F41C1406D1CB733AA85D9ECFC3" }
+    it "should decode" do
+      message_part = decoder.decode
+      expect(message_part.user_data_header).to be_present
+      expect(message_part.user_data_header[:parts]).to eq 2
+      expect(message_part.user_data_header[:part_number]).to eq 1
+    end
+  end
+end

data/spec/encoder_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe PDUTools::Encoder do
+  let(:recipient) { "+421 900 100 100" }
+  let(:encoder) { PDUTools::Encoder.new recipient: recipient, message: message }
+  context "short" do
+    context "7bit text" do
+      let(:message) { "This is a test message" }
+      it "should encode pdu" do
+        pdus = encoder.encode
+        expect(pdus.size).to eq(1)
+      end
+    end
+
+    context "16bit text" do
+      let(:message) { "This is diacritics ľščťžýáíäúôň" }
+      it "should encode pdu" do
+        pdus = encoder.encode
+        expect(pdus.size).to eq(1)
+      end
+    end
+  end
+
+  context "lonh" do
+    context "7bit text" do
+      let(:message) { "This is a test message" * 10 }
+      it "should encode pdu" do
+        pdus = encoder.encode
+        expect(pdus.size).to eq(2)
+      end
+    end
+
+    context "16bit text" do
+      let(:message) { "This is diacritics ľščťžýáíäúôň" * 3 }
+      it "should encode pdu" do
+        pdus = encoder.encode
+        expect(pdus.size).to eq(2)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'pdu_tools'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: pdu_tools
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Filip Zachar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-10-06 00:00:00 Z
+dependencies: []
+
+description: Tools for encoding and decoding GSM SMS PDUs.
+email: tulak45@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pdu_tools/decoder.rb
+- lib/pdu_tools/encoder.rb
+- lib/pdu_tools/helpers.rb
+- lib/pdu_tools/message_part.rb
+- lib/pdu_tools/pdu.rb
+- lib/pdu_tools.rb
+- spec/decoder_spec.rb
+- spec/encoder_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/pdu_tools
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id001 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id001
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Tools for encoding and decoding GSM SMS PDUs.
+test_files: []
+