ruby-smpp 0.1.2 → 0.1.3.pre1

data/examples/sample_smsc.rb

@@ -3,9 +3,8 @@
 # Sample SMPP SMS Gateway. 
 
 require 'rubygems'
-gem 'ruby-smpp'
-require 'smpp'
-require 'smpp/server'
+require File.dirname(__FILE__) + '/../lib/smpp'
+require File.dirname(__FILE__) + '/../lib/smpp/server'
 
 # set up logger
 Smpp::Base.logger = Logger.new('smsc.log')

data/lib/smpp/base.rb

@@ -142,6 +142,7 @@ module Smpp
     private  
     def write_pdu(pdu)
       logger.debug "<- #{pdu.to_human}"
+      hex_debug pdu.data, "<- "
       send_data pdu.data
     end
 
@@ -155,11 +156,43 @@ module Smpp
         else
           logger.debug "-> " + pdu.to_human          
         end
+        hex_debug data, "-> "
       rescue Exception => ex
         logger.error "Exception while reading PDUs: #{ex} in #{ex.backtrace[0]}"
         raise
       end
       pdu
+    end
+
+    def hex_debug(data, prefix = "")
+      return unless @config[:hex_debug]
+      logger.debug do
+        message = "Hex dump follows:\n"
+        hexdump(data).each_line do |line| 
+          message << (prefix + line.chomp + "\n")
+        end
+        message
+      end
+    end
+
+    def hexdump(target)
+      width=16
+      group=2
+
+      output = ""
+      n=0
+      ascii=''
+      target.each_byte { |b|
+        if n%width == 0
+          output << "%s\n%08x: "%[ascii,n]
+          ascii='| '
+        end
+        output << "%02x"%b
+        output << ' ' if (n+=1)%group==0
+        ascii << "%s"%b.chr.tr('^ -~','.')
+      }
+      output << ' '*(((2+width-ascii.size)*(2*group+1))/group.to_f).ceil+ascii
+      output[1..-1]
     end    
   end
 end

data/lib/smpp/pdu/base.rb

@@ -61,8 +61,12 @@ module Smpp::Pdu
     CANCEL_SM_RESP        = 0X80000008 
     ENQUIRE_LINK          = 0X00000015 
     ENQUIRE_LINK_RESP     = 0X80000015
-    SUBMIT_MULTI	        = 0X00000021
+    SUBMIT_MULTI          = 0X00000021
     SUBMIT_MULTI_RESP     = 0X80000021
+
+    OPTIONAL_RECEIPTED_MESSAGE_ID = 0x001E
+    OPTIONAL_MESSAGE_STATE        = 0x0427
+
     # PDU sequence number. 
     @@seq = [Time.now.to_i]
 
@@ -95,7 +99,8 @@ module Smpp::Pdu
 
     # return int as binary string of 4 octets
     def fixed_int(value)
-      sprintf("%c%c%c%c", value >> 24, value >> 16, value >> 8, value & 0xff)
+      arr = [value >> 24, value >> 16, value >> 8, value & 0xff]
+      arr.pack("cccc")
     end
 
     def next_sequence_number
@@ -103,7 +108,7 @@ module Smpp::Pdu
     end
 
     def Base.next_sequence_number
-      @@seq.synchronize do 
+      @@seq.synchronize do
         (@@seq[0] += 1) % 512
       end
     end
@@ -122,13 +127,13 @@ module Smpp::Pdu
       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#{cmd.to_s(16)}"
+        Smpp::Base.logger.error "Unknown PDU: #{"0x%08x" % cmd}"
         return nil
       end
     end
@@ -138,5 +143,18 @@ module Smpp::Pdu
       @@cmd_map[command_id] = self
     end
 
+    def Base.optional_parameters(remaining_bytes)
+      optionals = {}
+      while not remaining_bytes.empty?
+        optional = {}
+        tag, optional[:length], remaining_bytes = remaining_bytes.unpack('H4na*')
+        optional[:tag] = tag.hex
+        optional[:value] = remaining_bytes.slice!(0...optional[:length])
+        optionals[tag.hex] = optional
+      end
+      
+      return optionals
+    end
+
   end
 end

data/lib/smpp/pdu/deliver_sm.rb

@@ -4,7 +4,8 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
   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
+              :sm_default_msg_id, :sm_length, :stat, :msg_reference, :udh, :short_message,
+              :message_state, :receipted_message_id, :optional_parameters
 
   def initialize(source_addr, destination_addr, short_message, options={}, seq=nil) 
     
@@ -32,6 +33,9 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
     #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,
@@ -62,8 +66,26 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
     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}"
+    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] = 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
+
+
 
     #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"
@@ -73,10 +95,20 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
     # 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
-      options[:msg_reference] = short_message.scanf('id:%s').to_s
-      # @stat must be parsed according to the SMSC vendor's specifications (see comment above)
-      options[:stat] = 0
-    end
+      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    
     
     new(source_addr, destination_addr, short_message, options, seq) 
   end

data/lib/smpp/server.rb

@@ -1,4 +1,8 @@
-# the opposite of a client-based receiver, the server transmitter waill send
+# --------
+# This is experimental stuff submitted by taryn@taryneast.org
+# --------
+
+# the opposite of a client-based receiver, the server transmitter will send
 # out MOs to the client when set up
 class Smpp::Server < Smpp::Base
 

data/lib/smpp/transceiver.rb

@@ -5,9 +5,10 @@
 # The transceiver accepts a delegate object that may implement 
 # the following (all optional) methods:
 #
-#   mo_received(transceiver, source_addr, destination_addr, short_message)
-#   delivery_report_received(transceiver, msg_reference, stat, pdu)
-#   message_accepted(transceiver, mt_message_id, smsc_message_id)
+#   mo_received(transceiver, pdu)
+#   delivery_report_received(transceiver, pdu)
+#   message_accepted(transceiver, mt_message_id, pdu)
+#   message_rejected(transceiver, mt_message_id, pdu)
 #   bound(transceiver)
 #   unbound(transceiver)
 
@@ -31,7 +32,7 @@ class Smpp::Transceiver < Smpp::Base
   end
 
   # Send an MT SMS message. Delegate will receive message_accepted callback when SMSC 
-  # acknowledges. 
+  # acknowledges, or the message_rejected callback upon error
   def send_mt(message_id, source_addr, destination_addr, short_message, options={})
     logger.debug "Sending MT: #{short_message}"
     if @state == :bound
@@ -106,12 +107,12 @@ class Smpp::Transceiver < Smpp::Base
       if pdu.esm_class != 4
         # MO message
         if @delegate.respond_to?(:mo_received)
-          @delegate.mo_received(self, pdu.source_addr, pdu.destination_addr, pdu.short_message)
+          @delegate.mo_received(self, pdu)
         end
       else
         # Delivery report
         if @delegate.respond_to?(:delivery_report_received)
-          @delegate.delivery_report_received(self, pdu.msg_reference.to_s, pdu.stat, pdu)
+          @delegate.delivery_report_received(self, pdu)
         end
       end     
     when Pdu::BindTransceiverResponse
@@ -141,10 +142,13 @@ class Smpp::Transceiver < Smpp::Base
       end
       if pdu.command_status != Pdu::Base::ESME_ROK
         logger.error "Error status in SubmitSmResponse: #{pdu.command_status}"
+        if @delegate.respond_to?(:message_rejected)
+          @delegate.message_rejected(self, mt_message_id, pdu)
+        end
       else
         logger.info "Got OK SubmitSmResponse (#{pdu.message_id} -> #{mt_message_id})"
         if @delegate.respond_to?(:message_accepted)
-          @delegate.message_accepted(self, mt_message_id, pdu.message_id)
+          @delegate.message_accepted(self, mt_message_id, pdu)
         end        
       end
       # Now we got the SMSC message id; create pending delivery report.
@@ -156,10 +160,13 @@ class Smpp::Transceiver < Smpp::Base
       end
       if pdu.command_status != Pdu::Base::ESME_ROK
         logger.error "Error status in SubmitMultiResponse: #{pdu.command_status}"
+        if @delegate.respond_to?(:message_rejected)
+          @delegate.message_rejected(self, mt_message_id, pdu)
+        end
       else
         logger.info "Got OK SubmitMultiResponse (#{pdu.message_id} -> #{mt_message_id})"
         if @delegate.respond_to?(:message_accepted)
-          @delegate.message_accepted(self, mt_message_id, pdu.message_id)
+          @delegate.message_accepted(self, mt_message_id, pdu)
         end
       end
     else

data/ruby-smpp.gemspec

@@ -1,36 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{ruby-smpp}
-  s.version = "0.1.2"
+  s.version = "0.1.3.pre1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["August Z. Flatby"]
-  s.date = %q{2009-01-04}
-  s.description = %q{Ruby-implementation of the SMPP protocol, based on EventMachine. SMPP is a protocol that allows ordinary people outside the mobile network to exchange SMS messages directly with mobile operators.}
-  s.email = ["august@apparat.no"]
-  s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "README.txt", "CONTRIBUTORS.txt"]
-  s.files = ["History.txt", "License.txt", "Manifest.txt", "README.txt", "CONTRIBUTORS.txt", "Rakefile", "examples/PDU1.example", "examples/PDU2.example", "examples/sample_gateway.rb", "examples/sample_smsc.rb", "config/hoe.rb", "config/requirements.rb", "lib/smpp.rb", "lib/smpp/base.rb", "lib/smpp/pdu/base.rb", "lib/smpp/pdu/bind_base.rb", "lib/smpp/pdu/bind_receiver.rb", "lib/smpp/pdu/bind_receiver_response.rb", "lib/smpp/pdu/bind_resp_base.rb", "lib/smpp/pdu/bind_transceiver.rb", "lib/smpp/pdu/bind_transceiver_response.rb", "lib/smpp/pdu/bind_transmitter.rb", "lib/smpp/pdu/bind_transmitter_response.rb", "lib/smpp/pdu/deliver_sm.rb", "lib/smpp/pdu/deliver_sm_response.rb", "lib/smpp/pdu/enquire_link.rb", "lib/smpp/pdu/enquire_link_response.rb", "lib/smpp/pdu/generic_nack.rb", "lib/smpp/pdu/submit_multi.rb", "lib/smpp/pdu/submit_multi_response.rb", "lib/smpp/pdu/submit_sm.rb", "lib/smpp/pdu/submit_sm_response.rb", "lib/smpp/pdu/unbind.rb", "lib/smpp/pdu/unbind_response.rb", "lib/smpp/server.rb", "lib/smpp/transceiver.rb", "lib/smpp/version.rb", "lib/sms.rb", "script/console", "script/destroy", "script/generate", "script/txt2html", "setup.rb", "tasks/deployment.rake", "tasks/environment.rake", "test/smpp_test.rb", "test/test_helper.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://ruby-smpp.rubyforge.org}
-  s.rdoc_options = ["--main", "README.txt"]
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ray Krueger", "August Z. Flatby"]
+  s.date = %q{2010-02-05}
+  s.description = %q{Ruby implementation of the SMPP protocol, based on EventMachine. SMPP is a protocol that allows ordinary people outside the mobile network to exchange SMS messages directly with mobile operators.}
+  s.email = %q{raykrueger@gmail.com}
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "CONTRIBUTORS.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "CONTRIBUTORS.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/PDU1.example",
+     "examples/PDU2.example",
+     "examples/sample_gateway.rb",
+     "examples/sample_smsc.rb",
+     "lib/smpp.rb",
+     "lib/smpp/base.rb",
+     "lib/smpp/pdu/base.rb",
+     "lib/smpp/pdu/bind_base.rb",
+     "lib/smpp/pdu/bind_resp_base.rb",
+     "lib/smpp/pdu/bind_transceiver.rb",
+     "lib/smpp/pdu/bind_transceiver_response.rb",
+     "lib/smpp/pdu/deliver_sm.rb",
+     "lib/smpp/pdu/deliver_sm_response.rb",
+     "lib/smpp/pdu/enquire_link.rb",
+     "lib/smpp/pdu/enquire_link_response.rb",
+     "lib/smpp/pdu/generic_nack.rb",
+     "lib/smpp/pdu/submit_multi.rb",
+     "lib/smpp/pdu/submit_multi_response.rb",
+     "lib/smpp/pdu/submit_sm.rb",
+     "lib/smpp/pdu/submit_sm_response.rb",
+     "lib/smpp/pdu/unbind.rb",
+     "lib/smpp/pdu/unbind_response.rb",
+     "lib/smpp/server.rb",
+     "lib/smpp/transceiver.rb",
+     "lib/sms.rb",
+     "ruby-smpp.gemspec",
+     "test/smpp_test.rb"
+  ]
+  s.homepage = %q{http://github.com/raykrueger/ruby-smpp}
+  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{ruby-smpp}
-  s.rubygems_version = %q{1.3.0}
-  s.summary = %q{Ruby-implementation of the SMPP protocol, based on EventMachine. SMPP is a protocol that allows ordinary people outside the mobile network to exchange SMS messages directly with mobile operators.}
-  s.test_files = ["test/test_helper.rb"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ruby implementation of the SMPP protocol, based on EventMachine.}
+  s.test_files = [
+    "test/smpp_test.rb",
+     "examples/sample_gateway.rb",
+     "examples/sample_smsc.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<eventmachine>, [">= 0.10.0"])
-      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     else
       s.add_dependency(%q<eventmachine>, [">= 0.10.0"])
-      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     end
   else
     s.add_dependency(%q<eventmachine>, [">= 0.10.0"])
-    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
   end
 end
+

data/test/smpp_test.rb

@@ -1,75 +1,179 @@
-$:.unshift File.dirname(__FILE__) + '/../lib/'
-
 require 'rubygems'
 require 'test/unit'
-require 'stringio'
 require 'smpp'
 
 # a server which immediately requests the client to unbind
-module Server1  
-  def receive_data(data)
-    send_data Smpp::Pdu::Unbind.new.data    
+module Server
+  def self.config
+    {
+      :host => 'localhost',
+      :port => 2775,
+      :system_id => 'foo',
+      :password => 'bar',
+      :system_type => '',
+      :source_ton  => 0,
+      :source_npi => 1,
+      :destination_ton => 1,
+      :destination_npi => 1,
+      :source_address_range => '',
+      :destination_address_range => ''
+    }
   end
-end
 
-module Server2
-  def receive_data(data)
-    # problem: our Pdu's should have factory methods for "both ways"; ie. when created 
-    # by client, and when created from wire data.
-    send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+  module Unbind
+    def receive_data(data)
+      send_data Smpp::Pdu::Unbind.new.data
+    end
   end
+
+  module SubmitSmResponse
+    def receive_data(data)
+      # problem: our Pdu's should have factory methods for "both ways"; ie. when created
+      # by client, and when created from wire data.
+      send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+    end
+  end
+
+  module SubmitSmResponseWithErrorStatus
+    attr_reader :state #state=nil => bind => state=bound => send =>state=sent => unbind => state=unbound
+    def receive_data(data)
+      if @state.nil?
+        @state = 'bound'
+        pdu = Smpp::Pdu::Base.create(data)
+        response_pdu = Smpp::Pdu::BindTransceiverResponse.new(pdu.sequence_number,Smpp::Pdu::Base::ESME_ROK,Server::config[:system_id])
+        send_data response_pdu.data
+      elsif @state == 'bound'
+        @state = 'sent'
+        pdu = Smpp::Pdu::Base.create(data)
+        pdu.to_human
+        send_data Smpp::Pdu::SubmitSmResponse.new(pdu.sequence_number, Smpp::Pdu::Base::ESME_RINVDSTADR, pdu.body).data
+        #send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+      elsif @state == 'sent'
+        @state = 'unbound'
+        send_data Smpp::Pdu::Unbind.new.data
+      else
+        raise "unexpected state"
+      end
+    end
+  end
+
 end
 
+
 # the delagate receives callbacks when interesting things happen on the connection
 class Delegate
-  def mo_received(transceiver, source_addr, destination_addr, short_message)
+
+  def mo_received(transceiver, pdu)
+    puts "** mo_received"
+  end
+
+  def delivery_report_received(transceiver, pdu)
+    puts "** delivery_report_received"
+  end
+
+  def message_accepted(transceiver, mt_message_id, pdu)
+    puts "** message_sent"
+  end
+
+  def message_rejected(transceiver, mt_message_id, pdu)
+    puts "** message_rejected"
+  end
+
+  def bound(transceiver)
+    puts "** bound"
+  end
+
+  def unbound(transceiver)
+    puts "** unbound"
+    EventMachine::stop_event_loop
+  end
+end
+
+#TODO This should be made prettier with mocha
+class ResponsiveDelegate
+  attr_reader :seq, :event_counter
+
+  def initialize
+    @seq = 0
+    @event_counter = nil
+  end
+  def seq
+    @seq += 1
+  end
+  def count_function
+    func = caller(1)[0].split("`")[1].split("'")[0].to_sym
+    @event_counter = {} unless @event_counter.is_a?(Hash)
+    @event_counter[func] = 0 if @event_counter[func].nil?
+    @event_counter[func]+=1
+  end
+
+  def mo_received(transceiver, pdu)
+    count_function
     puts "** mo_received"
   end
   
-  def delivery_report_received(transceiver, msg_reference, stat, pdu)
+  def delivery_report_received(transceiver, pdu)
+    count_function
     puts "** delivery_report_received"
   end
   
-  def message_accepted(transceiver, mt_message_id, smsc_message_id)
+  def message_accepted(transceiver, mt_message_id, pdu)
+    count_function
     puts "** message_sent"
+    #sending messages from delegate to escape making a fake message sender - not nice :(
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_accepted")
+  end
+
+  def message_rejected(transceiver, mt_message_id, pdu)
+    count_function
+    puts "** message_rejected"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_rejected")
   end
   
   def bound(transceiver)
+    count_function
     puts "** bound"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ bound")
   end
   
-  def unbound(transceiver)  
+  def unbound(transceiver)
+    count_function
     puts "** unbound"
     EventMachine::stop_event_loop
   end
 end
 
+class Poller
+  def start
+    
+  end
+end
+
+
 class SmppTest < Test::Unit::TestCase
   
   def config
-    {
-      :host => 'localhost',
-      :port => 2775,
-      :system_id => 'foo',
-      :password => 'bar',
-      :system_type => '',
-      :source_ton  => 0,
-      :source_npi => 1,
-      :destination_ton => 1,
-      :destination_npi => 1,
-      :source_address_range => '',
-      :destination_address_range => ''
-    }
+    Server::config
   end
   
   def test_transceiver_should_bind_and_unbind_then_stop
     EventMachine.run {
-      EventMachine.start_server "localhost", 9000, Server1
+      EventMachine.start_server "localhost", 9000, Server::Unbind
       EventMachine.connect "localhost", 9000, Smpp::Transceiver, config, Delegate.new
     }
     # should not hang here: the server's response should have caused the client to terminate
   end
 
+  def test_transceiver_api_should_respond_to_message_rejected
+    $tx = nil
+    delegate = ResponsiveDelegate.new
+    EventMachine.run {
+      EventMachine.start_server "localhost", 9000, Server::SubmitSmResponseWithErrorStatus
+      $tx = EventMachine.connect "localhost", 9000, Smpp::Transceiver, config, delegate
+    }
+    assert_equal(delegate.event_counter[:message_rejected], 1)
+  end
+
   def test_bind_transceiver
     pdu1 = Smpp::Pdu::BindTransceiver.new(
       config[:system_id],
@@ -158,6 +262,11 @@ class SmppTest < Test::Unit::TestCase
     assert_equal(pdu1.command_status, pdu2.command_status)
   end
 
+  def test_submit_sm_receiving_invalid_status
+    pdu1 = Smpp::Pdu::SubmitSm.new( '11111', '1111111111', "This is a test" )
+    pdu2 = Smpp::Pdu::Base.create(pdu1.data)
+  end
+
   def test_deliver_sm_response
     pdu1 = Smpp::Pdu::DeliverSmResponse.new( nil )
     pdu2 = Smpp::Pdu::Base.create(pdu1.data)
@@ -256,5 +365,13 @@ class SmppTest < Test::Unit::TestCase
     assert_equal(pdu1.sequence_number, pdu2.sequence_number)
     assert_equal(pdu1.command_status, pdu2.command_status)
   end
+  
+  def test_should_parse_ref_and_stat_from_deliver_sm
+    direct = Smpp::Pdu::DeliverSm.new( '1', '2', "419318028472222#id:11f8f46639bd4f7a209016e1a181e3ae sub:001 dlvrd:001 submit date:0902191702 done date:0902191702 stat:DELIVRD err:000 Text:TVILLING: Sl? ut h?'!11f8f46639bd4f7a209016e1a181e3ae", :esm_class => 4)
+    parsed = Smpp::Pdu::Base.create(direct.data)
+    assert_equal("DELIVRD", parsed.stat)
+    assert_equal("11f8f46639bd4f7a209016e1a181e3ae", parsed.msg_reference)
+  end
+  
 
 end