anjlab-ruby-smpp 0.6.0

data/lib/smpp/optional_parameter.rb

@@ -0,0 +1,35 @@
+class Smpp::OptionalParameter
+
+  attr_reader :tag, :value
+  
+  def initialize(tag, value)
+    @tag = tag
+    @value = value
+  end
+
+  def [](symbol)
+    self.send symbol
+  end
+
+  def to_s
+    self.inspect
+  end
+
+  #class methods
+  class << self
+    def from_wire_data(data)
+
+      return nil if data.nil?
+      tag, length, remaining_bytes = data.unpack('H4na*')
+      tag = tag.hex
+
+      raise "invalid data, cannot parse optional parameters" if tag == 0 or length.nil?
+
+      value = remaining_bytes.slice!(0...length)
+
+      return new(tag, value), remaining_bytes
+    end
+
+  end
+
+end

data/lib/smpp/pdu/base.rb

@@ -0,0 +1,183 @@
+# PDUs are the protcol base units in SMPP
+module Smpp::Pdu
+  class Base
+    #Protocol Version
+    PROTOCOL_VERSION      = 0x34
+    # Error constants
+    ESME_ROK              = 0x00000000 # OK!
+    ESME_RINVMSGLEN       = 0x00000001 # Message Length is invalid 
+    ESME_RINVCMDLEN       = 0x00000002 # Command Length is invalid 
+    ESME_RINVCMDID        = 0x00000003 # Invalid Command ID 
+    ESME_RINVBNDSTS       = 0x00000004 # Incorrect BIND Status for given com- 
+    ESME_RALYBND          = 0x00000005 # ESME Already in Bound State 
+    ESME_RINVPRTFLG       = 0x00000006 # Invalid Priority Flag 
+    ESME_RINVREGDLVFLG    = 0x00000007 # Invalid Registered Delivery Flag 
+    ESME_RSYSERR          = 0x00000008 # System Error 
+    ESME_RINVSRCADR       = 0x0000000A # Invalid Source Address 
+    ESME_RINVDSTADR       = 0x0000000B # Invalid Dest Addr 
+    ESME_RINVMSGID        = 0x0000000C # Message ID is invalid 
+    ESME_RBINDFAIL        = 0x0000000D # Bind Failed 
+    ESME_RINVPASWD        = 0x0000000E # Invalid Password 
+    ESME_RINVSYSID        = 0x0000000F # Invalid System ID 
+    ESME_RCANCELFAIL      = 0x00000011 # Cancel SM Failed 
+    ESME_RREPLACEFAIL     = 0x00000013 # Replace SM Failed 
+    ESME_RMSGQFUL         = 0x00000014 # Message Queue Full 
+    ESME_RINVSERTYP       = 0x00000015 # Invalid Service Type 
+    ESME_RINVNUMDESTS     = 0x00000033 # Invalid number of destinations 
+    ESME_RINVDLNAME       = 0x00000034 # Invalid Distribution List name 
+    ESME_RINVDESTFLAG     = 0x00000040 # Destination flag is invalid 
+    ESME_RINVSUBREP       = 0x00000042 # Invalid ‘submit with replace’ request 
+    ESME_RINVESMCLASS     = 0x00000043 # Invalid esm_class field data 
+    ESME_RCNTSUBDL        = 0x00000044 # Cannot Submit to Distribution List 
+    ESME_RSUBMITFAIL      = 0x00000045 # submit_sm or submit_multi failed 
+    ESME_RINVSRCTON       = 0x00000048 # Invalid Source address TON 
+    ESME_RINVSRCNPI       = 0x00000049 # Invalid Source address NPI       
+    ESME_RINVDSTTON       = 0x00000050 # Invalid Destination address TON 
+    ESME_RINVDSTNPI       = 0x00000051 # Invalid Destination address NPI 
+    ESME_RINVSYSTYP       = 0x00000053 # Invalid system_type field 
+    ESME_RINVREPFLAG      = 0x00000054 # Invalid replace_if_present flag 
+    ESME_RINVNUMMSGS      = 0x00000055 # Invalid number of messages 
+    ESME_RTHROTTLED       = 0x00000058 # Throttling error (ESME has exceeded allowed message limits)     
+
+    ESME_RX_T_APPN        = 0x00000064 # ESME Receiver Temporary App Error Code
+
+    # PDU types
+    GENERIC_NACK          = 0X80000000 
+    BIND_RECEIVER         = 0X00000001 
+    BIND_RECEIVER_RESP    = 0X80000001 
+    BIND_TRANSMITTER      = 0X00000002 
+    BIND_TRANSMITTER_RESP = 0X80000002 
+    BIND_TRANSCEIVER      = 0X00000009
+    BIND_TRANSCEIVER_RESP = 0X80000009
+    QUERY_SM              = 0X00000003 
+    QUERY_SM_RESP         = 0X80000003 
+    SUBMIT_SM             = 0X00000004 
+    SUBMIT_SM_RESP        = 0X80000004 
+    DELIVER_SM            = 0X00000005 
+    DELIVER_SM_RESP       = 0X80000005 
+    UNBIND                = 0X00000006 
+    UNBIND_RESP           = 0X80000006 
+    REPLACE_SM            = 0X00000007 
+    REPLACE_SM_RESP       = 0X80000007 
+    CANCEL_SM             = 0X00000008 
+    CANCEL_SM_RESP        = 0X80000008 
+    ENQUIRE_LINK          = 0X00000015 
+    ENQUIRE_LINK_RESP     = 0X80000015
+    SUBMIT_MULTI          = 0X00000021
+    SUBMIT_MULTI_RESP     = 0X80000021
+
+    OPTIONAL_RECEIPTED_MESSAGE_ID = 0x001E
+    OPTIONAL_MESSAGE_STATE        = 0x0427
+
+    SEQUENCE_MAX = 0x7FFFFFFF
+
+    # PDU sequence number. 
+    @@seq = [Time.now.to_i]
+
+    # Add monitor to sequence counter for thread safety
+    @@seq.extend(MonitorMixin)
+
+    #factory class registry
+    @@cmd_map = {}
+
+    attr_reader :command_id, :command_status, :sequence_number, :body, :data
+
+    def initialize(command_id, command_status, seq, body='')    
+      length = 16 + body.length
+      @command_id = command_id
+      @command_status = command_status
+      @body = body
+      @sequence_number = seq
+      @data = fixed_int(length) + fixed_int(command_id) + fixed_int(command_status) + fixed_int(seq) + body   
+    end      
+
+    def logger
+      Smpp::Base.logger
+    end
+
+    def to_human
+      # convert header (4 bytes) to array of 4-byte ints
+      a = @data.to_s.unpack('N4')
+      sprintf("(%22s) len=%3d cmd=%8s status=%1d seq=%03d (%s)", self.class.to_s[11..-1], a[0], a[1].to_s(16), a[2], a[3], @body)
+    end
+
+    # return int as binary string of 4 octets
+    def Base.fixed_int(value)
+      arr = [value >> 24, value >> 16, value >> 8, value & 0xff]
+      arr.pack("cccc")
+    end
+
+    def fixed_int(value)
+      Base.fixed_int(value)
+    end
+
+    #expects a hash like {tag => Smpp::OptionalParameter}
+    def Base.optional_parameters_to_buffer(optionals)
+      output = ""
+      optionals.each do |tag, optional_param|
+        length = optional_param.value.length
+        buffer = []
+        buffer += [tag >> 8, tag & 0xff]
+        buffer += [length >> 8, length & 0xff]
+        output << buffer.pack('cccc') << optional_param.value
+      end
+      output
+    end
+
+    def optional_parameters_to_buffer(optionals)
+      Base.optional_parameters_to_buffer(optionals)
+    end
+
+    def next_sequence_number
+      Base.next_sequence_number
+    end
+
+    def Base.next_sequence_number
+      @@seq.synchronize do
+        (@@seq[0] += 1) % SEQUENCE_MAX
+      end
+    end
+
+    #This factory should be implemented in every subclass that can create itself from wire
+    #data.  The subclass should also register itself with the 'handles_cmd' class method.
+    def Base.from_wire_data(seq, status, body)
+      raise Exception.new("#{self.class} claimed to handle wire data, but doesn't.")
+    end
+
+    # PDU factory method for common client PDUs (used to create PDUs from wire data)
+    def Base.create(data)
+      header = data[0..15]
+      if !header
+        return nil
+      end
+      len, cmd, status, seq = header.unpack('N4')
+      body = data[16..-1]
+
+      #if a class has been registered to handle this command_id, try
+      #to create an instance from the wire data
+      if @@cmd_map[cmd]
+        @@cmd_map[cmd].from_wire_data(seq, status, body)
+      else
+        Smpp::Base.logger.error "Unknown PDU: #{"0x%08x" % cmd}"
+        return nil
+      end
+    end
+
+    #maps a subclass as the handler for a particulular pdu
+    def Base.handles_cmd(command_id)
+      @@cmd_map[command_id] = self
+    end
+
+    def Base.parse_optional_parameters(remaining_bytes)
+      optionals = {}
+      while not remaining_bytes.empty?
+        optional = {}
+        optional_parameter, remaining_bytes = Smpp::OptionalParameter.from_wire_data(remaining_bytes)
+        optionals[optional_parameter.tag] = optional_parameter
+      end
+      
+      return optionals
+    end
+
+  end
+end

data/lib/smpp/pdu/bind_base.rb

@@ -0,0 +1,25 @@
+# this class serves as the base for all the bind* commands.
+# since the command format remains the same for all bind commands, 
+# sub classes just change the @@command_id
+class Smpp::Pdu::BindBase < Smpp::Pdu::Base
+  class << self; attr_accessor :command_id ; end
+
+  attr_reader :system_id, :password, :system_type, :addr_ton, :addr_npi, :address_range 
+
+  def initialize(system_id, password, system_type, addr_ton, addr_npi, address_range, seq = nil)
+    @system_id, @password, @system_type, @addr_ton, @addr_npi, @address_range =
+      system_id, password, system_type, addr_ton, addr_npi, address_range
+
+    seq ||= next_sequence_number
+    body = sprintf("%s\0%s\0%s\0%c%c%c%s\0", system_id, password,system_type, PROTOCOL_VERSION, addr_ton, addr_npi, address_range)
+    super(self.class.command_id, 0, seq, body)
+  end
+
+  def self.from_wire_data(seq, status, body)
+    #unpack the body
+    system_id, password, system_type, interface_version, addr_ton,
+    addr_npi, address_range = body.unpack("Z*Z*Z*CCCZ*")
+
+    self.new(system_id, password, system_type, addr_ton, addr_npi, address_range, seq)
+  end
+end

data/lib/smpp/pdu/bind_receiver.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindReceiver < Smpp::Pdu::BindBase
+  @command_id = BIND_RECEIVER
+  handles_cmd BIND_RECEIVER
+end

data/lib/smpp/pdu/bind_receiver_response.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindReceiverResponse < Smpp::Pdu::BindRespBase
+  @command_id = BIND_RECEIVER_RESP
+  handles_cmd BIND_RECEIVER_RESP
+end

data/lib/smpp/pdu/bind_resp_base.rb

@@ -0,0 +1,17 @@
+class Smpp::Pdu::BindRespBase < Smpp::Pdu::Base
+  class << self; attr_accessor :command_id ; end
+  attr_accessor :system_id
+
+  def initialize(seq, status, system_id)
+    seq ||= next_sequence_number
+    system_id = system_id.to_s + "\000"
+    super(self.class.command_id, status, seq, system_id) # pass in system_id as body for simple debugging
+    @system_id = system_id
+  end
+
+  def self.from_wire_data(seq, status, body)
+    system_id = body.chomp("\000")
+    new(seq, status, system_id)
+  end
+
+end

data/lib/smpp/pdu/bind_transceiver.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindTransceiver < Smpp::Pdu::BindBase
+  @command_id = BIND_TRANSCEIVER
+  handles_cmd BIND_TRANSCEIVER
+end

data/lib/smpp/pdu/bind_transceiver_response.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindTransceiverResponse < Smpp::Pdu::BindRespBase
+  @command_id = BIND_TRANSCEIVER_RESP
+  handles_cmd BIND_TRANSCEIVER_RESP
+end

data/lib/smpp/pdu/deliver_sm.rb

@@ -0,0 +1,142 @@
+
+# Received for MO message or delivery notification
+class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base 
+  handles_cmd DELIVER_SM
+
+  attr_reader :service_type, :source_addr_ton, :source_addr_npi, :source_addr, :dest_addr_ton, :dest_addr_npi, 
+              :destination_addr, :esm_class, :protocol_id, :priority_flag, :schedule_delivery_time, 
+              :validity_period, :registered_delivery, :replace_if_present_flag, :data_coding, 
+              :sm_default_msg_id, :sm_length, :stat, :msg_reference, :udh, :short_message,
+              :message_state, :receipted_message_id, :optional_parameters
+
+  @@encoder = nil
+
+  def initialize(source_addr, destination_addr, short_message, options={}, seq=nil) 
+    
+    @udh = options[:udh]      
+    @service_type            = options[:service_type]? options[:service_type] :''
+    @source_addr_ton         = options[:source_addr_ton]?options[:source_addr_ton]:0 # network specific
+    @source_addr_npi         = options[:source_addr_npi]?options[:source_addr_npi]:1 # unknown
+    @source_addr             = source_addr
+    @dest_addr_ton           = options[:dest_addr_ton]?options[:dest_addr_ton]:1 # international
+    @dest_addr_npi           = options[:dest_addr_npi]?options[:dest_addr_npi]:1 # unknown 
+    @destination_addr        = destination_addr
+    @esm_class               = options[:esm_class]?options[:esm_class]:0 # default smsc mode
+    @protocol_id             = options[:protocol_id]?options[:protocol_id]:0
+    @priority_flag           = options[:priority_flag]?options[:priority_flag]:0
+    @schedule_delivery_time  = options[:schedule_delivery_time]?options[:schedule_delivery_time]:''
+    @validity_period         = options[:validity_period]?options[:validity_period]:''
+    @registered_delivery     = options[:registered_delivery]?options[:registered_delivery]:1 # we want delivery notifications
+    @replace_if_present_flag = options[:replace_if_present_flag]?options[:replace_if_present_flag]:0
+    @data_coding             = options[:data_coding]?options[:data_coding]:3 # iso-8859-1
+    @sm_default_msg_id       = options[:sm_default_msg_id]?options[:sm_default_msg_id]:0
+    @short_message           = short_message
+    payload                  = @udh ? @udh.to_s + @short_message : @short_message 
+    @sm_length               = payload.length
+
+    #fields set for delivery report
+    @stat                    = options[:stat]
+    @msg_reference           = options[:msg_reference]
+    @receipted_message_id    = options[:receipted_message_id]
+    @message_state           = options[:message_state]
+    @optional_parameters     = options[:optional_parameters]
+
+    pdu_body = sprintf("%s\0%c%c%s\0%c%c%s\0%c%c%c%s\0%s\0%c%c%c%c%c%s", @service_type, @source_addr_ton, @source_addr_npi, @source_addr,
+    @dest_addr_ton, @dest_addr_npi, @destination_addr, @esm_class, @protocol_id, @priority_flag, @schedule_delivery_time, @validity_period,
+    @registered_delivery, @replace_if_present_flag, @data_coding, @sm_default_msg_id, @sm_length, payload)
+
+    seq ||= next_sequence_number
+
+    super(DELIVER_SM, 0, seq, pdu_body)
+  end
+
+  def total_parts
+    @udh ? @udh[4] : 0
+  end
+
+  def part
+    @udh ? @udh[5] : 0
+  end
+
+  def message_id
+    @udh ? @udh[3] : 0
+  end
+
+  def self.from_wire_data(seq, status, body)
+    options = {}
+    # brutally unpack it
+    options[:service_type], 
+    options[:source_addr_ton], 
+    options[:source_addr_npi], 
+    source_addr, 
+    options[:dest_addr_ton], 
+    options[:dest_addr_npi], 
+    destination_addr, 
+    options[:esm_class], 
+    options[:protocol_id],
+    options[:priority_flag], 
+    options[:schedule_delivery_time], 
+    options[:validity_period], 
+    options[:registered_delivery], 
+    options[:replace_if_present_flag], 
+    options[:data_coding], 
+    options[:sm_default_msg_id],
+    options[:sm_length], 
+    remaining_bytes = body.unpack('Z*CCZ*CCZ*CCCZ*Z*CCCCCa*')    
+
+    short_message = remaining_bytes.slice!(0...options[:sm_length])
+
+    #everything left in remaining_bytes is 3.4 optional parameters
+    options[:optional_parameters] = parse_optional_parameters(remaining_bytes)
+
+    #parse the 'standard' optional parameters for delivery receipts
+    options[:optional_parameters].each do |tag, tlv|
+      if OPTIONAL_MESSAGE_STATE == tag
+        value = tlv[:value].unpack('C')
+        options[:message_state] = value[0] if value
+
+      elsif OPTIONAL_RECEIPTED_MESSAGE_ID == tag
+        value = tlv[:value].unpack('A*')
+        options[:receipted_message_id] = value[0] if value
+      end
+    end
+
+    # Check to see if body has a 5 bit header
+    if short_message.unpack("c")[0] == 5
+      options[:udh] = short_message.slice!(0..5).unpack("CCCCCC")
+    end
+
+    #Note: if the SM is a delivery receipt (esm_class=4) then the short_message _may_ be in this format:  
+    # "id:Smsc2013 sub:1 dlvrd:1 submit date:0610171515 done date:0610171515 stat:0 err:0 text:blah"
+    # or this format:
+    # "4790000000SMSAlert^id:1054BC63 sub:0 dlvrd:1 submit date:0610231217 done date:0610231217 stat:DELIVRD err: text:"
+    # (according to the SMPP spec, the format is vendor specific)
+    # For example, Tele2 (Norway):
+    # "<msisdn><shortcode>?id:10ea34755d3d4f7a20900cdb3349e549 sub:001 dlvrd:001 submit date:0611011228 done date:0611011230 stat:DELIVRD err:000 Text:abc'!10ea34755d3d4f7a20900cdb3349e549"
+    if options[:esm_class] == 4
+      msg_ref_match = short_message.match(/id:([^ ]*)/)
+      if msg_ref_match
+        options[:msg_reference] = msg_ref_match[1]
+      end
+      
+      stat_match = short_message.match(/stat:([^ ]*)/)
+      if stat_match
+        options[:stat] = stat_match[1]
+      end
+      
+      Smpp::Base.logger.debug "DeliverSM with source_addr=#{source_addr}, destination_addr=#{destination_addr}, msg_reference=#{options[:msg_reference]}, stat=#{options[:stat]}"
+    else
+      Smpp::Base.logger.debug "DeliverSM with source_addr=#{source_addr}, destination_addr=#{destination_addr}"
+    end
+
+    #yield the data_coding and short_message to the encoder if one is set
+    short_message = @@encoder.encode(options[:data_coding], short_message) if @@encoder.respond_to?(:encode)
+
+    new(source_addr, destination_addr, short_message, options, seq) 
+  end
+
+  #set an encoder that can be called to yield the data_coding and short_message
+  def self.data_encoder=(encoder)
+    @@encoder = encoder
+  end
+end

data/lib/smpp/pdu/deliver_sm_response.rb

@@ -0,0 +1,12 @@
+class Smpp::Pdu::DeliverSmResponse < Smpp::Pdu::Base
+  handles_cmd DELIVER_SM_RESP
+
+  def initialize(seq, status=ESME_ROK)
+    seq ||= next_sequence_number
+    super(DELIVER_SM_RESP, status, seq, "\000") # body must be NULL..!
+  end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq, status)
+  end
+end