anjlab-ruby-smpp 0.6.0

data/lib/smpp/pdu/enquire_link.rb

@@ -0,0 +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

@@ -0,0 +1,11 @@
+class Smpp::Pdu::EnquireLinkResponse < Smpp::Pdu::Base
+  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

@@ -0,0 +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 = 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

@@ -0,0 +1,68 @@
+# 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  
+
+  # Note: short_message (the SMS body) must be in iso-8859-1 format
+  def initialize(source_addr, destination_addr_array, short_message, options={})
+    options.merge!(
+      :esm_class => 0,    # default smsc mode
+      :dcs => 3           # iso-8859-1
+    ) { |key, old_val, new_val| old_val } 
+  
+    @msg_body = short_message
+    
+    udh = options[:udh]          
+    service_type            = ''
+    source_addr_ton         = 0 # network specific
+    source_addr_npi         = 1 # unknown
+    number_of_dests         = destination_addr_array.length # Max value can be 254
+    dest_addr_ton           = 1 # international
+    dest_addr_npi           = 1 # unknown
+    dest_addresses          = build_destination_addresses(destination_addr_array,dest_addr_ton,dest_addr_npi,IS_SMEADDR) 
+    esm_class               = options[:esm_class]
+    protocol_id             = 0
+    priority_flag           = 0
+    schedule_delivery_time  = ''
+    validity_period         = ''
+    registered_delivery     = 1 # we want delivery notifications
+    replace_if_present_flag = 0
+    data_coding             = options[:dcs]
+    sm_default_msg_id       = 0
+    payload                 = udh ? udh + short_message : short_message # this used to be (short_message + "\0")
+    sm_length               = payload.length
+    
+    # craft the string/byte buffer
+    pdu_body = sprintf("%s\0%c%c%s\0%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, number_of_dests,dest_addresses, 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_MULTI, 0, next_sequence_number, pdu_body)        
+  end
+  
+  # some special formatting is needed for SubmitSm PDUs to show the actual message content
+  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], @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)
+
+      elsif dest_flag == IS_DISTLISTNAME
+        packet_str = sprintf("%c%s",IS_SMEADDR,dest_elem)
+                          formatted_array.push(packet_str)
+
+      end
+
+    }
+
+    formatted_array.join("\0");
+  end
+  
+end

data/lib/smpp/pdu/submit_multi_response.rb

@@ -0,0 +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
+  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

@@ -0,0 +1,91 @@
+# 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, :optional_parameters
+
+  
+  # Note: short_message (the SMS body) must be in iso-8859-1 format
+  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
+    @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 + @short_message : @short_message 
+    @sm_length               = payload.length
+    
+    @optional_parameters     = options[:optional_parameters]
+    
+    # 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)
+
+    if @optional_parameters
+      pdu_body << optional_parameters_to_buffer(@optional_parameters)
+    end
+
+    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
+  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], @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], 
+    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)
+
+    Smpp::Base.logger.debug "SubmitSM 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

@@ -0,0 +1,31 @@
+class Smpp::Pdu::SubmitSmResponse < Smpp::Pdu::Base
+  handles_cmd SUBMIT_SM_RESP
+
+  attr_accessor :message_id
+  attr_accessor :optional_parameters
+
+  def initialize(seq, status, message_id, optional_parameters=nil)
+    seq ||= next_sequence_number
+    body = message_id.to_s + "\000"
+    super(SUBMIT_SM_RESP, status, seq, body)
+    @message_id = message_id
+    @optional_parameters = optional_parameters
+  end
+
+  def optional_parameter(tag)
+    if optional_parameters 
+      if param = optional_parameters[tag]
+        param.value
+      end
+    end
+  end
+
+  def self.from_wire_data(seq, status, body)
+    message_id, remaining_bytes = body.unpack("Z*a*")
+    optionals = nil
+    if remaining_bytes && !remaining_bytes.empty?
+      optionals = parse_optional_parameters(remaining_bytes)
+    end
+    new(seq, status, message_id, optionals)
+  end
+end

data/lib/smpp/pdu/unbind.rb

@@ -0,0 +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

@@ -0,0 +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

data/lib/smpp/receiver.rb

@@ -0,0 +1,27 @@
+# The SMPP Receiver maintains a unidirectional 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 receiver accepts a delegate object that may implement 
+# the following (all optional) methods:
+#
+#   mo_received(receiver, pdu)
+#   delivery_report_received(receiver, pdu)
+#   bound(receiver)
+#   unbound(receiver)
+
+class Smpp::Receiver < Smpp::Base
+
+  # Send BindReceiverResponse PDU.
+  def send_bind
+    raise IOError, 'Receiver already bound.' unless unbound?
+    pdu = Pdu::BindReceiver.new(
+        @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/server.rb

@@ -0,0 +1,223 @@
+# --------
+# 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
+
+  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
+    
+    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