private void WhenDeliveryReceiptReceivedFromSMSC(object sender, DeliverSm data)
{
if (data.MessageType == MessageTypes.SMSCDeliveryReceipt)
{
_storage.ReceiptReceived(data);
}
}
private void OnMessageReceivedFromMS(object sender, DeliverSm data)
{
if (data.ServiceType == "USSD")
{
var opParameter = data.Parameters.Of <UssdServiceOpParameter>().FirstOrDefault();
if (opParameter != null)
{
if (opParameter.Operation == USSDOperation.PSSRIndication)
{
//Begin Message
//The operation type can only be Request USSDOperation.USSRRequest or USSDOperation.USSNRequest.
}
else if (opParameter.Operation == USSDOperation.USSRConfirm)
{
//Continue message
//The operation type can only be Response. In the subsequent message exchange, the MS can only respond to the Request or Notify message of the ESME.
//USSDOperation.USSRRequest or USSDOperation.USSNRequest??
}
else if (opParameter.Operation == USSDOperation.PSSRResponse || opParameter.Operation == USSDOperation.USSNConfirm)
{
//End Message
//The operation type can only be Response.
//
//USSDOperation.PSSRResponse
}
}
}
}
//</SendMessage>
//<EvDeliverSm>
private void ClientOnEvDeliverSm(object sender, DeliverSm data)
{
if (data.MessageType == MessageTypes.SMSCDeliveryReceipt)
{
_clientMessageStore.UpdateMessageStatus(data.Receipt.MessageId, data.Receipt.State);
}
}
//</EventsSample>
//<InlineSample>
private void client_evDeliverSmInline(object sender, DeliverSm data)
{
_composer.AddMessage(data);
if (_composer.IsLastSegment(data))
{
string receivedText = _composer.GetFullMessage(data);
}
}
public void DeliverSmDecode()
{
var pdu = new DeliverSm(rawPdu.Replace(" ", ""));
pdu.Decode();
Assert.AreEqual("4797509181", pdu.Sender);
Assert.AreEqual("BSS Test 301115 kl 1550", pdu.Body);
}
public void DeliverSmDecodeLatin()
{
var pdu = new DeliverSm(rawPduLatin.Replace(" ", ""));
pdu.Decode();
Assert.AreEqual("4797509181", pdu.Sender);
Assert.AreEqual("Norwegian char: æøåÆØÅ", pdu.Body);
}
private async void WhenReceiptIsReadyForDelivery(object sender, DeliverSm data)
{
//Find client that should receive the delivery receipt.
var client = _proxyServer.ConnectedClients.FirstOrDefault();
if (client != null)
{
DeliverSmResp resp = await client.Deliver(data);
_storage.ReceiptDelivered(data.Receipt.MessageId);
}
}
private void OnReceiptReadyForForward(MessageEntry entry)
{
if (ReceiptReadyForDelivery != null)
{
DeliverSm receipt = entry.Receipt.Clone();
receipt.Receipt.MessageId = entry.LocalMessageId;
receipt.Parameters[OptionalTags.ReceiptedMessageId] =
EncodingMapper.Default.GetMessageBytes(receipt.Receipt.MessageId, receipt.DataCoding);
receipt.Header.Sequence = 0;
ReceiptReadyForDelivery(this, receipt);
}
}
private void SendAnswerToHuaweiUSSDWithServiceType(DeliverSm deliverSm)
{
if (deliverSm.ServiceType == "PSSRR")
{
_client.Submit(SMS.ForSubmit()
.ServiceType("PSSRC")
.To(deliverSm.SourceAddress)
.Coding(deliverSm.DataCoding)
.Text("USSD response")
);
}
if (deliverSm.ServiceType == "RELC")
{
//USSD Dialogue has been released
}
}
private void client_evDeliverSm(object sender, DeliverSm data)
{
try
{
//Check if we received Delivery Receipt
if (data.MessageType == MessageTypes.SMSCDeliveryReceipt)
{
//Get MessageId of delivered message
string messageId = data.Receipt.MessageId;
MessageState deliveryStatus = data.Receipt.State;
}
else
{
// Receive incoming message and try to concatenate all parts
if (data.Concatenation != null)
{
_composer.AddMessage(data);
_log.Info("DeliverSm part received : Sequence: {0} SourceAddr: {1} Concatenation ( {2} ) Coding: {3} Text: {4}",
data.Header.Sequence, data.SourceAddress, data.Concatenation, data.DataCoding, _client.EncodingMapper.GetMessageText(data));
if (_composer.IsLastSegment(data))
{
string fullMessage = _composer.GetFullMessage(data);
_log.Info("Full message: " + fullMessage);
}
}
else
{
_log.Info("DeliverSm received : Sequence: {0} SourceAddr : {1} Coding : {2} MessageText : {3}",
data.Header.Sequence, data.SourceAddress, data.DataCoding, _client.EncodingMapper.GetMessageText(data));
}
}
}
catch (Exception ex)
{
data.Response.Header.Status = CommandStatus.ESME_RX_T_APPN;
_log.Error("Failed to process DeliverSm", ex);
}
// </ReceiveMessage>
}
public void ReceiptReceived(DeliverSm data)
{
MessageEntry entry;
if (_remoteMessage.TryGetValue(data.Receipt.MessageId, out entry))
{
entry.Receipt = data;
OnReceiptReadyForForward(entry);
}
else
{
_remoteMessage.TryAdd(data.Receipt.MessageId, new MessageEntry
{
RemoteMessageId = data.Receipt.MessageId,
Receipt = data
});
}
}
private int DeliverSm(int message_id, string sender, string recipient, string body, string body_format, bool delivery_report)
{
if (!connected)
{
Events.LogMessageChangeStatusEvent(message_id, Common.MessageStatus.received_route_failure);
return(1);
}
// check for max sms count
if (max_threads != 0)
{
int now_second = DateTime.Now.Second;
if (now_second != last_second)
{
last_second = now_second;
sent_during_last_second = 0;
}
else
{
sent_during_last_second++;
}
if (max_threads < sent_during_last_second)
{
Events.LogMessageChangeStatusEvent(message_id, Common.MessageStatus.queued);
return(2); // too many SMS per second
}
}
var deliver_sm = new DeliverSm(Events);
while (submitted_messages.ContainsKey(sequence_number))
{
sequence_number++;
}
deliver_sm.sequence_number = sequence_number;
submitted_message sm = new submitted_message();
sm.message_id = message_id;
sm.submitted_time = DateTime.Now;
sm.registered_delivery = delivery_report;
try
{
submitted_messages.Add(deliver_sm.sequence_number, sm);
}
catch (ArgumentException)
{
Events.LogChannelEvent(channel_name, "Duplicate sequence number.");
Events.LogMessageChangeStatusEvent(message_id, Common.MessageStatus.queued);
return(3);
}
deliver_sm.Sender = sender;
deliver_sm.Recipient = recipient;
deliver_sm.Body = body;
deliver_sm.BodyFormat = body_format;
deliver_sm.ServiceType = system_type;
deliver_sm.SourceAddrTON = source_ton;
deliver_sm.SourceAddrNPI = source_npi;
deliver_sm.DestAddrTON = destination_ton;
deliver_sm.DestAddrNPI = destination_npi;
deliver_sm.SplitBaseASCII = split_base_ascii;
deliver_sm.LargeMessageHandleMethod = large_message;
if (registered_delivery == 1 && delivery_report)
{
deliver_sm.RegisteredDelivery = registered_delivery;
}
else
{
deliver_sm.RegisteredDelivery = 0;
}
string[] pdu = deliver_sm.EncodeM();
Events.LogChannelEvent(channel_name, "Sending from " + sender + " to " + recipient);
int k = pdu.Length;
foreach (string part in pdu)
{
Events.LogChannelEvent(channel_name, "Sending [deliver_sm]", debug ? part : "");
SendPDU(part);
if (k != 1)
{
Thread.Sleep(multypart_delay);
}
k--;
if (registered_delivery == 1 && delivery_report)
{
Events.LogMessageChangeStatusEvent(message_id, Common.MessageStatus.submitted_waiting_for_ACK);
}
else
{
Events.LogMessageChangeStatusEvent(message_id, Common.MessageStatus.received_routed);
}
}
return(0);
}
/// <summary>
/// Gets PDU from stream, parses
/// </summary>
/// <param name="pdu">PDU to handle</param>
private void PduHandler(string pdu)
{
string response = string.Empty;
Events.LogChannelEvent(channel_name, "Receiving [" + Common.command_id.Values[Common.command_id.IndexOfKey(uint.Parse(pdu.Substring(8, 8), System.Globalization.NumberStyles.HexNumber))] + "]", debug ? pdu : "");
switch (Common.command_id.Values[Common.command_id.IndexOfKey(uint.Parse(pdu.Substring(8, 8), System.Globalization.NumberStyles.HexNumber))])
{
case "generic_nack":
// they do not understand my command
// may be a bug in my pdu
break;
case "bind_transceiver_resp":
var bind_transceiver = new BindTransceiverResp(pdu);
commands_queue.Remove(bind_transceiver.sequence_number);
if (bind_transceiver.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error: " + Common.command_status[bind_transceiver.command_status].description);
if (!is_server)
{
// try to reconnect
Thread.Sleep(reconnectDelay);
Task.Run(() => { Gate.Clients[channel_name].Connect(); });
}
}
break;
case "bind_transmitter_resp":
var bind_transmitter = new BindTransmitterResp(pdu);
commands_queue.Remove(bind_transmitter.sequence_number);
if (bind_transmitter.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error: " + Common.command_id[bind_transmitter.command_status]);
if (!is_server)
{
Thread.Sleep(reconnectDelay);
Task.Run(() => { Gate.Clients[channel_name].Connect(); });
}
}
break;
case "bind_receiver_resp":
var bind_receiver = new BindReceiverResp(pdu);
commands_queue.Remove(bind_receiver.sequence_number);
if (bind_receiver.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error: " + Common.command_id[bind_receiver.command_status]);
Quit();
if (!is_server)
{
Thread.Sleep(reconnectDelay);
Task.Run(() => { Gate.Clients[channel_name].Connect(); });
}
}
break;
case "submit_sm":
var submit_sm_s = new SubmitSm(pdu);
var submit_sm_resp_s = new SubmitSmResp();
submit_sm_resp_s.MessageID = Guid.NewGuid().ToString("n");
submit_sm_resp_s.sequence_number = submit_sm_s.sequence_number;
response = submit_sm_resp_s.Encode();
Events.LogChannelEvent(channel_name, "Message received from " + submit_sm_s.Sender + " to " + submit_sm_s.Recipient);
Events.LogChannelEvent(channel_name, "Sending [submit_sm_resp]");
SendPDU(response);
if (submit_sm_s.isMultipart)
{
int parts = 0;
lock (multipart_messages)
{
multipart_messages.Add(submit_sm_s.MultipartMessage);
foreach (Common.MultipartMessage mm in multipart_messages)
{
if (mm.reference == submit_sm_s.MultipartMessage.reference)
{
parts++;
}
}
}
if (parts == submit_sm_s.MultipartMessage.num_of_parts)
{
var for_remove = new List <Common.MultipartMessage>();
var short_message = new StringBuilder();
var str = new string[parts];
lock (multipart_messages)
{
foreach (Common.MultipartMessage mm in multipart_messages)
{
if (mm.reference == submit_sm_s.MultipartMessage.reference)
{
for_remove.Add(mm);
try
{
str[mm.part_num - 1] = mm.short_message;
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1 + " " + pdu);
}
}
}
foreach (Common.MultipartMessage k in for_remove)
{
multipart_messages.Remove(k);
}
}
// can be required
// short_message.Append("(" + submit_sm_s.MultipartMessage.reference.ToString() + ") ");
try
{
for (int k = 0; k < parts; k++)
{
short_message.Append(str[k]);
}
submit_sm_s.Body = short_message.ToString();
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1 + " " + pdu);
}
Events.LogNewMessageEvent(channel_name, submit_sm_resp_s.MessageID, submit_sm_s.Sender, submit_sm_s.Recipient, submit_sm_s.Body, submit_sm_s.BodyFormat, submit_sm_s.RegisteredDelivery);
}
}
else
{
Events.LogNewMessageEvent(channel_name, submit_sm_resp_s.MessageID, submit_sm_s.Sender, submit_sm_s.Recipient, submit_sm_s.Body, submit_sm_s.BodyFormat, submit_sm_s.RegisteredDelivery);
}
break;
case "submit_sm_resp":
try
{
var submit_sm_resp = new SubmitSmResp(pdu);
if (submitted_messages.ContainsKey(submit_sm_resp.sequence_number))
{
var submitSmRespMessageId = "";
if (!string.IsNullOrEmpty(submit_sm_resp.MessageID))
{
submitSmRespMessageId = submit_sm_resp.MessageID;
}
if (submit_sm_resp.command_status == 0)
{
Events.LogMessageChangeStatusEvent(
submitted_messages[submit_sm_resp.sequence_number].message_id, Common.MessageStatus.sent, submitSmRespMessageId);
}
else
{
if (Common.command_status.ContainsKey(submit_sm_resp.command_status))
{
Events.LogMessageChangeStatusEvent(
submitted_messages[submit_sm_resp.sequence_number].message_id,
Common.MessageStatus.rejected, submitSmRespMessageId);
}
else
{
Events.LogMessageChangeStatusEvent(
submitted_messages[submit_sm_resp.sequence_number].message_id,
Common.MessageStatus.sent);
}
}
submitted_messages.Remove(submit_sm_resp.sequence_number);
}
if (submit_sm_resp.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error sending: " + submit_sm_resp.command_status);
}
else
{
Events.LogChannelEvent(channel_name, "Message reference: " + submit_sm_resp.MessageID);
}
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1.ToString());
}
break;
case "enquire_link":
var enquire_link = new EnquireLink(pdu);
var enquire_link_resp = new EnquireLinkResp();
enquire_link_resp.sequence_number = enquire_link.sequence_number;
response = enquire_link_resp.Encode();
SendPDU(response);
Events.LogChannelEvent(channel_name, "Sending [enquire_link_resp]", debug ? response : "");
break;
case "enquire_link_resp":
var enquire_link_resp_o = new EnquireLinkResp(pdu);
commands_queue.Remove(enquire_link_resp_o.sequence_number);
break;
case "deliver_sm":
DeliverSm deliver_sm;
try
{
deliver_sm = new DeliverSm(pdu);
deliver_sm.Is8bit = use8bit;
deliver_sm.Decode();
}
catch (CommandLengthException)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + ". Command length error.");
break;
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + ". Error: " + e1.Message);
break;
}
// Send Resp
var deliver_sm_resp = new DeliverSmResp();
deliver_sm_resp.MessageID = Guid.NewGuid().ToString("n");
deliver_sm_resp.sequence_number = deliver_sm.sequence_number;
response = deliver_sm_resp.Encode();
Events.LogChannelEvent(channel_name, "Sending [deliver_sm_resp]", debug ? response : "");
SendPDU(response);
// Multipart message
if (deliver_sm.isMultipart)
{
int parts = 0;
lock (multipart_messages)
{
multipart_messages.Add(deliver_sm.MultipartMessage);
foreach (Common.MultipartMessage mm in multipart_messages)
{
if (mm.reference == deliver_sm.MultipartMessage.reference)
{
parts++;
}
}
}
if (parts == deliver_sm.MultipartMessage.num_of_parts)
{
List <Common.MultipartMessage> for_remove = new List <Common.MultipartMessage>();
StringBuilder short_message = new StringBuilder();
string[] str = new string[parts];
lock (multipart_messages)
{
foreach (Common.MultipartMessage mm in multipart_messages)
{
if (mm.reference == deliver_sm.MultipartMessage.reference)
{
for_remove.Add(mm);
try
{
str[mm.part_num - 1] = mm.short_message;
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1.ToString() + " " + pdu);
}
}
}
foreach (Common.MultipartMessage k in for_remove)
{
multipart_messages.Remove(k);
}
}
try
{
for (int k = 0; k < parts; k++)
{
short_message.Append(str[k]);
}
deliver_sm.Body = short_message.ToString();
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1.ToString() + " " + pdu);
}
}
else
{
// Multipart message is not built yet, wait for the rest
break;
}
}
// Delivery report
if (deliver_sm.ESMClass == 4)
{
Events.LogChannelEvent(channel_name, "Message ref: " + deliver_sm.Reference + " " + deliver_sm.DeliveryStatus, debug ? pdu : "");
if (deliver_sm.DeliveryStatus.ToUpper() == "DELIVR")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.delivered_ACK_received);
}
if (deliver_sm.DeliveryStatus.ToUpper() == "EXPIRE")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.ACK_expired);
}
if (deliver_sm.DeliveryStatus.ToUpper() == "UNKNOW")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.unknown_recipient);
}
if (deliver_sm.DeliveryStatus.ToUpper() == "ACCEPT")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.received_routed);
}
if (deliver_sm.DeliveryStatus.ToUpper() == "REJECT")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.rejected);
}
if (deliver_sm.DeliveryStatus.ToUpper() == "UNDELI")
{
Events.LogMessageDeliverReportEvent(deliver_sm.Reference, Common.MessageStatus.message_undeliverable);
}
break;
}
// Log message
Events.LogChannelEvent(channel_name, "Message received from " + deliver_sm.Sender + " to " + deliver_sm.Recipient, debug ? pdu : "");
Events.LogNewMessageEvent(channel_name, deliver_sm_resp.MessageID, deliver_sm.Sender, deliver_sm.Recipient, deliver_sm.Body, deliver_sm.BodyFormat, deliver_sm.RegisteredDelivery);
break;
case "deliver_sm_resp":
try
{
var deliver_sm_resp2 = new DeliverSmResp(pdu);
if (submitted_messages.ContainsKey(deliver_sm_resp2.sequence_number))
{
var deliverSmRespMessageId = "";
if (!string.IsNullOrEmpty(deliver_sm_resp2.MessageID))
{
deliverSmRespMessageId = deliver_sm_resp2.MessageID;
}
if (deliver_sm_resp2.command_status == 0)
{
if (registered_delivery != 1 && submitted_messages[deliver_sm_resp2.sequence_number].registered_delivery)
{
Events.LogMessageChangeStatusEvent(submitted_messages[deliver_sm_resp2.sequence_number].message_id, Common.MessageStatus.sent, deliverSmRespMessageId);
}
}
else
{
if (Common.command_status.ContainsKey(deliver_sm_resp2.command_status))
{
Events.LogMessageChangeStatusEvent(
submitted_messages[deliver_sm_resp2.sequence_number].message_id,
Common.MessageStatus.rejected, deliverSmRespMessageId);
}
else
{
Events.LogMessageChangeStatusEvent(
submitted_messages[deliver_sm_resp2.sequence_number].message_id,
Common.MessageStatus.sent, deliverSmRespMessageId);
}
}
submitted_messages.Remove(deliver_sm_resp2.sequence_number);
}
if (deliver_sm_resp2.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error sending: " + deliver_sm_resp2.command_status);
}
else
{
Events.LogChannelEvent(channel_name, "Message reference: " + deliver_sm_resp2.MessageID);
}
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + " - " + e1);
}
break;
case "data_sm":
var data_sm_s = new DataSm(pdu);
var data_sm_resp_s = new DataSmResp();
data_sm_resp_s.MessageID = Guid.NewGuid().ToString("n");
data_sm_resp_s.sequence_number = data_sm_s.sequence_number;
response = data_sm_resp_s.Encode();
Events.LogChannelEvent(channel_name, "Message received from " + data_sm_s.Sender + " to " + data_sm_s.Recipient, debug ? pdu : "");
Events.LogChannelEvent(channel_name, "Sending [data_sm_resp]");
SendPDU(response);
Events.LogNewMessageEvent(channel_name, data_sm_resp_s.MessageID, data_sm_s.Sender, data_sm_s.Recipient, data_sm_s.Body, data_sm_s.BodyFormat, data_sm_s.RegisteredDelivery);
break;
case "data_sm_resp":
try
{
var data_sm_resp = new DataSmResp(pdu);
if (submitted_messages.ContainsKey(data_sm_resp.sequence_number))
{
var dataSmRespMessageId = "";
if (!string.IsNullOrEmpty(data_sm_resp.MessageID))
{
dataSmRespMessageId = data_sm_resp.MessageID;
}
if (data_sm_resp.command_status == 0)
{
if (registered_delivery != 1 && submitted_messages[data_sm_resp.sequence_number].registered_delivery)
{
Events.LogMessageChangeStatusEvent(submitted_messages[data_sm_resp.sequence_number].message_id, Common.MessageStatus.sent, dataSmRespMessageId);
}
}
else
{
if (Common.command_status.ContainsKey(data_sm_resp.command_status))
{
Events.LogMessageChangeStatusEvent(submitted_messages[data_sm_resp.sequence_number].message_id, Common.MessageStatus.rejected, dataSmRespMessageId);
}
else
{
Events.LogMessageChangeStatusEvent(submitted_messages[data_sm_resp.sequence_number].message_id, Common.MessageStatus.sent, dataSmRespMessageId);
}
}
submitted_messages.Remove(data_sm_resp.sequence_number);
}
if (data_sm_resp.command_status != 0)
{
Events.LogChannelEvent(channel_name, "Error sending: " + data_sm_resp.command_status);
}
else
{
Events.LogChannelEvent(channel_name, "Message reference: " + data_sm_resp.MessageID);
}
}
catch (Exception e1)
{
Events.LogEvent(LogEvent.Level.Error, channel_name + ". error: " + e1);
}
break;
case "unbind":
var unbind = new Unbind(pdu);
var unbind_resp = new UnbindResp();
unbind_resp.sequence_number = unbind.sequence_number;
response = unbind_resp.Encode();
SendPDU(response);
Events.LogChannelEvent(channel_name, "Sending [unbind_resp]", debug ? response : "");
enquire_link_timer.Stop();
timeout_timer.Stop();
tcp_stream.Close();
tcp_client.Close();
Gate.Clients.Remove(channel_name);
Gate.Servers.Remove(channel_name);
Events.LogChannelEvent(channel_name, "Disconnected");
// should reconnect if it was a client
if (!is_server)
{
Thread.Sleep(10000);
Task.Run(() => { Gate.Clients[channel_name].Connect(); });
}
break;
case "unbind_resp":
;
break;
default:
Events.LogChannelEvent(channel_name, "Receiving unknown command", pdu);
break;
}
}
/// <summary>
/// Sends delivery report of the message
/// </summary>
/// <param name="messageId"></param>
/// <param name="status"></param>
public void SubmitDeliveryReport(string messageId, Common.MessageStatus status)
{
string pdu;
string messageStatus;
switch (status)
{
case Common.MessageStatus.ACK_expired:
case Common.MessageStatus.delivered_ACK_received:
case Common.MessageStatus.duplicate_ACK_detected:
case Common.MessageStatus.received_routed:
case Common.MessageStatus.sent:
case Common.MessageStatus.submitted_waiting_for_ACK:
messageStatus = "DELIVRD";
break;
case Common.MessageStatus.queued:
case Common.MessageStatus.received_waiting_to_be_processed:
case Common.MessageStatus.scheduled:
messageStatus = "ACCEPTD";
break;
case Common.MessageStatus.generic_error:
case Common.MessageStatus.locked_by_system:
case Common.MessageStatus.NACK_received:
case Common.MessageStatus.rejected:
case Common.MessageStatus.out_of_balance:
messageStatus = "REJECTD";
break;
case Common.MessageStatus.message_undeliverable:
case Common.MessageStatus.received_route_failure:
case Common.MessageStatus.received_no_route_specified:
case Common.MessageStatus.no_channel_can_handle_message:
messageStatus = "UNDELIV";
break;
case Common.MessageStatus.unknown_recipient:
messageStatus = "UNKNOWN";
break;
default:
messageStatus = "DELIVRD";
break;
}
var deliver_sm = new DeliverSm(Events);
deliver_sm.sequence_number = sequence_number;
deliver_sm.Recipient = "";
deliver_sm.Sender = "";
deliver_sm.BodyFormat = "ascii";
deliver_sm.ESMClass = 4;
deliver_sm.IsDeliveryReport = true;
var short_message = new StringBuilder();
short_message.Append("id:" + messageId);
short_message.Append(" sub:001");
if (messageStatus == "DELIVRD")
{
short_message.Append(" dlvrd:001");
}
else
{
short_message.Append(" dlvrd:000");
}
short_message.Append(" submit date:" + DateTime.Now.ToString("yyMMddHHmm"));
short_message.Append(" done date:" + DateTime.Now.ToString("yyMMddHHmm"));
short_message.Append(" stat:" + messageStatus);
short_message.Append(" err:0");
short_message.Append(" text:");
deliver_sm.Body = short_message.ToString();
pdu = deliver_sm.EncodeM()[0];
Events.LogChannelEvent(channel_name, "Sending [deliver_sm] report", debug ? pdu : "");
SendPDU(pdu);
}
private void client_evDeliverSm(object sender, DeliverSm data)
{
try
{
//Check if we received Delivery Receipt
if (data.MessageType == MessageTypes.SMSCDeliveryReceipt)
{
//Get MessageId of delivered message
string messageId = data.Receipt.MessageId;
MessageState deliveryStatus = data.Receipt.State;
_log.Info("Delivery Receipt received: {0}", data.Receipt.ToString());
}
else
{
// Receive incoming message and try to concatenate all parts
if (data.Concatenation != null)
{
_messageComposer.AddMessage(data);
_log.Info("DeliverSm part received: Sequence: {0}, SourceAddress: {1}, Concatenation ( {2} )" +
" Coding: {3}, Text: {4}",
data.Header.Sequence, data.SourceAddress, data.Concatenation, data.DataCoding, _client.EncodingMapper.GetMessageText(data));
}
else
{
_log.Info("DeliverSm received : Sequence: {0}, SourceAddress: {1}, Coding: {2}, Text: {3}",
data.Header.Sequence, data.SourceAddress, data.DataCoding, _client.EncodingMapper.GetMessageText(data));
}
// Check if an ESME acknowledgement is required
if (data.Acknowledgement != SMEAcknowledgement.NotRequested)
{
// You have to clarify with SMSC support what kind of information they request in ESME acknowledgement.
string messageText = data.GetMessageText(_client.EncodingMapper);
var smBuilder = SMS.ForSubmit()
.From(data.DestinationAddress)
.To(data.SourceAddress)
.Coding(data.DataCoding)
.ConcatenationInUDH(_client.SequenceGenerator.NextReferenceNumber())
.Set(m => m.MessageType = MessageTypes.SMEDeliveryAcknowledgement)
.Text(new Receipt
{
DoneDate = DateTime.Now,
State = MessageState.Delivered,
// MessageId = data.Response.MessageId,
ErrorCode = "0",
SubmitDate = DateTime.Now,
Text = messageText.Substring(0, Math.Min(20, messageText.Length))
}.ToString()
);
_client.Submit(smBuilder).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
data.Response.Header.Status = CommandStatus.ESME_RX_T_APPN;
_log.Error(ex, "Failed to process DeliverSm");
}
}
public void GetItsSessionInfoFromDeliverSm(DeliverSm deliverSm)
{
byte[] bytes = deliverSm.Parameters[OptionalTags.ItsSessionInfo];
ushort id = GetUssdSessionId(bytes);
bool end = GetUssdSessionEnd(bytes);
}
private void OnFullMessageReceived(object sender, MessageEventHandlerArgs args)
{
DeliverSm pdu = args.GetFirst <DeliverSm>();
_log.Info(string.Format("Full message received from {0}: {1}", pdu.SourceAddress, args.Text));
}
private void OnFullMessageTimedout(object sender, MessageEventHandlerArgs args)
{
DeliverSm pdu = args.GetFirst <DeliverSm>();
_log.Info(string.Format("Incomplete message received from {0}", pdu.SourceAddress));
}
private void client_evDeliverSm(object sender, DeliverSm data)
{
_composer.AddMessage(data);
}
