Esempio n. 1
0
        /// <summary> Called to fire the bind response pdu event </summary>
        /// <param name="data"></param>
        internal void OnBindSmResp(BindSmResp data)
        {
            try
            {
                if (BindSmRespEvent != null)
                {
                    BindSmRespEvent(this, data);
                }
            }

            catch
            {
            }
        }
Esempio n. 2
0
        /// <summary> Called to process received messages from the SMPP server </summary>
        public void ProcessReceivedData()
        {
            try
            {
                // Copy the existing pdu data into a SmppBuffer for processing
                SmppBuffer sb = new SmppBuffer(DefaultEncoding, _SocketClient.MessageBuffer.ToArray());
                int offset = 0;

                // While we have data to process
                while (offset < sb.Length)
                {
                    // Where are we starting in the data
                    int startOffset = offset;

                    // Do we have enough data for the header
                    if ((sb.Length - offset) < Header.HEADER_LENGTH)
                    {
                        // Copy the data we have left back into the buffer
                        _SocketClient.MessageBuffer.SetLength(0);
                        _SocketClient.MessageBuffer.Write(sb.Buffer, offset, sb.Length - offset);
                        _SocketClient.MessageBuffer.Seek(0, SeekOrigin.End);

                        return;
                    }

                    // Extract the header
                    Header hd = sb.PeekHeader(offset);
                    if (hd == null)
                    {
                        _SocketClient.MessageBuffer.SetLength(0);
                        OnError("Unable To Extract Header, throw all data in buffer away");

                        return;
                    }

                    // Convert the length to an int
                    // The command length includes the header as well
                    int commandLength = Convert.ToInt32(hd.Length);

                    // Do we have all the data for the command we are receiving
                    if (commandLength + offset > sb.Length)
                    {
                        // Copy the data we have left back into the buffer
                        _SocketClient.MessageBuffer.SetLength(0);
                        _SocketClient.MessageBuffer.Write(sb.Buffer, offset, sb.Length - offset);
                        _SocketClient.MessageBuffer.Seek(0, SeekOrigin.End);

                        return;
                    }

                    #region Process Command

                    switch (hd.Command)
                    {
                        case CommandSet.AlertNotification:
                            #region AlertNotification

                            AlertNotification alertn = AlertNotification.Create(DefaultEncoding, sb, ref offset);

                            OnPduDetails(PduDirectionTypes.Received, alertn);
                            OnAlertNotification(alertn);

                            break;

                            #endregion

                        case CommandSet.BindTransceiverResp:
                        case CommandSet.BindReceiverResp:
                        case CommandSet.BindTransmitterResp:
                            #region Bind Response

                            BindSmResp = BindSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (BindSmResp == null)
                            {
                                BindSmResp = BindSmResp.Create(DefaultEncoding, hd);
                                BindSmResp.Status = CommandStatus.SMPPCLIENT_UNEXPRESP;
                            }

                            OnPduDetails(PduDirectionTypes.Received, BindSmResp);
                            OnBindSmResp(BindSmResp);

                            BindDone.Set();
                            break;

                            #endregion

                        case CommandSet.BindTransceiver:
                        case CommandSet.BindReceiver:
                        case CommandSet.BindTransmitter:
                            #region Bind

                            BindSm bindSm = BindSm.Create(DefaultEncoding, sb, ref offset);
                            if (bindSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, bindSm);
                                CommandStatus commandStatus = OnBindSm(bindSm);

                                CommandSet commandSet = (bindSm.Command == CommandSet.BindTransmitter) ? CommandSet.BindTransmitterResp :
                                                        (bindSm.Command == CommandSet.BindReceiver) ? CommandSet.BindReceiverResp : CommandSet.BindTransceiverResp;

                                SendPacket(BindSmResp.Create(DefaultEncoding, bindSm, commandSet, commandStatus, "AS"));
                            }
                            break;

                            #endregion

                        case CommandSet.CancelSm:
                            #region Cancel

                            CancelSm cancelSm = CancelSm.Create(DefaultEncoding, sb, ref offset);
                            if (cancelSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, cancelSm);
                                CommandStatus commandStatus = OnCancelSm(cancelSm);

                                SendPacket(CancelSmResp.Create(DefaultEncoding, cancelSm, commandStatus));
                            }
                            else
                            {
                                SendPacket(CancelSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid CANCEL_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.CancelSmResp:
                            #region Cancel Response

                            CancelSmResp cancelResp = CancelSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (cancelResp == null)
                            {
                                cancelResp = CancelSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP);
                            }

                            OnPduDetails(PduDirectionTypes.Received, cancelResp);
                            OnCancelSmResp(cancelResp);
                            break;

                            #endregion

                        case CommandSet.DataSm:
                            #region Data Received

                            DataSm dataSm = DataSm.Create(DefaultEncoding, sb, ref offset);
                            if (dataSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, dataSm);

                                string messageId = null;
                                CommandStatus commandStatus = OnDataSm(dataSm, out messageId);

                                SendPacket(DataSmResp.Create(DefaultEncoding, dataSm, commandStatus, messageId));
                            }
                            else
                            {
                                SendPacket(DataSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid DATA_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.DataSmResp:
                            #region Data Response

                            DataSmResp dataSmResp = DataSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (dataSmResp == null)
                            {
                                dataSmResp = DataSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP);
                            }

                            OnPduDetails(PduDirectionTypes.Received, dataSmResp);
                            OnDataSmResp(dataSmResp);
                            break;

                            #endregion

                        case CommandSet.DeliverSm:
                            #region Deliver Received

                            DeliverSm deliverSm = DeliverSm.Create(DefaultEncoding, sb, ref offset);
                            if (deliverSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, deliverSm);
                                CommandStatus commandStatus = OnDeliverSm(deliverSm);

                                SendPacket(DeliverSmResp.Create(DefaultEncoding, deliverSm, commandStatus));
                            }
                            else
                            {
                                SendPacket(DeliverSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid DELIVER_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.DeliverSmResp:
                            #region Deliver Resp Received

                            DeliverSmResp deliverSmResp = DeliverSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (deliverSmResp == null)
                            {
                                deliverSmResp = DeliverSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP);
                            }

                            OnPduDetails(PduDirectionTypes.Received, deliverSmResp);
                            OnDeliverSmResp(deliverSmResp);
                            break;

                            #endregion

                        case CommandSet.EnquireLink:
                            #region EnquireLink

                            EnquireLinkSm enquireLink = EnquireLinkSm.Create(DefaultEncoding, sb, ref offset);
                            if (enquireLink != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, enquireLink);
                                CommandStatus commandStatus = OnEnquireLinkSm(enquireLink);

                                SendPacket(EnquireLinkSmResp.Create(DefaultEncoding, enquireLink, commandStatus));
                            }
                            else
                            {
                                SendPacket(EnquireLinkSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid ENQUIRELINK packet");
                            }

                            break;

                            #endregion

                        case CommandSet.EnquireLinkResp:
                            #region EnquireLink Response

                            EnquireLinkSmResp = EnquireLinkSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (EnquireLinkSmResp == null)
                            {
                                EnquireLinkSmResp = EnquireLinkSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP, 0);
                            }

                            OnPduDetails(PduDirectionTypes.Received, EnquireLinkSmResp);
                            OnEnquireLinkSmResp(EnquireLinkSmResp);

                            EnquireDone.Set();
                            break;

                            #endregion

                        case CommandSet.GenericNack:
                            #region GenericNack Received

                            GenericNackSm nack = GenericNackSm.Create(DefaultEncoding, sb, ref offset);
                            if (nack == null)
                            {
                                nack = GenericNackSm.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP, hd.Sequence);
                            }

                            OnPduDetails(PduDirectionTypes.Received, nack);
                            OnGenericNackSm(nack);

                            GenericDone.Set();
                            break;

                            #endregion

                        case CommandSet.QuerySm:
                            #region Query Received

                            QuerySm querySm = QuerySm.Create(DefaultEncoding, sb, ref offset);
                            if (querySm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, querySm);
                                SendPacket(OnQuerySm(querySm));
                            }
                            else
                            {
                                SendPacket(QuerySmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid QUERY_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.QuerySmResp:
                            #region Query Response

                            QuerySmResp querySmResp = QuerySmResp.Create(DefaultEncoding, sb, ref offset);
                            if (querySmResp == null)
                            {
                                querySmResp = QuerySmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP);
                            }

                            OnPduDetails(PduDirectionTypes.Received, querySmResp);
                            OnQuerySmResp(querySmResp);
                            break;

                            #endregion

                        case CommandSet.SubmitSm:
                            #region Submit Received

                            SubmitSm submitSm = SubmitSm.Create(DefaultEncoding, sb, ref offset);
                            if (submitSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, submitSm);

                                string messageId = null;
                                CommandStatus commandStatus = OnSubmitSm(submitSm, out messageId);

                                SendPacket(SubmitSmResp.Create(DefaultEncoding, submitSm, commandStatus, messageId));
                            }
                            else
                            {
                                SendPacket(SubmitSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid SUBMIT_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.SubmitSmResp:
                            #region Submit Response

                            SubmitSmResp submitSmResp = SubmitSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (submitSmResp == null)
                            {
                                submitSmResp = SubmitSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP, submitSmResp.Sequence);
                            }

                            OnPduDetails(PduDirectionTypes.Received, submitSmResp);
                            OnSubmitSmResp(submitSmResp);

                            lock (SubmitDone)
                            {
                                if (SubmitDone.ContainsKey(submitSmResp.Sequence) == true)
                                {
                                    EventData eventData = SubmitDone[submitSmResp.Sequence];
                                    eventData.ResponseObject = submitSmResp;
                                    eventData.SignalEvent.Set();
                                }
                            }
                            break;

                            #endregion

                        case CommandSet.SubmitMultiSm:
                            #region SubmitMulti Received

                            SubmitMultiSm submitMultiSm = SubmitMultiSm.Create(DefaultEncoding, sb, ref offset);
                            if (submitMultiSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, submitMultiSm);

                                string messageId = null;
                                CommandStatus commandStatus = OnSubmitMultiSm(submitMultiSm, out messageId);

                                SendPacket(SubmitMultiSmResp.Create(DefaultEncoding, submitMultiSm, commandStatus, messageId));
                            }
                            else
                            {
                                SendPacket(SubmitMultiSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, hd.Sequence));

                                OnError("Invalid SUBMIT_MULTI_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.SubmitMultiSmResp:
                            #region SubmitMulti Response

                            SubmitMultiSmResp submitMultiSmResp = SubmitMultiSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (submitMultiSmResp == null)
                            {
                                submitMultiSmResp = SubmitMultiSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP, submitMultiSmResp.Sequence);
                            }

                            OnPduDetails(PduDirectionTypes.Received, submitMultiSmResp);
                            OnSubmitMultiSmResp(submitMultiSmResp);

                            lock (SubmitDone)
                            {
                                if (SubmitDone.ContainsKey(submitMultiSmResp.Sequence) == true)
                                {
                                    EventData eventData = SubmitDone[submitMultiSmResp.Sequence];
                                    eventData.ResponseObject = submitMultiSmResp;
                                    eventData.SignalEvent.Set();
                                }
                            }
                            break;

                            #endregion

                        case CommandSet.Unbind:
                            #region Unbind

                            UnBindSm unBindSm = UnBindSm.Create(DefaultEncoding, sb, ref offset);
                            if (unBindSm != null)
                            {
                                OnPduDetails(PduDirectionTypes.Received, unBindSm);

                                SendPacket(UnBindSmResp.Create(DefaultEncoding, unBindSm, CommandStatus.ESME_ROK));
                                OnUnBindSm(unBindSm);
                            }
                            else
                            {
                                SendPacket(UnBindSmResp.Create(DefaultEncoding, CommandStatus.ESME_RSYSERR, unBindSm.Sequence));

                                OnError("Invalid UNBIND_SM packet");
                            }
                            break;

                            #endregion

                        case CommandSet.UnbindResp:
                            #region Unbind Response

                            UnBindSmResp = UnBindSmResp.Create(DefaultEncoding, sb, ref offset);
                            if (UnBindSmResp == null)
                            {
                                UnBindSmResp = UnBindSmResp.Create(DefaultEncoding, CommandStatus.SMPPCLIENT_UNEXPRESP);
                            }

                            OnPduDetails(PduDirectionTypes.Received, UnBindSmResp);
                            OnUnBindSmResp(UnBindSmResp);

                            UnbindDone.Set();
                            break;

                            #endregion

                        default:
                            offset++;
                            OnError("Undefined packet received : " + hd.Command.ToString() + " with status " + hd.Status.ToString());
                            break;
                    }

                    #endregion

                    // Move the offset past this command
                    offset = startOffset + commandLength;
                }

                // Clear the buffer we processed everything
                _SocketClient.MessageBuffer.SetLength(0);

                // Mark we processed a pdu
                lock (_LastPduLock)
                {
                    _LastPdu = DateTime.Now;
                }
            }

            catch (Exception exception)
            {
                _SocketClient.MessageBuffer.SetLength(0);
                OnError(exception.ToString());
            }
        }