ruby-smpp 0.1.1 → 0.1.2

data/lib/smpp/server.rb

@@ -0,0 +1,224 @@
+# the opposite of a client-based receiver, the server transmitter waill send
+# out MOs to the client when set up
+class Smpp::Server < Smpp::Base
+
+  attr_accessor :bind_status
+
+  # Expects a config hash, 
+  # a proc to invoke for incoming (MO) messages,
+  # a proc to invoke for delivery reports,
+  # and optionally a hash-like storage for pending delivery reports.
+  def initialize(config, received_messages = [], sent_messages = [])
+    super(config)
+    @state = :unbound
+    @received_messages = received_messages
+    @sent_messages = sent_messages
+    
+    # Array of un-acked MT message IDs indexed by sequence number.
+    # As soon as we receive SubmitSmResponse we will use this to find the 
+    # associated message ID, and then create a pending delivery report.
+    @ack_ids = Array.new(512)         
+    
+    ed = @config[:enquire_link_delay_secs] || 5
+    comm_inactivity_timeout = [ed - 5, 3].max
+  rescue Exception => ex
+    logger.error "Exception setting up server: #{ex}"
+    raise
+  end
+
+  
+  #######################################################################
+  # Session management functions
+  #######################################################################
+  # Session helpers
+
+  # convenience methods
+  # is this session currently bound?
+  def bound?
+    @state == :bound
+  end
+  # is this session currently unbound?
+  def unbound?
+    @state == :unbound
+  end
+  # set of valid bind statuses
+  BIND_STATUSES = {:transmitter => :bound_tx, 
+           :receiver => :bound_rx, :transceiver => :bound_trx}
+  # set the bind status based on the common-name for the bind class
+  def set_bind_status(bind_classname)
+    @bind_status = BIND_STATUSES[bind_classname]
+  end
+  # and kill the bind status when done
+  def unset_bind_status
+    @bind_status = nil
+  end
+  # what is the bind_status?
+  def bind_status
+    @bind_status
+  end
+  # convenience function - are we able to transmit in this bind-Status?
+  def transmitting?
+    # not transmitting if not bound
+    return false if unbound? || bind_status.nil?
+    # receivers can't transmit
+    bind_status != :bound_rx
+  end
+  # convenience function - are we able to receive in this bind-Status?
+  def receiving?
+    # not receiving if not bound
+    return false if unbound? || bind_status.nil?
+    # transmitters can't receive
+    bind_status != :bound_tx
+  end
+
+  def am_server?
+    true
+  end
+
+  # REVISIT - not sure if these are using the correct data.  Currently just
+  # pulls the data straight out of the given pdu and sends it right back.
+  #
+  def fetch_bind_response_class(bind_classname)
+    # check we have a valid classname - probably overkill as only our code
+    # will send the classnames through
+    raise IOError, "bind class name missing" if bind_classname.nil?
+    raise IOError, "bind class name: #{bind_classname} unknown" unless BIND_STATUSES.has_key?(bind_classname)
+
+    case bind_classname
+    when :transceiver
+      return Smpp::Pdu::BindTransceiverResponse
+    when :transmitter
+      return Smpp::Pdu::BindTransmitterResponse
+    when :receiver
+      return Smpp::Pdu::BindReceiverResponse
+    end
+  end
+
+  # actually perform the action of binding the session to the given session
+  # type
+  def bind_session(bind_pdu, bind_classname)
+    # TODO: probably should not "raise" here - what's better?
+    raise IOError, "Session already bound." if bound?
+    response_class = fetch_bind_response_class(bind_classname)
+
+    # TODO: look inside the pdu for the password and check it
+
+    send_bind_response(bind_pdu, response_class)
+
+    @state = :bound
+    set_bind_status(bind_classname)
+  end
+
+  # Send BindReceiverResponse PDU - used in response to a "bind_receiver"
+  # pdu.
+  def send_bind_response(bind_pdu, bind_class)
+    resp_pdu = bind_class.new(
+                  bind_pdu.sequence_number, 
+                  # currently assume that it binds ok
+                  Pdu::Base::ESME_ROK, 
+                  # TODO: not sure where we get the system ID
+                  # is this the session id?
+                  bind_pdu.system_id)
+    write_pdu(resp_pdu)
+  end
+ 
+  #######################################################################
+  # Message submission (transmitter) functions (used by transmitter and
+  # transceiver-bound system) 
+  # Note - we only support submit_sm message type, not submit_multi or
+  # data_sm message types
+  #######################################################################
+  # Receive an incoming message to send to the network and respond
+  # REVISIT = just a stub
+  def receive_sm(pdu)
+    # TODO: probably should not "raise" here - what's better?
+    raise IOError, "Connection not bound." if unbound?
+    # Doesn't matter if it's a TX/RX/TRX, have to send a SubmitSmResponse:
+    # raise IOError, "Connection not set to receive" unless receiving?
+
+    # Must respond to SubmitSm requests with the same sequence number
+    m_seq = pdu.sequence_number
+    # add the id to the list of ids of which we're awaiting acknowledgement
+    @received_messages << m_seq
+
+    # In theory this is where the MC would actually do something useful with
+    # the PDU - eg send it on to the network. We'd check if it worked and
+    # send a failure PDU if it failed.
+    #
+    # Given this is a dummy MC, that's not necessary, so all our responses
+    # will be OK.
+
+    # so respond with a successful response
+    pdu = Pdu::SubmitSmResponse.new(m_seq, Pdu::Base::ESME_ROK, message_id = '' )
+    write_pdu pdu
+    @received_messages.delete m_seq
+    
+    logger.info "Received submit sm message: #{m_seq}"
+  end
+
+  #######################################################################
+  # Message delivery (receiver) functions (used by receiver and
+  # transceiver-bound system)
+  #######################################################################
+  # When we get an incoming SMS to send on to the client, we need to
+  # initiate one of these PDUs.
+  # Note - data doesn't have to be valid, as we're not really doing much
+  # useful with it. Only the params that will be pulled out by the test
+  # system need to be valid.
+  def deliver_sm(from, to, message, config = {})
+    # TODO: probably should not "raise" here - what's better?
+    raise IOError, "Connection not bound." if unbound?
+    raise IOError, "Connection not set to receive" unless receiving?
+    
+    # submit the given message
+    new_pdu = Pdu::DeliverSm.new(from, to, message, config)
+    write_pdu(new_pdu)
+    # add the id to the list of ids of which we're awaiting acknowledgement
+    @sent_messages << m_seq
+
+    logger.info "Delivered SM message id: #{m_seq}"
+
+    new_pdu
+  end
+
+  # Acknowledge delivery of an outgoing MO message
+  # REVISIT = just a stub
+  def accept_deliver_sm_response(pdu)
+    m_seq = pdu.sequence_number
+    # add the id to the list of ids we're awaiting acknowledgement of
+    # REVISIT - what id do we need to store?
+    unless @sent_messages && @sent_messages.include?(m_seq)
+      logger.error("Received deliver response for message for which we have no saved id: #{m_seq}")
+    else
+      @sent_messages.delete(m_seq)
+      logger.info "Acknowledged receipt of SM delivery message id: #{m_seq}"
+    end
+  end
+
+
+  # a PDU is received
+  # these pdus are all responses to a message sent by the client and require
+  # their own special response
+  def process_pdu(pdu)
+    case pdu
+    # client has asked to set up a connection
+    when Pdu::BindTransmitter
+      bind_session(pdu, :transmitter)
+    when Pdu::BindReceiver
+      bind_session(pdu, :receiver)
+    when Pdu::BindTransceiver
+      bind_session(pdu, :transceiver)
+    # client has acknowledged receipt of a message we sent to them
+    when Pdu::DeliverSmResponse
+      accept_deliver_sm_response(pdu) # acknowledge its sending
+
+    # client has asked for a message to be sent
+    when Pdu::SubmitSm
+      receive_sm(pdu)
+    else
+      # for generic functions or default fallback
+      super(pdu)
+    end 
+  end
+ 
+end

data/lib/smpp/transceiver.rb

@@ -1,15 +1,22 @@
+
+# The SMPP Transceiver maintains a bidirectional connection to an SMSC.
+# Provide a config hash with connection options to get started. 
+# See the sample_gateway.rb for examples of config values.
+# 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)
+#   bound(transceiver)
+#   unbound(transceiver)
+
 class Smpp::Transceiver < Smpp::Base
 
-  # Expects a config hash, 
-  # a proc to invoke for incoming (MO) messages,
-  # a proc to invoke for delivery reports,
-  # and optionally a hash-like storage for pending delivery reports.
-  def initialize(config, mo_proc, dr_proc, pdr_storage={})
+  def initialize(config, delegate, pdr_storage={})
     super(config)
-    @state = :unbound
-    @mo_proc = mo_proc
-    @dr_proc = dr_proc      
-    @pdr_storage = pdr_storage   
+    @delegate = delegate
+    @pdr_storage = pdr_storage
     
     # Array of un-acked MT message IDs indexed by sequence number.
     # As soon as we receive SubmitSmResponse we will use this to find the 
@@ -17,13 +24,14 @@ class Smpp::Transceiver < Smpp::Base
     @ack_ids = Array.new(512)         
     
     ed = @config[:enquire_link_delay_secs] || 5
-    comm_inactivity_timeout = [ed - 5, 3].max
+    comm_inactivity_timeout = 2 * ed
   rescue Exception => ex
-    logger.error "Exception setting up transceiver: #{ex}"
+    logger.error "Exception setting up transceiver: #{ex} at #{ex.backtrace.join("\n")}"
     raise
   end
 
-  # Send an MT SMS message
+  # Send an MT SMS message. Delegate will receive message_accepted callback when SMSC 
+  # acknowledges. 
   def send_mt(message_id, source_addr, destination_addr, short_message, options={})
     logger.debug "Sending MT: #{short_message}"
     if @state == :bound
@@ -37,6 +45,41 @@ class Smpp::Transceiver < Smpp::Base
       raise InvalidStateException, "Transceiver is unbound. Cannot send MT messages."
     end
   end
+
+  # Send a concatenated message with a body of > 160 characters as multiple messages.
+  def send_concat_mt(message_id, source_addr, destination_addr, message, options = {})
+    logger.debug "Sending concatenated MT: #{message}"
+    if @state == :bound
+      # Split the message into parts of 153 characters. (160 - 7 characters for UDH)
+      parts = []
+      while message.size > 0 do
+        parts << message.slice!(0..152)
+      end
+      
+      0.upto(parts.size-1) do |i|
+        udh = sprintf("%c", 5)            # UDH is 5 bytes.
+        udh << sprintf("%c%c", 0, 3)      # This is a concatenated message 
+        udh << sprintf("%c", message_id)  # The ID for the entire concatenated message
+        udh << sprintf("%c", parts.size)  # How many parts this message consists of
+        udh << sprintf("%c", i+1)         # This is part i+1
+        
+        options = {
+          :esm_class => 64,               # This message contains a UDH header.
+          :udh => udh 
+        }
+        
+        pdu = Pdu::SubmitSm.new(source_addr, destination_addr, parts[i], options)
+        write_pdu pdu
+        
+        # This is definately a bit hacky - multiple PDUs are being associated with a single
+        # message_id.
+        @ack_ids[pdu.sequence_number] = message_id
+      end
+    else
+      raise InvalidStateException, "Transceiver is unbound. Connot send MT messages."
+    end
+  end
+
   # Send  MT SMS message for multiple dest_address
   # Author: Abhishek Parolkar (abhishek[at]parolkar.com)
   # USAGE: $tx.send_multi_mt(123, "9100000000", ["9199000000000","91990000000001","9199000000002"], "Message here")
@@ -54,34 +97,42 @@ class Smpp::Transceiver < Smpp::Base
     end
   end
 
-
-  # a PDU is received
+  # a PDU is received. Parse it and invoke delegate methods.
   def process_pdu(pdu)
     case pdu
     when Pdu::DeliverSm
       write_pdu(Pdu::DeliverSmResponse.new(pdu.sequence_number))
       logger.debug "ESM CLASS #{pdu.esm_class}"
       if pdu.esm_class != 4
-        # MO message; invoke MO proc
-        @mo_proc.call(pdu.source_addr, pdu.destination_addr, pdu.short_message)
+        # MO message
+        if @delegate.respond_to?(:mo_received)
+          @delegate.mo_received(self, pdu.source_addr, pdu.destination_addr, pdu.short_message)
+        end
       else
-        # Invoke DR proc (let the owner of the block do the mapping from msg_reference to mt_id)
-        @dr_proc.call(pdu.msg_reference.to_s, pdu.stat)
+        # Delivery report
+        if @delegate.respond_to?(:delivery_report_received)
+          @delegate.delivery_report_received(self, pdu.msg_reference.to_s, pdu.stat, pdu)
+        end
       end     
     when Pdu::BindTransceiverResponse
       case pdu.command_status
       when Pdu::Base::ESME_ROK
         logger.debug "Bound OK."
         @state = :bound
+        if @delegate.respond_to?(:bound)
+          @delegate.bound(self)
+        end
       when Pdu::Base::ESME_RINVPASWD
         logger.warn "Invalid password."
-        EventMachine::stop_event_loop
+        # scheduele the connection to close, which eventually will cause the unbound() delegate 
+        # method to be invoked.
+        close_connection
       when Pdu::Base::ESME_RINVSYSID
         logger.warn "Invalid system id."
-        EventMachine::stop_event_loop
+        close_connection
       else
         logger.warn "Unexpected BindTransceiverResponse. Command status: #{pdu.command_status}"
-        EventMachine::stop_event_loop
+        close_connection
       end
     when Pdu::SubmitSmResponse
       mt_message_id = @ack_ids[pdu.sequence_number]
@@ -92,9 +143,12 @@ class Smpp::Transceiver < Smpp::Base
         logger.error "Error status in SubmitSmResponse: #{pdu.command_status}"
       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)
+        end        
       end
-      # Now we got the SMSC message id; create pending delivery report
-      @pdr_storage[pdu.message_id] = mt_message_id
+      # Now we got the SMSC message id; create pending delivery report.
+      @pdr_storage[pdu.message_id] = mt_message_id            
     when Pdu::SubmitMultiResponse
       mt_message_id = @ack_ids[pdu.sequence_number]
       if !mt_message_id
@@ -104,6 +158,9 @@ class Smpp::Transceiver < Smpp::Base
         logger.error "Error status in SubmitMultiResponse: #{pdu.command_status}"
       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)
+        end
       end
     else
       super
@@ -112,14 +169,14 @@ class Smpp::Transceiver < Smpp::Base
 
   # Send BindTransceiverResponse PDU.
   def send_bind
-    raise IOError, 'Receiver already bound.' unless @state == :unbound
+    raise IOError, 'Receiver already bound.' unless unbound?
     pdu = Pdu::BindTransceiver.new(
-    @config[:system_id], 
-    @config[:password],
-    @config[:system_type], 
-    @config[:source_ton], 
-    @config[:source_npi], 
-    @config[:source_address_range])
+        @config[:system_id], 
+        @config[:password],
+        @config[:system_type], 
+        @config[:source_ton], 
+        @config[:source_npi], 
+        @config[:source_address_range])
     write_pdu(pdu)
   end
 end

data/lib/smpp/version.rb

@@ -2,7 +2,7 @@ module Smpp #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/smpp.rb

@@ -11,6 +11,8 @@ $:.unshift(File.dirname(__FILE__))
 require 'smpp/base.rb'
 require 'smpp/transceiver.rb'
 require 'smpp/pdu/base.rb'
+require 'smpp/pdu/bind_base.rb'
+require 'smpp/pdu/bind_resp_base.rb'
 
 # Load all PDUs
 Dir.glob(File.join(File.dirname(__FILE__), 'smpp', 'pdu', '*.rb')) do |f|
@@ -18,4 +20,4 @@ Dir.glob(File.join(File.dirname(__FILE__), 'smpp', 'pdu', '*.rb')) do |f|
 end
 
 # Default logger. Invoke this call in your client to use another logger.
-Smpp::Base.logger = Logger.new(STDOUT)
+Smpp::Base.logger = Logger.new(STDOUT)

data/ruby-smpp.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name = %q{ruby-smpp}
+  s.version = "0.1.2"
+
+  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.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"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    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"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0.10.0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0.10.0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end