anthill_smpp_ruby 0.5.1

data/lib/smpp_datatypes.rb

@@ -0,0 +1,89 @@
+#
+#   Copyright 2007 Majoron.com (developers@majoron.com)
+#   Original sources are available at www.majoron.com
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+module Majoron
+  module AntHill
+  	module SMPP
+  		# Class describe broadcast area identifier
+  		class BroadcastAreaIdentifier
+  			# Constructor.
+  			def initialize(value = "")
+  				@value = value
+  			end
+
+  			def alias?()
+  				return false if @value.size() == 0
+          if RUBY_VERSION >= "1.9.0"
+            # Encoding::CompatibilityError: incompatible character encodings: US-ASCII and ASCII-8BIT
+            # ASCII-8BIT is a binary data, I am not able to find how to set encoding in constructor
+            @value.force_encoding("ASCII-8BIT")
+            return value[0].ord == BroadcastAreaFormat::ALIAS
+          else
+            return value[0] == BroadcastAreaFormat::ALIAS
+          end
+  			end
+
+  			def ellipsoid?()
+  				return false if @value.size() == 0
+          if RUBY_VERSION >= "1.9.0"
+            # Encoding::CompatibilityError: incompatible character encodings: US-ASCII and ASCII-8BIT
+            # ASCII-8BIT is a binary data, I am not able to find how to set encoding in constructor
+            @value.force_encoding("ASCII-8BIT")
+            return value[0].ord == BroadcastAreaFormat::ELLIPSOID
+          else
+            return value[0] == BroadcastAreaFormat::ELLIPSOID
+          end
+  			end
+
+  			def polygon?()
+  				return false if @value.size() == 0
+          if RUBY_VERSION >= "1.9.0"
+            # Encoding::CompatibilityError: incompatible character encodings: US-ASCII and ASCII-8BIT
+            # ASCII-8BIT is a binary data, I am not able to find how to set encoding in constructor
+            @value.force_encoding("ASCII-8BIT")
+            return value[0].ord == BroadcastAreaFormat::POLYGON
+          else
+            return value[0] == BroadcastAreaFormat::POLYGON
+          end
+  			end
+
+  			def broadcast_area_format()
+  				BroadcastAreaFormat::UNKNOWN if @value.size() == 0
+          if RUBY_VERSION >= "1.9.0"
+            # Encoding::CompatibilityError: incompatible character encodings: US-ASCII and ASCII-8BIT
+            # ASCII-8BIT is a binary data, I am not able to find how to set encoding in constructor
+            @value.force_encoding("ASCII-8BIT")
+            if value[0].ord == BroadcastAreaFormat::ALIAS ||
+              value[0].ord = BroadcastAreaFormat::ELLIPSOID ||
+              value[0].ord = BroadcastAreaFormat::POLYGON
+              return value[0].ord
+            end
+          else
+            if value[0] == BroadcastAreaFormat::ALIAS ||
+              value[0] = BroadcastAreaFormat::ELLIPSOID ||
+              value[0] = BroadcastAreaFormat::POLYGON
+              return value[0]
+            end
+          end
+  				return BroadcastAreaFormat::UNKNOWN
+  			end
+  		public
+  			attr_accessor :value
+  		end
+  	end
+  end
+end

data/lib/smpp_decoder.rb

@@ -0,0 +1,627 @@
+#
+#   Copyright 2007 Majoron.com (developers@majoron.com)
+#   Original sources are available at www.majoron.com
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+module Majoron
+
+  module AntHill
+  	module SMPP
+  		class SMPPDecoder < AntHill::BinaryDecoder
+
+  			# Constructor. Insert all SMPP commands to hash. Key is SMPP command identity,
+  			# and value is SMPP command intanse. Hash is used to get PDU to decode PDU.
+  			def initialize()
+  				super()
+  			end
+
+  		public
+  			# Method
+  			def has_tlvs()
+  				return true if @offset + 1 < decode_command_length()
+  				return false
+  			end
+
+  			# Method
+  			def has_packets()
+  				return false if @buffer.size() < SMPPOffset::SMPP_HEADER_SIZE
+  				return false if @buffer.size() < decode_command_length()
+  				return true
+  			end
+
+  			# Method
+  			def get_tlv_code()
+  				result = 0
+  				sizeof = 2
+  				if SMPPOffset::TLV_CODE_POS + sizeof <= @buffer.size()
+  					shift = @offset + SMPPOffset::TLV_CODE_POS
+  					result = @buffer[shift..shift+(sizeof-1)].unpack('n').first
+  				end
+  				result
+  			end
+
+  			# Method
+  			def get_tlv_error()
+  				tlv_code = get_tlv_code()
+  				begin_pos = @offset > 2 ? @offset - 2 : 0
+  				finish_pos = @offset + 2 > @buffer.size() ? @buffer.size() : @offset + 2
+  				dump = AntHill::ByteBuffer.encode_hex(@buffer[begin_pos .. finish_pos])
+  				sprintf("Offset: %d, TLVCode: %d, TLVCode 0x%X, Dump[offset-2..@offset+2]: %s",
+  					@offset, tlv_code, tlv_code, dump)
+  			end
+
+
+  			# Method to get new copy of SMPP command based on byte buffer located at decoder.
+  			# If byte buffer is large enough then command id extracted and then pdu is returned
+  			def get_packet()
+  				case decode_command_id()
+  					when nil
+  						return nil
+  					when CommandId::CM_GENERIC_NACK
+  						return SMPPGenericNack.new()
+  					when CommandId::CM_BIND_RECEIVER
+  						return SMPPBindReceiver.new()
+  					when CommandId::CM_BIND_RECEIVER_RESP
+  						return SMPPBindReceiverResp.new()
+  					when CommandId::CM_BIND_TRANSMITTER
+  						return SMPPBindTransmitter.new()
+  					when CommandId::CM_BIND_TRANSMITTER_RESP
+  						return SMPPBindTransmitterResp.new()
+  					when CommandId::CM_QUERY_SM
+  						return SMPPQuerySM.new()
+  					when CommandId::CM_QUERY_SM_RESP
+  						return SMPPQuerySMResp.new()
+  					when CommandId::CM_SUBMIT_SM
+						return SMPPSubmitSM.new()
+					when CommandId::CM_SUBMIT_SM_RESP
+						return SMPPSubmitSMResp.new()
+					when CommandId::CM_DELIVER_SM
+						return SMPPDeliverSM.new()
+					when CommandId::CM_DELIVER_SM_RESP
+						return SMPPDeliverSMResp.new()
+					when CommandId::CM_UNBIND
+						return SMPPUnbind.new()
+					when CommandId::CM_UNBIND_RESP
+						return SMPPUnbindResp.new()
+					when CommandId::CM_REPLACE_SM
+						return SMPPReplaceSM.new()
+					when CommandId::CM_REPLACE_SM_RESP
+						return SMPPReplaceSMResp.new()
+					when CommandId::CM_CANCEL_SM
+						return SMPPCancelSM.new()
+					when CommandId::CM_CANCEL_SM_RESP
+						return SMPPCancelSMResp.new()
+					when CommandId::CM_BIND_TRANSCEIVER
+						return SMPPBindTransceiver.new()
+					when CommandId::CM_BIND_TRANSCEIVER_RESP
+						return SMPPBindTransceiverResp.new()
+					when CommandId::CM_OUTBIND
+						return SMPPOutbind.new()
+					when CommandId::CM_ENQUIRE_LINK
+						return SMPPEnquireLink.new()
+					when CommandId::CM_ENQUIRE_LINK_RESP
+						return SMPPEnquireLinkResp.new()
+					when CommandId::CM_SUBMIT_MULTI
+						return SMPPSubmitMulti.new()
+					when CommandId::CM_SUBMIT_MULTI_RESP
+						return SMPPSubmitMultiResp.new()
+					when CommandId::CM_ALERT_NOTIFICATION
+						return SMPPAlertNotification.new()
+					when CommandId::CM_DATA_SM
+						return SMPPDataSM.new()
+					when CommandId::CM_DATA_SM_RESP
+						return SMPPDataSMResp.new()
+					when CommandId::CM_BROADCAST_SM
+						return SMPPBroadcastSM.new()
+					when CommandId::CM_BROADCAST_SM_RESP
+						return SMPPBroadcastSMResp.new()
+					when CommandId::CM_QUERY_BROADCAST_SM
+						return SMPPQueryBroadcastSM.new()
+					when CommandId::CM_QUERY_BROADCAST_SM_RESP
+						return SMPPQueryBroadcastSMResp.new()
+					when CommandId::CM_CANCEL_BROADCAST_SM
+						return SMPPCancelBroadcastSM.new()
+					when CommandId::CM_CANCEL_BROADCAST_SM_RESP
+						return SMPPCancelBroadcastSMResp.new()
+					else
+						return nil
+				end
+			end
+
+			# Method
+			def decode_packet()
+				raise "not implemented yet !!!"
+			end
+
+
+			# SMPP header decoder
+			def decode_header()
+				header = AntHill::SMPP::Header.new()
+				header.command_length = decode_unsigned32()
+				header.command_id = decode_unsigned32(header.command_length)
+				header.command_status = decode_unsigned32(header.command_length)
+				header.sequence_number = decode_unsigned32(header.command_length)
+				header
+			end
+
+			# Mandatory SMPP fields decoder
+			def decode_system_id(limit)
+				decode_cstring_max(SMPPMaxLen::SYSTEM_ID_MAX_LEN, limit)
+			end
+
+			def decode_password(limit)
+				decode_cstring_max(SMPPMaxLen::PASSWORD_MAX_LEN, limit)
+			end
+
+			def decode_system_type(limit)
+				decode_cstring_max(SMPPMaxLen::SYSTEM_TYPE_MAX_LEN, limit)
+			end
+
+			def decode_interface_version(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_addr_ton(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_addr_npi(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_address_range(limit)
+				decode_cstring_max(SMPPMaxLen::ADDRESS_RANGE_MAX_LEN, limit)
+			end
+
+			def decode_service_type(limit)
+				decode_cstring_max(SMPPMaxLen::SERVICE_TYPE_MAX_LEN, limit)
+			end
+
+			def decode_source_addr_ton(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_source_addr_npi(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_source_addr21(limit)
+				decode_cstring_max(SMPPMaxLen::SOURCE_ADDR_MAX_LEN_21, limit)
+			end
+
+			def decode_source_addr65(limit)
+				decode_cstring_max(SMPPMaxLen::SOURCE_ADDR_MAX_LEN_65, limit)
+			end
+
+			def decode_dest_addr_ton(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_dest_addr_npi(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_dest_addr21(limit)
+				decode_cstring_max(SMPPMaxLen::DESTINATION_ADDR_MAX_LEN_21, limit)
+			end
+
+			def decode_dest_addr65(limit)
+				decode_cstring_max(SMPPMaxLen::DESTINATION_ADDR_MAX_LEN_65, limit)
+			end
+
+			def decode_esm_class(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_protocol_id(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_priority_flag(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_schedule_delivery_time(limit)
+				decode_cstring_max(SMPPMaxLen::SMPP_DATETIME_MAX_LEN, limit)
+			end
+
+			def decode_validity_period(limit)
+				decode_cstring_max(SMPPMaxLen::SMPP_DATETIME_MAX_LEN, limit)
+			end
+
+			def decode_registered_delivery(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_replace_if_present_flag(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_data_coding(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_sm_default_msg_id(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_sm_length(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_short_message(sm_length, limit)
+				decode_binary(sm_length, limit)
+			end
+
+			def decode_message_id(limit)
+				decode_cstring_max(SMPPMaxLen::MESSAGE_ID_MAX_LEN, limit)
+			end
+
+			def decode_esme_addr_ton(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_esme_addr_npi(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_esme_addr(limit)
+				decode_cstring_max(SMPPMaxLen::ESME_ADDR_MAX_LEN, limit)
+			end
+
+			def decode_number_of_dest(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_dest_addresses(number_of_dests, limit)
+				result = []
+				0.upto(number_of_dests - 1) do |i|
+					dest_address = DestAddress.new()
+					dest_address.dest_flag = decode_uchar(limit)
+					case dest_address.dest_flag
+						when DestFlag::SME_ADDRESS
+							ton = decode_uchar(limit)
+							npi = decode_uchar(limit)
+							adr = decode_cstring_max(SMPPMaxLen::DESTINATION_ADDR_MAX_LEN_21,limit)
+							dest_address.address = SMEAddress.new(ton, npi, adr)
+						when DestFlag::DISTR_LIST_NAME
+							dest_address.distr_list_name = decode_cstring_max(SMPPMaxLen::DL_NAME_MAX_LEN, limit)
+						else
+							# Report about error
+							raise spritnf(CodecErrors::DECODER_INV_DSTFLAG, @offset, dest_address.dest_flag)
+					end
+					result << dest_address
+				end
+				result
+			end
+
+			def decode_no_unsuccess(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_unsuccess_smes(no_unsuccess, limit)
+				result = []
+				0.upto(no_unsuccess - 1) do |i|
+					ton = decode_uchar(limit)
+					npi = decode_uchar(limit)
+					adr = decode_cstring_max(SMPPMaxLen::DESTINATION_ADDR_MAX_LEN_21,limit)
+					err = decode_unsigned32(limit)
+					result << UnsuccessSME.new(SMEAddress.new(ton, npi, adr), err)
+				end
+				result
+			end
+
+			def decode_final_date(limit)
+				decode_cstring_max(SMPPMaxLen::SMPP_DATETIME_MAX_LEN, limit)
+			end
+
+			def decode_error_code(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_message_state(limit)
+				decode_uchar(limit)
+			end
+
+			def decode_broadcast_area_identifier(limit)
+				data, len = decode_binary_tlv(limit)
+				return BroadcastAreaIdentifier.new(data), len
+			end
+
+			def decode_broadcast_rep_num(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_broadcast_frequency_interval(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_broadcast_area_success(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			# Optional (TLV) SMPP fields decoder
+			def decode_sc_interface_version(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_ms_availability_status(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_alert_on_msg_delivery(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_broadcast_channel_indicator(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_broadcast_content_type_info(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_broadcast_message_class(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_broadcast_service_group(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_callback_num(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_callback_num_atag(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_callback_num_pres_ind(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_dest_addr_subunit(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_dest_subaddress(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_display_time(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_language_indicator(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_message_payload(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_ms_validity(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_payload_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_privacy_indicator(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_sms_signal(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_source_addr_subunit(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_source_port(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_source_subaddress(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_user_message_reference(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_broadcast_error_status(limit)
+				decode_uint32_tlv(limit)
+			end
+
+			def decode_failed_broadcast_area_identifier(limit)
+				data, len = decode_binary_tlv(limit)
+				return BroadcastAreaIdentifier.new(data), len
+			end
+
+			def decode_broadcast_content_type(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_source_network_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_source_bearer_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_source_telematics_id(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_destination_port(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_dest_network_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_dest_bearer_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_dest_telematics_id(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_sar_msg_ref_num(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_sar_total_segments(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_sar_segment_seqnum(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_more_messages_to_send(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_qos_time_to_live(limit)
+				decode_uint32_tlv(limit)
+			end
+
+			def decode_set_dpf(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_receipted_message_id(limit)
+				decode_cstring_tlv(limit)
+			end
+
+			def decode_message_state_tlv(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_network_error_code(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT)
+				len = decode_unsigned16(limit)
+				network = decode_uchar(limit)
+				error = decode_unsigned16(limit)
+				return NetworkErrorCode.new(network, error), len
+			end
+
+			def decode_ms_msg_wait_facilities(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_number_of_messages(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_its_reply_type(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_its_session_info(limit)
+				decode_uint16_tlv(limit)
+			end
+
+			def decode_user_response_code(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_delivery_failure_reason(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_additional_status_info_text(limit)
+				decode_binary_tlv(limit)
+			end
+
+			def decode_dpf_result(limit)
+				decode_uchar_tlv(limit)
+			end
+
+			def decode_broadcast_end_time(limit)
+				decode_cstring_tlv(limit)
+			end
+
+			def decode_ussd_service_op(limit)
+				decode_uchar_tlv(limit)
+			end
+
+		private
+			# Method to decoder command id based on byte buffer located at decoder.
+			def decode_command_id()
+				sizeof = 4
+				shift = SMPPOffset::COMMAND_ID_POS
+				if shift + sizeof <= @buffer.size()
+					return @buffer[shift.. shift + (sizeof-1)].unpack('N').first
+				end
+			end
+
+			# Method to decoder command id based on byte buffer located at decoder.
+			def decode_command_length()
+				sizeof = 4
+				shift = SMPPOffset::COMMAND_LENGTH_POS
+				if shift + sizeof <= @buffer.size()
+					return @buffer[shift.. shift + (sizeof-1)].unpack('N').first
+				end
+			end
+
+			# Auxiliary methods to decode tlv
+			def decode_uchar_tlv(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT, limit)
+				len = decode_unsigned16(limit)
+				val = decode_uchar(limit)
+				return val, len
+			end
+
+			def decode_uint16_tlv(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT, limit)
+				len = decode_unsigned16(limit)
+				val = decode_unsigned16(limit)
+				return val, len
+			end
+
+			def decode_uint32_tlv(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT, limit)
+				len = decode_unsigned16(limit)
+				val = decode_unsigned32(limit)
+				return val, len
+			end
+
+			def decode_cstring_tlv(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT, limit)
+				len = decode_unsigned16(limit)
+				val = decode_cstring_max(len, limit)
+				return val, len
+			end
+
+			def decode_binary_tlv(limit)
+				skip_n_bytes(SMPPOffset::TLV_TAG_LENGHT, limit)
+				len = decode_unsigned16(limit)
+				val = decode_binary(len, limit)
+				return val, len
+			end
+		end
+
+	end
+end
+end