ruby-smpp 0.1.1 → 0.1.2

data/lib/smpp/pdu/base.rb

@@ -1,6 +1,8 @@
 # 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 
@@ -59,7 +61,7 @@ module Smpp::Pdu
     CANCEL_SM_RESP        = 0X80000008 
     ENQUIRE_LINK          = 0X00000015 
     ENQUIRE_LINK_RESP     = 0X80000015
-    SUBMIT_MULTI	  = 0X00000021
+    SUBMIT_MULTI	        = 0X00000021
     SUBMIT_MULTI_RESP     = 0X80000021
     # PDU sequence number. 
     @@seq = [Time.now.to_i]
@@ -67,6 +69,9 @@ module Smpp::Pdu
     # 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='')    
@@ -103,6 +108,12 @@ module Smpp::Pdu
       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]
@@ -111,33 +122,21 @@ module Smpp::Pdu
       end
       len, cmd, status, seq = header.unpack('N4')
       body = data[16..-1]
-      case cmd
-      when ENQUIRE_LINK:
-        EnquireLink.new(seq)
-      when ENQUIRE_LINK_RESP:
-        EnquireLinkResponse.new(seq)
-      when GENERIC_NACK:
-        GenericNack.new(seq, status, body)        
-      when UNBIND:
-        Unbind.new(seq)        
-      when UNBIND_RESP:
-        UnbindResponse.new(seq, status)        
-      when BIND_TRANSMITTER_RESP:
-        BindTransmitterResponse.new(seq, status, body) # could be opt'l params too
-      when BIND_RECEIVER_RESP:
-        BindReceiverResponse.new(seq, status, body) 
-      when BIND_TRANSCEIVER_RESP:
-        BindTransceiverResponse.new(seq, status, body)
-      when SUBMIT_SM_RESP:
-        SubmitSmResponse.new(seq, status, body)
-      when SUBMIT_MULTI_RESP:
-        SubmitMultiResponse.new(seq, status, body)
-      when DELIVER_SM:
-        DeliverSm.new(seq, status, body)
+          
+      #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#{cmd.to_s(16)}"
         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
+
   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_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

@@ -1,6 +1,4 @@
-class Smpp::Pdu::BindTransceiver < Smpp::Pdu::Base
-  def initialize(system_id, password, system_type, addr_ton, addr_npi, address_range)
-    body = sprintf("%s\0%s\0%s\0%c%c%c%s\0", system_id, password,system_type, 0x34, addr_ton, addr_npi, address_range)
-    super(BIND_TRANSCEIVER, 0, next_sequence_number, body)
-  end
+class Smpp::Pdu::BindTransceiver < Smpp::Pdu::BindBase
+  @command_id = BIND_TRANSCEIVER
+  handles_cmd BIND_TRANSCEIVER
 end

data/lib/smpp/pdu/bind_transceiver_response.rb

@@ -1,7 +1,4 @@
-class Smpp::Pdu::BindTransceiverResponse < Smpp::Pdu::Base
-  attr_accessor :system_id
-  def initialize(seq, status, system_id)
-    super(BIND_TRANSCEIVER_RESP, status, seq, system_id) # pass in system_id as body for simple debugging
-    @system_id = system_id
-  end
+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

@@ -1,40 +1,83 @@
 # Received for MO message or delivery notification
-class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
-  attr_reader :source_addr, :destination_addr, :short_message, :source_addr, :esm_class, :msg_reference, :stat
-  def initialize(seq, status, body)
-    # brutally unpack it
-    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, 
-    @short_message = body.unpack('Z*CCZ*CCZ*CCCZ*Z*CCCCCa*')
-    logger.debug "DeliverSM with source_addr=#{@source_addr}, destination_addr=#{@destination_addr}"
+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
+
+  def initialize(source_addr, destination_addr, short_message, options={}, seq=nil) 
     
-    # Note: if the SM is a delivery receipt (esm_class=4) then the short_message _may_ be in this format:  
+    @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]:1
+    @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 + @short_message : @short_message 
+    @sm_length               = payload.length
+
+    #fields set for delivery report
+    @stat                    = options[:stat]
+    @msg_reference           = options[:msg_reference]
+
+    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 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], 
+    short_message = body.unpack('Z*CCZ*CCZ*CCCZ*Z*CCCCCa*')
+    Smpp::Base.logger.debug "DeliverSM with source_addr=#{source_addr}, destination_addr=#{destination_addr}"
+
+    #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 @esm_class == 4
-      @msg_reference = @short_message.scanf('id:%s').to_s
+    if options[:esm_class] == 4
+      options[:msg_reference] = short_message.scanf('id:%s').to_s
       # @stat must be parsed according to the SMSC vendor's specifications (see comment above)
-      @stat = 0
+      options[:stat] = 0
     end
-    super(DELIVER_SM, status, seq, body)
+    
+    new(source_addr, destination_addr, short_message, options, seq) 
   end
-end
+end

data/lib/smpp/pdu/deliver_sm_response.rb

@@ -1,5 +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

data/lib/smpp/pdu/enquire_link.rb

@@ -1,5 +1,11 @@
 class Smpp::Pdu::EnquireLink < Smpp::Pdu::Base
+  handles_cmd ENQUIRE_LINK
+
   def initialize(seq = next_sequence_number)
     super(ENQUIRE_LINK, 0, seq)
   end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq)
+  end
 end

data/lib/smpp/pdu/enquire_link_response.rb

@@ -1,5 +1,11 @@
 class Smpp::Pdu::EnquireLinkResponse < Smpp::Pdu::Base
-  def initialize(seq)
+  handles_cmd ENQUIRE_LINK_RESP
+
+  def initialize(seq = next_sequence_number)
     super(ENQUIRE_LINK_RESP, ESME_ROK, seq)
   end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq)
+  end
 end

data/lib/smpp/pdu/generic_nack.rb

@@ -1,8 +1,20 @@
 # signals invalid message header
 class Smpp::Pdu::GenericNack < Smpp::Pdu::Base
+  handles_cmd GENERIC_NACK
+
   attr_accessor :error_code
-  def initialize(seq, error_code, original_sequence_code)
-    super(GENERIC_NACK, error_code, seq, "Error: #{error_code} Problem sequence: #{original_sequence_code.blank? ? 'unknown' : original_sequence_code }")
+
+  def initialize(seq, error_code, original_sequence_code = nil)
+    #TODO: original_sequence_code used to be passed to this function
+    #however, a GENERIC_NACK has only one sequence number and no body
+    #so this is a useless variable.  I leave it here only to preserve
+    #the API, but it has no practical use.
+    seq ||= next_sequence_number
+    super(GENERIC_NACK, error_code, seq)
     @error_code = error_code
   end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq,status,body) 
+  end
 end        

data/lib/smpp/pdu/submit_multi.rb

@@ -1,5 +1,6 @@
 # Sending an MT message to multiple addresses
 # Author: Abhishek Parolkar, (abhishek[at]parolkar.com)
+#TODO: Implement from_wire_data for this pdu class.
 class Smpp::Pdu::SubmitMulti < Smpp::Pdu::Base
   IS_SMEADDR = 1 # type of dest_flag
   IS_DISTLISTNAME = 2 #type of dest_flag  
@@ -45,23 +46,23 @@ class Smpp::Pdu::SubmitMulti < Smpp::Pdu::Base
     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], @msg_body[0..30])
   end
+
   def build_destination_addresses(dest_array,dest_addr_ton,dest_addr_npi, dest_flag = IS_SMEADDR)
-  
-	formatted_array = Array.new
-	dest_array.each { |dest_elem|
-		if dest_flag == IS_SMEADDR
-			packet_str = sprintf("%c%c%c%s",IS_SMEADDR,dest_addr_ton,dest_addr_npi,dest_elem)
-			formatted_array.push(packet_str)
+    formatted_array = Array.new
+    dest_array.each { |dest_elem|
+      if dest_flag == IS_SMEADDR
+        packet_str = sprintf("%c%c%c%s",IS_SMEADDR,dest_addr_ton,dest_addr_npi,dest_elem)
+        formatted_array.push(packet_str)
 
-		elsif dest_flag == IS_DISTLISTNAME
-			packet_str = sprintf("%c%s",IS_SMEADDR,dest_elem)
-                        formatted_array.push(packet_str)
+      elsif dest_flag == IS_DISTLISTNAME
+        packet_str = sprintf("%c%s",IS_SMEADDR,dest_elem)
+                          formatted_array.push(packet_str)
 
-		end
+      end
 
-	}
+    }
 
-	formatted_array.join('\0');
+    formatted_array.join('\0');
   end
   
 end

data/lib/smpp/pdu/submit_multi_response.rb

@@ -1,10 +1,49 @@
 # Recieving response for an MT message sent to multiple addresses
 # Author: Abhishek Parolkar, (abhishek[at]parolkar.com)
 class Smpp::Pdu::SubmitMultiResponse < Smpp::Pdu::Base
-  attr_accessor :message_id
-  def initialize(seq, status, message_id)
-    message_id = message_id.chomp("\000")
-    super(SUBMIT_MULTI_RESP, status, seq, message_id)
+  class UnsuccessfulSme 
+    Struct.new(:dest_addr_ton, :dest_addr_npi, :destination_addr, :error_status_code)
+  end
+
+  handles_cmd SUBMIT_MULTI_RESP
+
+  attr_accessor :message_id, :unsuccess_smes
+
+  def initialize(seq, status, message_id, unsuccess_smes = [])
+    @unsuccess_smes = unsuccess_smes
+    seq ||= next_sequence_number
+
+    packed_smes = ""
+    unsuccess_smes.each do |sme|
+      packed_smes << [
+        sme.dest_addr_ton, 
+        sme.dest_addr_npi, 
+        sme.destination_addr, 
+        sme.error_status_code
+      ].pack("CCZ*N")
+    end
+    body = [message_id, unsuccess_smes.size, packed_smes].pack("Z*Ca*")
+
+    super(SUBMIT_MULTI_RESP, status, seq, body)
     @message_id = message_id
   end
+
+  def self.from_wire_data(seq, status, body)
+    message_id, no_unsuccess, rest = body.unpack("Z*Ca*")
+    unsuccess_smes = []
+
+    no_unsuccess.times do |i|
+      #unpack the next sme
+      dest_addr_ton, dest_addr_npi, destination_addr, error_status_code =
+        rest.unpack("CCZ*N")
+      #remove the SME from rest 
+      rest.slice!(0,7 + destination_addr.length)
+      unsuccess_smes << UnsuccessfulSme.new(dest_addr_ton, dest_addr_npi, destination_addr, error_status_code)
+    end
+    
+    new(seq, status, message_id, unsuccess_smes)
+  end
+
+
+
 end    

data/lib/smpp/pdu/submit_sm.rb

@@ -1,34 +1,46 @@
 # Sending an MT message
 class Smpp::Pdu::SubmitSm < Smpp::Pdu::Base
+  handles_cmd SUBMIT_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, :udh, :short_message
+
   
   # Note: short_message (the SMS body) must be in iso-8859-1 format
-  def initialize(source_addr, destination_addr, short_message, options={})
+  def initialize(source_addr, destination_addr, short_message, options={}, seq = nil)
      
     @msg_body = short_message
     
-    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
-    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 
-    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]:1
-    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
-    payload                 = udh ? udh + short_message : short_message # this used to be (short_message + "\0")
-    sm_length               = payload.length
+    @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]:1
+    @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 + @short_message : @short_message 
+    @sm_length               = payload.length
     
     # craft the string/byte buffer
-    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)
-    super(SUBMIT_SM, 0, next_sequence_number, pdu_body)        
+    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(SUBMIT_SM, 0, seq, pdu_body)        
   end
   
   # some special formatting is needed for SubmitSm PDUs to show the actual message content
@@ -37,4 +49,31 @@ class Smpp::Pdu::SubmitSm < Smpp::Pdu::Base
     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], @msg_body[0..30])
   end
+
+  def self.from_wire_data(seq, status, body)
+    options = {}
+
+    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], 
+    short_message = body.unpack('Z*CCZ*CCZ*CCCZ*Z*CCCCCa*')
+    Smpp::Base.logger.debug "DeliverSM with source_addr=#{source_addr}, destination_addr=#{destination_addr}"
+
+    new(source_addr, destination_addr, short_message, options, seq) 
+  end
+
 end

data/lib/smpp/pdu/submit_sm_response.rb

@@ -1,8 +1,17 @@
 class Smpp::Pdu::SubmitSmResponse < Smpp::Pdu::Base
+  handles_cmd SUBMIT_SM_RESP
+
   attr_accessor :message_id
+
   def initialize(seq, status, message_id)
-    message_id = message_id.chomp("\000")
-    super(SUBMIT_SM_RESP, status, seq, message_id)
+    seq ||= next_sequence_number
+    body = message_id.to_s + "\000"
+    super(SUBMIT_SM_RESP, status, seq, body)
     @message_id = message_id
   end
+
+  def self.from_wire_data(seq, status, body)
+    message_id = body.chomp("\000")
+    new(seq, status, message_id)
+  end
 end    

data/lib/smpp/pdu/unbind.rb

@@ -1,5 +1,11 @@
 class Smpp::Pdu::Unbind < Smpp::Pdu::Base
+  handles_cmd UNBIND
+
   def initialize(seq=next_sequence_number)
     super(UNBIND, 0, seq)
   end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq)
+  end
 end

data/lib/smpp/pdu/unbind_response.rb

@@ -1,5 +1,12 @@
 class Smpp::Pdu::UnbindResponse < Smpp::Pdu::Base
+  handles_cmd UNBIND_RESP
+
   def initialize(seq, status)
+    seq ||= next_sequence_number
     super(UNBIND_RESP, status, seq)
   end
+
+  def self.from_wire_data(seq, status, body)
+    new(seq, status)
+  end
 end