private void SendAck(object o)
{
SmsMessage message = (SmsMessage)o;
if (message.deliveryTime == DateTime.MinValue)
{
CompleteMessageDelivery(message);
}
// If we are to send a receipt then do so.
if ((message.deliveryReceipt == DeliveryReceiptType.FINAL_DELIVERY_RECEIPT) ||
(message.deliveryReceipt == DeliveryReceiptType.FINAL_DELIVERY_FAIL_RECEIPT &&
(message.deliveryResult != DeliveryStatus.DELIVERED &&
message.deliveryResult != DeliveryStatus.ACCEPTED)))
{
deliver_sm pdu = new deliver_sm("", message.PDU.SourceAddress,
message.PDU.DestinationAddress,
new esm_class(MessagingMode.DEFAULT_MODE, MessageType.SMSC_DELIVERY_RCPT),
0, MessagePriority.NORMAL, new SmppTime(), new SmppTime(),
new registered_delivery(DeliveryReceiptType.NONE, AcknowledgementType.NONE, false),
false, DataEncoding.SMSC_DEFAULT, 0,
deliver_sm.BuildAckMessage(message.MessageId, 0, 0, DateTime.Now, DateTime.Now,
message.deliveryResult, 0, message.PDU.Message));
((SmscSession)message.Session).BeginDeliverSm(pdu, new AsyncCallback(EndDeliverSm));
}
}
/// <summary>
/// This method sends a deliver_sm packet synchronously over to the peer.
/// </summary>
/// <param name="pdu">deliver_sm packet</param>
/// <returns>deliver_sm response</returns>
public deliver_sm_resp DeliverSm(deliver_sm pdu)
{
deliver_sm_resp rpdu = null;
PduSyncronizer evt = AddWaitingPdu(pdu);
if (IsBound && SendPdu(pdu))
{
SmppPdu pduR = evt.PduResponse;
if ((pduR as deliver_sm_resp) != null)
{
rpdu = (deliver_sm_resp)pduR;
}
else
{
rpdu = new deliver_sm_resp();
rpdu.Status = pduR.Status;
}
}
else
{
FindAndRemoveWaitingPdu(pdu.SequenceNumber);
rpdu = new deliver_sm_resp();
rpdu.Status = StatusCodes.ESME_RDELIVERYFAILURE;
}
return(rpdu);
}
/// <summary>
/// This processes the deliver_sm PDU
/// </summary>
/// <param name="pdu">Protocol Data Unit being processed</param>
public override void Process(deliver_sm pdu)
{
SmppEventArgs ea = new SmppEventArgs(session_, pdu, new deliver_sm_resp(pdu.SequenceNumber));
if (!session_.FireEvent(EventType.DeliverSm, ea))
{
ea.ResponsePDU.Status = StatusCodes.ESME_RSUBMITFAIL;
}
session_.SendPdu(ea.ResponsePDU);
}
private void OnGenerateSms(object sender, EventArgs e)
{
GenerateSms dlg = new GenerateSms(server_);
if (dlg.ShowDialog() == DialogResult.OK)
{
deliver_sm pdu = new deliver_sm(dlg.ServiceType,
new address(TypeOfNumber.NATIONAL, NumericPlanIndicator.E164, dlg.SourceAddress),
new address(TypeOfNumber.NATIONAL, NumericPlanIndicator.E164, dlg.DestinationAddress),
new esm_class(MessagingMode.DEFAULT_MODE, MessageType.DEFAULT_MSG_TYPE),
0, MessagePriority.NORMAL, new SmppTime(), new SmppTime(),
new registered_delivery(DeliveryReceiptType.NONE, AcknowledgementType.NONE, false),
false, DataEncoding.SMSC_DEFAULT, 0, dlg.ShortMessage);
SmscSession session = dlg.Session as SmscSession;
if (session != null && session.IsBound)
{
session.BeginDeliverSm(pdu, new AsyncCallback(EndDeliverSm));
}
}
}
// Used to get delivery ack.'s and MO messages from SMSC
private void OnDeliverSm(object sender, SmppEventArgs args)
{
deliver_sm req = (deliver_sm)args.PDU;
deliver_sm_resp resp = (deliver_sm_resp)args.ResponsePDU;
esm_class esm = req.EsmClass;
switch (esm.MessageType)
{
case MessageType.SMSC_DELIVERY_RCPT: // Delivery receipt for previously sent short message
smsc_delivery_receipt receipt = new smsc_delivery_receipt(req.Message);
// Update the final deleivery status for the sent message using the message Id to locate
UpdateSentMessageFinalStatus(receipt);
break;
case MessageType.DEFAULT_MSG_TYPE: // Mobile originated message
AddNewMessage("Mobile Orig.", req.SourceAddress.Address, req.Message, "DELIVRD", DateTime.Now.ToString("d"), 0);
break;
default:
AddNewMessage("Error", req.SourceAddress.Address, "Unknown message type - " + esm.MessageType, "n/a", "n/a", 0);
break;
}
}
// Used to get delivery ack.'s and MO messages from SMSC
private static void OnDeliverSm(object sender, SmppEventArgs args)
{
deliver_sm req = (deliver_sm)args.PDU;
deliver_sm_resp resp = (deliver_sm_resp)args.ResponsePDU;
esm_class esm = req.EsmClass;
switch (esm.MessageType)
{
case MessageType.SMSC_DELIVERY_RCPT: // Delivery receipt for previously sent short message
smsc_delivery_receipt receipt = new smsc_delivery_receipt(req.Message);
Console.WriteLine(string.Format("Delivery receipt for message {0}: Type: {1}",
receipt.OriginalMessageId, receipt.FinalMessageStatus));
break;
case MessageType.DEFAULT_MSG_TYPE: // Mobile originated message
Console.WriteLine(string.Format("Mobile originated message from {0}: {1}",
req.SourceAddress, req.Message));
break;
default:
Console.WriteLine("Unexpected deliver_sm message type: " + esm.MessageType.ToString());
break;
}
}
/// <summary>
/// This processes the deliver_sm PDU
/// </summary>
/// <param name="pdu">Protocol Data Unit being processed</param>
public override void Process(deliver_sm pdu)
{
rx_.Process(pdu);
}
/// <summary>
/// This processes the deliver_sm PDU
/// </summary>
/// <param name="pdu">Protocol Data Unit being processed</param>
public virtual void Process(deliver_sm pdu)
{
throw new InvalidSmppStateException("Session is not in the proper state for a deliver_sm operation.");
}
/// <summary>
/// This method invokes the DeliverSm method asynchronously
/// </summary>
/// <param name="pdu">deliver_sm PDU to send</param>
/// <param name="ac">Asynch callback</param>
/// <returns>IAsyncResult interface for monitoring</returns>
public IAsyncResult BeginDeliverSm(deliver_sm pdu, AsyncCallback ac)
{
AsynchCall acr = new AsynchCall(ac, this);
return(acr.BeginInvoke(new DeliverSmDelegate(DeliverSm), new object[] { pdu }));
}
