empp 0.0.3

data/lib/empp/msg_connect_resp.rb

@@ -0,0 +1,22 @@
+require 'empp/empp_base'
+require 'empp/constants'
+
+module Empp
+  
+  class MsgConnectResp < EmppBase
+
+    attr_accessor :status
+  
+    def initialize
+      @command_id = Constants::EMPP_CONNECT_RESP
+      @status = nil
+    end
+
+    def to_s
+      str = super
+      str + ", status = #{@status}"
+    end
+  
+  end
+  
+end

data/lib/empp/msg_delivery.rb

@@ -0,0 +1,21 @@
+require 'empp/empp_base'
+require 'empp/constants'
+
+module Empp
+  
+  class MsgDelivery < EmppBase
+
+    attr_accessor :msg_id, :dest_id, :service_id, :msg_format, :src_terminal_id, :registered_delivery, :msg_length, :msg_content
+  
+    def initialize
+      @command_id = Constants::EMPP_DELIVER
+    end
+
+    def to_s
+      str = super
+      str + "msg_id=#{@msg_id}, dest_id=#{@dest_id}, service_id=#{@service_id}, msg_format=#{@msg_format}, src_terminal_id=#{@src_terminal_id}, msg_length=#{@msg_length}, msg_content=#{@msg_content}"
+    end
+  
+  end
+  
+end

data/lib/empp/msg_delivery_resp.rb

@@ -0,0 +1,35 @@
+require 'empp/empp_base'
+require 'empp/utils/bytebuffer'
+require 'empp/utils/utils'
+require 'empp/constants'
+
+module Empp
+  
+  class MsgDeliveryResp < EmppBase
+
+    attr_accessor :msg_id
+
+    def initialize
+      @command_id = Constants::EMPP_DELIVER_RESP
+      @result = 0
+      @total_length = 12 + 10 + 4
+      setSequenceId
+    end
+
+    def package
+      buf = Utils::ByteBuffer.new
+      # add header
+      buf.append_uint_be(@total_length)
+    
+      buf.append_uint_be(@command_id)
+      buf.append_uint_be(@sequence_id)
+      buf.append_string(@msg_id)
+      buf.append_string("\0\0\0\0")
+
+      buf.data
+
+    end
+
+  end
+  
+end

data/lib/empp/msg_submit.rb

@@ -0,0 +1,105 @@
+require 'empp/empp_base'
+require 'empp/constants'
+require 'empp/empp_logger'
+require 'empp/utils/bytebuffer'
+require 'empp/utils/utils'
+
+
+module Empp
+  
+  class MsgSubmit < EmppBase
+
+    attr_accessor :terminal_id, :pk_total, :pk_number, :msg_id, :sequence_ids
+
+    def initialize(terminal_id, message, account_id, service_id)
+      @command_id = Constants::EMPP_SUBMIT
+      @terminal_id = terminal_id
+      @account_id = account_id
+      @service_id = service_id
+      @message = Utils::Utils.convert_utf8_to_gbk(message)
+      @splitted_messages = Utils::Utils.get_splitted_msgs(@message)
+      @sequence_ids = [] 
+       # assign sequence_id for each slice
+      @splitted_messages.each do |msg|
+        setSequenceId
+        @sequence_ids << @sequence_id
+      end
+      
+      @msg_id = Time.now.to_i.to_s[0...10]
+      
+      @pk_total = @splitted_messages.length
+      @pk_number = 1
+      
+      @logger = EmppLogger.instance
+    end
+
+    def package
+      @logger.debug("Enter MsgSubmit::package")
+
+      tmp_buf = ''
+      index = 0
+      
+      @splitted_messages.each do |msg|
+        @sequence_id = @sequence_ids[index]
+        index += 1
+        tmp_buf << package_msg(msg)
+      end
+      
+      @logger.debug("Leave MsgSubmit::package")
+
+      tmp_buf
+    end
+
+    private 
+
+    def package_msg(a_msg)
+      @logger.debug("Enter MsgSubmit::package_msg")
+      buf = Utils::ByteBuffer.new
+      @total_length = 12 + 10 + 1*4 + 17 + 17 + 4 + 32*1 + 1 + a_msg.length + 21*2 + 10 + 20 + 1*2 + 32 + 1*3 + 2 + 6 + 1
+
+
+      # add header
+      buf.append_uint_be(@total_length)
+    
+      buf.append_uint_be(@command_id)
+      buf.append_uint_be(@sequence_id)
+    
+      buf.append_string(@msg_id)
+      
+      tmp_str = ''
+      tmp_str << @pk_total
+      buf.append_string(tmp_str)
+
+      tmp_str = ''
+      tmp_str << @pk_number
+      @pk_number += 1
+      buf.append_string(tmp_str)
+
+      buf.append_string("\1")
+      buf.append_string("\017") # 15
+      buf.append_string("\0" * 17)
+      buf.append_string("\0" * 17)
+      buf.append_uint_be(1)
+      buf.append_string(@terminal_id.ljust(32, "\0"))
+      buf.append_string([a_msg.length].pack("C"))
+      buf.append_string(a_msg)
+      buf.append_string(" " * 21)
+      buf.append_string(@account_id.ljust(21, "\0"))
+      buf.append_string(@service_id.ljust(10, "\0"))
+      buf.append_string("\0" * 20)
+      buf.append_string("\0")
+      buf.append_string("\0")
+      buf.append_string("\0" * 32)
+      buf.append_string("\0")
+      buf.append_string("\0")
+      buf.append_string("\0")
+      buf.append_string("\0" * 2)
+      buf.append_string("\0" * 6)
+      buf.append_string("\0")
+    
+      @logger.debug("Leave MsgSubmit::package_msg")
+      buf.data
+    end
+  end
+  
+end

data/lib/empp/msg_submit_resp.rb

@@ -0,0 +1,23 @@
+require 'empp/empp_base'
+require 'empp/constants'
+
+module Empp
+  
+  class MsgSubmitResp < EmppBase
+
+    attr_accessor :status, :msg_id
+  
+    def initialize
+      @command_id = Constants::EMPP_SUBMIT_RESP
+      @msg_id = nil
+      @status = nil
+    end
+
+    def to_s
+      str = super
+      str + ", status = #{@status}, msg_id=#{@msg_id}"
+    end
+  
+  end
+  
+end

data/lib/empp/tcp_connection.rb

@@ -0,0 +1,103 @@
+require 'socket'
+require 'empp/empp_logger'
+
+module Empp
+  
+  class TcpConnection
+  
+    def initialize(host, port)
+      @socket = nil
+      @host = host
+      @port = port
+      @max_to_read = 4096
+      @logger = EmppLogger.instance
+      @alive = false
+    end
+
+    def self.getConnection(host, port)
+       return self.new(host, port)
+    end
+  
+    def alive?
+      @alive
+    end
+  
+    def send(data)
+      @logger.debug("Enter TcpConnection::send")
+    
+      @logger.debug("TcpConnection: send bytes:#{data.unpack("H*")}")
+      if @socket
+        begin
+          @socket.write(data)
+        rescue
+          @logger.fatal("Get exception to write data")
+          @alive = false
+        end
+      end
+
+      @logger.debug("Leave TcpConnection::send")
+    end
+
+    def connect
+      @logger.debug("Enter TcpConnection::connect")
+
+      begin
+        @socket = TCPSocket.new(@host, @port)
+        @alive = true
+      rescue
+          @alive = false
+          @socket = nil
+          @logger.fatal("Open socket error for host=#{@host}, port=#{@port}")  
+      end    
+
+      @logger.debug("Leave TcpConnection::connect")
+    end
+
+    def close
+      @logger.debug("Enter TcpConnection::close")
+
+      begin
+        @alive = false
+        if @socket
+          @socket.close()
+        end
+      rescue
+        @logger.warn("Unable to close socket.")
+      end
+
+      @logger.debug("Leave TcpConnection::close")
+    end
+
+    def receive(count = 0)
+      @logger.debug("Enter TcpConnection::receive")
+
+      count ||= @max_to_read
+    
+      if count < 0 || count > @max_to_read
+        return
+      end
+
+      bytes = nil
+      begin
+
+        while !bytes || bytes.length == 0
+          if @socket
+            bytes =  @socket.recvfrom(count)[0]
+          else
+            raise
+          end
+        end
+
+      rescue
+        @logger.fatal("TcpConnection::receive: get exception from socket recvFrom")
+        @alive = false
+        return
+      end
+      @logger.info("TcpConnectin receive bytes=" + bytes.unpack("H*").to_s )
+      @logger.debug("Leave TcpConnection::receive")
+      return bytes
+    end
+
+  end
+  
+end

data/lib/empp/utils/bytebuffer.rb

@@ -0,0 +1,39 @@
+require 'bindata'
+require 'empp/utils/utils'
+
+module Empp
+  
+  module Utils
+    
+    class ByteBuffer
+  
+      def initialize(data = nil)
+        @buf = data || ''
+        @offset = 0
+      end
+
+      def append_uint_be(intValue)
+        @buf << Utils.getUintBe(intValue)
+      end
+
+      def append_uint_le(intValue)
+        @buf << Utils.getUintLe(intValue)
+      end
+
+      def append_string(strValue)
+        @buf << strValue
+      end
+
+      def data
+        @buf
+      end
+
+      def to_s
+        @buf.unpack("H*")
+      end
+  
+    end
+
+  end
+  
+end

data/lib/empp/utils/hashtable.rb

@@ -0,0 +1,36 @@
+require 'thread'
+
+module Empp
+  
+  module Utils
+    
+    class Hashtable < Hash
+
+      def initialize
+        super
+        @mutex = Mutex.new
+      end
+
+      def put(key, value)
+        @mutex.synchronize{
+          self[key] = value
+        }
+      end
+
+      def get(key)
+        @mutex.synchronize{
+          self[key]
+        }
+      end
+
+      def delete(key)
+        @mutex.synchronize{
+          super(key)
+        }
+      end
+  
+    end
+    
+  end
+  
+end

data/lib/empp/utils/utils.rb

@@ -0,0 +1,120 @@
+
+require 'bindata'
+require 'iconv'
+
+module Empp
+  
+  module Utils
+    
+    class Utils
+
+      #  MMDDHHMMSS
+      def self.getTimestampInt(now)
+        u8 = BinData::Uint8.new
+        intVal = now.month * 10**8 + now.day * 10**6 + now.hour * 10**4 + now.min * 10**2 +             now.sec
+      end
+
+      def self.getTimestampStr(now)
+        now.month.to_s.rjust(2, "0") + now.day.to_s.rjust(2, "0") + now.hour.to_s.rjust(2, "0") + now.min.to_s.rjust(2, "0") + now.sec.to_s.rjust(2, "0")
+      end
+
+      def self.getUintLe(intValue)
+        ibe = BinData::Uint32le.new
+        ibe.assign( intValue )
+        ibe.to_binary_s
+      end
+
+      def self.getUintBe(intValue)
+        ibe = BinData::Uint32be.new
+        ibe.assign( intValue )
+        ibe.to_binary_s
+      end
+
+      def self.getVersion
+        version = 0b00010000
+        u8 = BinData::Uint8be.new
+        u8.assign(version)
+        u8.to_binary_s
+      end
+
+      private
+  
+      def self.fill_zero(binaryStr)
+        binaryStr.rjust(2, "\0")
+      end
+
+      def self.convert_utf8_to_gbk(strVal)
+        conv = Iconv.new("gbk", "utf-8")
+        conv.iconv(strVal)
+      end
+
+      def self.convert_gbk_to_utf8(strVal)
+        conv = Iconv.new("utf-8", "gbk")
+        conv.iconv(strVal)
+      end
+  
+      def self.convert_ucs2_to_utf8(strVal)
+        conv = Iconv.new("utf-8", "utf-16")
+        conv.iconv(strVal)
+      end
+      
+      ###########################################################
+      ## strip the possible prefix like "86" "+86" in          ##
+      ## terminal_id                                           ##
+      ###########################################################
+      def self.deal_with_terminal_id(terminal_id)
+
+        start_index = 0
+        if terminal_id.start_with?"86"
+          start_index = 2
+        elsif terminal_id.start_with?"+86"
+          start_index = 3
+        end
+        terminal_id[start_index .. -1]
+      end
+      
+      ############################################################
+      ## split msg_content to slices which has characters<70    ##
+      ## to fit empp's requirement, msg_content is coded as gbk ##
+      ############################################################
+      def self.get_splitted_msgs(msg_content)
+        fix_len = 68
+        msgs = []
+        count, index = 0, 0;
+        tmp_str = ''
+        step = 1
+
+        while true
+          
+          if count > fix_len || index >= msg_content.length
+            msgs << tmp_str
+            tmp_str = ''
+            count = 0
+          end
+
+          break if index >= msg_content.length
+          bt = msg_content[index]
+          
+          if bt.to_i < 128 && bt.to_i > 0
+            tmp_str << msg_content[index]
+            step = 1
+          else
+            tmp_str << msg_content[index]
+            tmp_str << msg_content[index + 1]
+            step = 2
+          end
+          
+          index += step
+          count += 1
+          
+        end
+
+        msgs
+
+      end
+        
+    end
+    
+  end
+  
+end