anjlab-ruby-smpp 0.6.0

data/examples/sample_smsc.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+# Sample SMPP SMS Gateway. 
+
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/smpp'
+require File.dirname(__FILE__) + '/../lib/smpp/server'
+
+# set up logger
+Smpp::Base.logger = Logger.new('smsc.log')
+
+# the transceiver
+$tx = nil
+
+# We use EventMachine to receive keyboard input (which we send as MT messages).
+# A "real" gateway would probably get its MTs from a message queue instead.
+module KeyboardHandler
+  include EventMachine::Protocols::LineText2
+
+  def receive_line(data)
+    puts "Sending MO: #{data}"
+    from = '1111111111'
+    to = '1111111112'       
+    $tx.send_mo(from, to, data)
+
+
+# if you want to send messages with custom options, uncomment below code, this configuration allows the sender ID to be alpha numeric
+#    $tx.send_mt(123, "RubySmpp", to, "Testing RubySmpp as sender id",{
+#    :source_addr_ton=> 5,
+#	:service_type => 1,
+#	:source_addr_ton => 5,
+#	:source_addr_npi => 0 ,
+#	:dest_addr_ton => 2, 
+#	:dest_addr_npi => 1, 
+#	:esm_class => 3 ,
+#	:protocol_id => 0, 
+#	:priority_flag => 0,
+#	:schedule_delivery_time => nil,
+#	:validity_period => nil,
+#	:registered_delivery=> 1,
+#	:replace_if_present_flag => 0,
+#	:data_coding => 0,
+#	:sm_default_msg_id => 0 
+#     })   
+
+# if you want to send message to multiple destinations , uncomment below code
+#    $tx.send_multi_mt(123, from, ["919900000001","919900000002","919900000003"], "I am echoing that ruby-smpp is great")  
+    prompt
+  end
+end
+
+def prompt
+  print "Enter MO body: "
+  $stdout.flush
+end
+
+def logger
+  Smpp::Base.logger
+end
+
+def start(config)
+
+  # Run EventMachine in loop so we can reconnect when the SMSC drops our connection.
+  loop do
+    EventMachine::run do             
+      $tx = EventMachine::start_server(
+          config[:host], 
+          config[:port], 
+          Smpp::Server,
+          config
+          )       
+    end
+    logger.warn "Event loop stopped. Restarting in 5 seconds.."
+    sleep 5
+  end
+end
+
+# Start the Gateway
+begin   
+  puts "Starting SMS Gateway"  
+
+  # SMPP properties. These parameters the ones provided sample_gateway.rb and
+  # will work with it.
+  config = {
+    :host => 'localhost',
+    :port => 6000,
+    :system_id => 'hugo',
+    :password => 'ggoohu',
+	  :system_type => 'vma', # default given according to SMPP 3.4 Spec
+    :interface_version => 52,
+    :source_ton  => 0,
+    :source_npi => 1,
+    :destination_ton => 1,
+    :destination_npi => 1,
+    :source_address_range => '',
+    :destination_address_range => '',
+    :enquire_link_delay_secs => 10
+  }
+  start(config)  
+rescue Exception => ex
+  puts "Exception in SMS Gateway: #{ex} at #{ex.backtrace[0]}"
+end

data/lib/smpp.rb

@@ -0,0 +1,25 @@
+# SMPP v3.4 subset implementation.
+# SMPP is a short message peer-to-peer protocol typically used to communicate 
+# with SMS Centers (SMSCs) over TCP/IP.
+#
+# August Z. Flatby
+# august@apparat.no
+
+require 'logger'
+
+$:.unshift(File.dirname(__FILE__))
+require 'smpp/base.rb'
+require 'smpp/transceiver.rb'
+require 'smpp/receiver.rb'
+require 'smpp/optional_parameter'
+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|
+  require f unless f.match('base.rb$')
+end
+
+# Default logger. Invoke this call in your client to use another logger.
+Smpp::Base.logger = Logger.new(STDOUT)

data/lib/smpp/base.rb

@@ -0,0 +1,308 @@
+require 'timeout'
+require 'scanf'
+require 'monitor'
+require 'eventmachine'
+
+module Smpp
+  class InvalidStateException < Exception; end
+    
+  class Base < EventMachine::Connection
+    include Smpp
+    
+    # :bound or :unbound
+    attr_accessor :state
+    
+    def initialize(config, delegate)
+      @state = :unbound
+      @config = config
+      @data = ""
+      @delegate = delegate
+
+      # 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 = {}
+
+      ed = @config[:enquire_link_delay_secs] || 5
+      comm_inactivity_timeout = 2 * ed
+    end
+
+    # queries the state of the transmitter - is it bound?
+    def unbound?
+      @state == :unbound
+    end
+    
+    def bound?
+      @state == :bound
+    end
+    
+    def Base.logger
+      @@logger
+    end
+
+    def Base.logger=(logger)
+      @@logger = logger
+    end
+
+    def logger
+      @@logger
+    end
+    
+    
+    # invoked by EventMachine when connected
+    def post_init
+      # send Bind PDU if we are a binder (eg
+      # Receiver/Transmitter/Transceiver
+      send_bind unless defined?(am_server?) && am_server?
+
+      # start timer that will periodically send enquire link PDUs
+      start_enquire_link_timer(@config[:enquire_link_delay_secs]) if @config[:enquire_link_delay_secs]
+    rescue Exception => ex
+      logger.error "Error starting RX: #{ex.message} at #{ex.backtrace[0]}"
+    end
+
+    # sets up a periodic timer that will periodically enquire as to the
+    # state of the connection
+    # Note: to add in custom executable code (that only runs on an open
+    # connection), derive from the appropriate Smpp class and overload the
+    # method named: periodic_call_method
+    def start_enquire_link_timer(delay_secs)
+      logger.info "Starting enquire link timer (with #{delay_secs}s interval)"
+      EventMachine::PeriodicTimer.new(delay_secs) do 
+        if error?
+          logger.warn "Link timer: Connection is in error state. Disconnecting."
+          close_connection
+        elsif unbound?
+          logger.warn "Link is unbound, waiting until next #{delay_secs} interval before querying again"
+        else
+
+          # if the user has defined a method to be called periodically, do
+          # it now - and continue if it indicates to do so
+          rval = defined?(periodic_call_method) ? periodic_call_method : true
+
+          # only send an OK if this worked
+          write_pdu Pdu::EnquireLink.new if rval 
+        end
+      end
+    end
+
+    # EventMachine::Connection#receive_data
+    def receive_data(data)
+      #append data to buffer
+      @data << data
+
+      while (@data.length >=4)
+        cmd_length = @data[0..3].unpack('N').first
+        if(@data.length < cmd_length)
+          #not complete packet ... break
+          break
+        end
+
+        pkt = @data.slice!(0,cmd_length)
+
+        begin
+          # parse incoming PDU
+          pdu = read_pdu(pkt)
+
+          # let subclass process it
+          process_pdu(pdu) if pdu
+        rescue Exception => e
+          logger.error "Error receiving data: #{e}\n#{e.backtrace.join("\n")}"
+          if @delegate.respond_to?(:data_error)
+            @delegate.data_error(e)
+          end
+        end
+
+      end
+    end
+    
+    # EventMachine::Connection#unbind
+    # Invoked by EM when connection is closed. Delegates should consider
+    # breaking the event loop and reconnect when they receive this callback.
+    def unbind
+      if @delegate.respond_to?(:unbound)
+        @delegate.unbound(self)
+      end
+    end
+    
+    def send_unbind
+      write_pdu Pdu::Unbind.new
+      @state = :unbound
+    end
+
+    # process common PDUs
+    # returns true if no further processing necessary
+    def process_pdu(pdu)      
+      case pdu
+      when Pdu::EnquireLinkResponse
+        # nop
+      when Pdu::EnquireLink
+        write_pdu(Pdu::EnquireLinkResponse.new(pdu.sequence_number))
+      when Pdu::Unbind
+        @state = :unbound
+        write_pdu(Pdu::UnbindResponse.new(pdu.sequence_number, Pdu::Base::ESME_ROK))
+        close_connection
+      when Pdu::UnbindResponse      
+        logger.info "Unbound OK. Closing connection."
+        close_connection
+      when Pdu::GenericNack
+        logger.warn "Received NACK! (error code #{pdu.error_code})."
+        # we don't take this lightly: close the connection
+        close_connection
+      when Pdu::DeliverSm
+        begin
+          logger.debug "ESM CLASS #{pdu.esm_class}"
+          if pdu.esm_class != 4
+            # MO message
+            if @delegate.respond_to?(:mo_received)
+              @delegate.mo_received(self, pdu)
+            end
+          else
+            # Delivery report
+            if @delegate.respond_to?(:delivery_report_received)
+              @delegate.delivery_report_received(self, pdu)
+            end
+          end     
+          write_pdu(Pdu::DeliverSmResponse.new(pdu.sequence_number))
+        rescue => e
+          logger.warn "Send Receiver Temporary App Error due to #{e.inspect} raised in delegate"
+          write_pdu(Pdu::DeliverSmResponse.new(pdu.sequence_number, Pdu::Base::ESME_RX_T_APPN))
+        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."
+          # 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."
+          close_connection
+        else
+          logger.warn "Unexpected BindTransceiverResponse. Command status: #{pdu.command_status}"
+          close_connection
+        end
+      when Pdu::SubmitSmResponse
+        mt_message_id = @ack_ids.delete(pdu.sequence_number)
+        if !mt_message_id
+          raise "Got SubmitSmResponse for unknown sequence_number: #{pdu.sequence_number}"
+        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)
+          end        
+        end
+      when Pdu::SubmitMultiResponse
+        mt_message_id = @ack_ids[pdu.sequence_number]
+        if !mt_message_id
+          raise "Got SubmitMultiResponse for unknown sequence_number: #{pdu.sequence_number}"
+        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)
+          end
+        end
+      when Pdu::BindReceiverResponse
+        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."
+          # 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."
+          close_connection
+        else
+          logger.warn "Unexpected BindReceiverResponse. Command status: #{pdu.command_status}"
+          close_connection
+        end
+      else
+        logger.warn "(#{self.class.name}) Received unexpected PDU: #{pdu.to_human}."
+        close_connection
+      end
+    end
+
+    private  
+    def write_pdu(pdu)
+      logger.debug "<- #{pdu.to_human}"
+      hex_debug pdu.data, "<- "
+      send_data pdu.data
+    end
+
+    def read_pdu(data)
+      pdu = nil
+      # we may either receive a new request or a response to a previous response.
+      begin        
+        pdu = Pdu::Base.create(data)
+        if !pdu
+          logger.warn "Not able to parse PDU!"
+        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 = "")
+      Base.hex_debug(data, prefix)
+    end
+
+    def Base.hex_debug(data, prefix = "")
+      logger.debug do
+        message = "Hex dump follows:\n"
+        hexdump(data).each_line do |line| 
+          message << (prefix + line.chomp + "\n")
+        end
+        message
+      end
+    end
+
+    def Base.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/encoding/utf8_encoder.rb

@@ -0,0 +1,37 @@
+require 'iconv'
+
+module Smpp
+  module Encoding
+
+    # This class is not required by smpp.rb at all, you need to bring it in yourself.
+    # This class also requires iconv, you'll need to ensure it is installed.
+    class Utf8Encoder 
+
+      EURO_TOKEN = "_X_EURO_X_"
+
+      GSM_ESCAPED_CHARACTERS = {
+        ?(  => "\173", # {
+        ?)  => "\175", # }
+        184 => "\174", # |
+        ?<  => "\133", # [
+        ?>  => "\135", # ]
+        ?=  => "\176", # ~
+        ?/  => "\134", # \
+        134 => "\252", # ^
+        ?e  =>  EURO_TOKEN
+      }
+
+      def encode(data_coding, short_message)
+        if data_coding < 2
+          sm = short_message.gsub(/\215./) { |match| GSM_ESCAPED_CHARACTERS[match[1]] }
+          sm = Iconv.conv("UTF-8", "HP-ROMAN8", sm)
+          sm.gsub(EURO_TOKEN, "\342\202\254")
+        elsif data_coding == 8
+          Iconv.conv("UTF-8", "UTF-16BE", short_message)
+        else
+          short_message
+        end
+      end
+    end
+  end
+end