Examples with Esme org.restcomm.smpp.Esme used on opensource projects

Example 16 with Esme

use of org.restcomm.smpp.Esme in project smscgateway by RestComm.

the class DeliveryCommonSbb method applyMProcPreDelivery.

private boolean applyMProcPreDelivery(Sms sms, ProcessingType processingType) {
    MProcResult mProcResult = MProcManagement.getInstance().applyMProcPreDelivery(itsMProcRa, sms, processingType);
    if (mProcResult.isMessageIsRerouted()) {
        // firstly we check if rerouting attempts was not too many
        if (sms.getReroutingCount() >= MAX_POSSIBLE_REROUTING) {
            StringBuilder sb = new StringBuilder();
            sb.append("Rerouting message attempt in PreDelivery, but we have already rerouted ");
            sb.append(MAX_POSSIBLE_REROUTING);
            sb.append(" times before: targetId=");
            sb.append(sms.getSmsSet().getTargetId());
            sb.append(", newNetworkId=");
            sb.append(mProcResult.getNewNetworkId());
            sb.append(", sms=");
            sb.append(sms);
            this.logger.warning(sb.toString());
            return false;
        } else if (mProcResult.getNewNetworkId() == sms.getSmsSet().getNetworkId()) {
            // we do not reroute for the same networkId
            return true;
        } else {
            ArrayList<Sms> lstRerouted = new ArrayList<Sms>();
            ArrayList<Integer> lstNewNetworkId = new ArrayList<Integer>();
            lstRerouted.add(sms);
            lstNewNetworkId.add(mProcResult.getNewNetworkId());
            if (this.logger.isInfoEnabled()) {
                StringBuilder sb = new StringBuilder();
                sb.append("Rerouting message in PreDelivery: targetId=");
                sb.append(sms.getSmsSet().getTargetId());
                sb.append(", newNetworkId=");
                sb.append(mProcResult.getNewNetworkId());
                sb.append(", sms=");
                sb.append(sms);
                this.logger.info(sb.toString());
            }
            postProcessRerouted(lstRerouted, lstNewNetworkId);
            return false;
        }
    } else if (mProcResult.isMessageDropped()) {
        if (this.logger.isInfoEnabled()) {
            StringBuilder sb = new StringBuilder();
            sb.append("Dropping message after in PreDelivery: targetId=");
            sb.append(sms.getSmsSet().getTargetId());
            sb.append(", sms=");
            sb.append(sms);
            this.logger.info(sb.toString());
        }
        ArrayList<Sms> lstPermFailured = new ArrayList<Sms>();
        lstPermFailured.add(sms);
        ErrorCode smStatus = ErrorCode.MPROC_PRE_DELIVERY_DROP;
        ErrorAction errorAction = ErrorAction.permanentFailure;
        String reason = "Message drop in PreDelivery";
        sms.getSmsSet().setStatus(smStatus);
        // sending of a failure response for transactional mode
        this.sendTransactionalResponseFailure(lstPermFailured, null, errorAction, null);
        // Processing messages that were temp or permanent failed or rerouted
        this.postProcessPermFailures(lstPermFailured, null, null);
        // generating CDRs for permanent failure messages
        this.generateCDRs(lstPermFailured, CdrGenerator.CDR_MPROC_DROP_PRE_DELIVERY, reason);
        EsmeManagement esmeManagement = EsmeManagement.getInstance();
        Esme esme = esmeManagement.getEsmeByClusterName(smsSet.getDestClusterName());
        String messageType = esme.getSmppSessionType() == Type.CLIENT ? CdrDetailedGenerator.CDR_MSG_TYPE_SUBMITSM : CdrDetailedGenerator.CDR_MSG_TYPE_DELIVERSM;
        this.generateDetailedCDRs(lstPermFailured, EventType.OUT_SMPP_ERROR, smStatus, messageType, esme.getRemoteAddressAndPort(), -1);
        // sending of failure delivery receipts
        this.generateFailureReceipts(sms.getSmsSet(), lstPermFailured, null);
        return false;
    }
    FastList<Sms> addedMessages = mProcResult.getMessageList();
    if (addedMessages != null) {
        for (FastList.Node<Sms> n = addedMessages.head(), end = addedMessages.tail(); (n = n.getNext()) != end; ) {
            Sms smst = n.getValue();
            TargetAddress ta = new TargetAddress(smst.getSmsSet().getDestAddrTon(), smst.getSmsSet().getDestAddrNpi(), smst.getSmsSet().getDestAddr(), smst.getSmsSet().getNetworkId());
            this.sendNewGeneratedMessage(smst, ta);
            if (this.logger.isInfoEnabled()) {
                StringBuilder sb = new StringBuilder();
                sb.append("Posting of a new message after PreDelivery: targetId=");
                sb.append(smst.getSmsSet().getTargetId());
                sb.append(", sms=");
                sb.append(smst);
                this.logger.info(sb.toString());
            }
        }
    }
    return true;
}

Example 17 with Esme

use of org.restcomm.smpp.Esme in project smscgateway by RestComm.

the class DefaultSmsRoutingRule method getEsmeClusterName.

/*
	 * (non-Javadoc)
	 * 
	 * @see org.mobicents.smsc.smpp.SmsRoutingRule#getSystemId(byte, byte,
	 * java.lang.String)
	 */
@Override
public String getEsmeClusterName(int ton, int npi, String address, String name, int networkId) {
    // for (Esme esme : this.esmeManagement.getEsmes()) {
    for (FastList.Node<Esme> n = this.esmeManagement.getEsmes().head(), end = this.esmeManagement.getEsmes().tail(); (n = n.getNext()) != end; ) {
        Esme esme = n.getValue();
        SmppBindType sessionBindType = esme.getSmppBindType();
        SmppSession.Type smppSessionType = esme.getSmppSessionType();
        if (sessionBindType == SmppBindType.TRANSCEIVER || (sessionBindType == SmppBindType.RECEIVER && smppSessionType == SmppSession.Type.SERVER) || (sessionBindType == SmppBindType.TRANSMITTER && smppSessionType == SmppSession.Type.CLIENT)) {
            if (!(esme.getName().equals(name)) && esme.getNetworkId() == networkId && esme.isRoutingAddressMatching(ton, npi, address)) {
                return esme.getClusterName();
            }
        }
    }
    return null;
}

Example 18 with Esme

use of org.restcomm.smpp.Esme in project smscgateway by RestComm.

the class TxSmppServerSbb method onDataSmLocal.

private void onDataSmLocal(final TxSmppServerSbbUsage anSbbUsage, final com.cloudhopper.smpp.pdu.DataSm event, ActivityContextInterface aci) {
    SmppTransaction smppServerTransaction = (SmppTransaction) aci.getActivity();
    Esme esme = smppServerTransaction.getEsme();
    String esmeName = esme.getName();
    if (this.logger.isFineEnabled()) {
        this.logger.fine("Received DATA_SM = " + event + " from Esme name=" + esmeName);
    }
    CheckMessageLimitResult cres = esme.onMessageReceived(1);
    if (cres.getResult() != CheckMessageLimitResult.Result.ok) {
        if (cres.getResult() == CheckMessageLimitResult.Result.firstFault) {
            this.updateOverrateCounters(cres);
            this.logger.info(cres.getMessage());
        }
        if (smscPropertiesManagement.isGenerateRejectionCdr()) {
            generateCDR(parseShortMessageText(event), esme.getNetworkId(), esme.getSystemId(), event.getSourceAddress().getAddress(), event.getSourceAddress().getTon(), event.getSourceAddress().getNpi(), event.getDestAddress().getAddress(), event.getDestAddress().getTon(), event.getDestAddress().getNpi(), CdrGenerator.CDR_SUBMIT_FAILED_ESME, cres.getMessage(), true);
        }
        DataSmResp response = event.createResponse();
        response.setCommandStatus(SmppConstants.STATUS_THROTTLED);
        String s = cres.getMessage();
        if (s.length() > 255)
            s = s.substring(0, 255);
        Tlv tlv;
        try {
            tlv = TlvUtil.createNullTerminatedStringTlv(SmppConstants.TAG_ADD_STATUS_INFO, s);
            response.addOptionalParameter(tlv);
        } catch (TlvConvertException e) {
            anSbbUsage.incrementCounterErrorDataSm(ONE);
            this.logger.severe("TlvConvertException while storing TAG_ADD_STATUS_INFO Tlv parameter", e);
        }
        // Lets send the Response with error here
        try {
            this.smppServerSessions.sendResponsePdu(esme, event, response);
        } catch (Exception e) {
            anSbbUsage.incrementCounterErrorDataSmResponding(ONE);
            this.logger.severe("Error while trying to send DataSmResponse=" + response, e);
        }
        try {
            TargetAddress ta = createDestTargetAddress(event.getDestAddress(), esme.getNetworkId());
            Sms sms = this.createSmsEvent(event, esme, ta, persistence);
            sms.setTimestampB(System.currentTimeMillis());
            generateFailureDetailedCdr(sms, EventType.IN_SMPP_REJECT_CONG, ErrorCode.REJECT_INCOMING, CdrDetailedGenerator.CDR_MSG_TYPE_DATASM, SmppConstants.STATUS_THROTTLED, esme.getRemoteAddressAndPort(), event.getSequenceNumber());
        } catch (SmscProcessingException e1) {
        }
        return;
    }
    Sms sms = null;
    try {
        TargetAddress ta = createDestTargetAddress(event.getDestAddress(), esme.getNetworkId());
        sms = this.createSmsEvent(event, esme, ta, persistence);
        this.processSms(sms, persistence, esme, null, event, null, IncomingMessageType.data_sm, CdrDetailedGenerator.CDR_MSG_TYPE_DATASM, event.getSequenceNumber());
    } catch (SmscProcessingException e1) {
        anSbbUsage.incrementCounterErrorDataSm(ONE);
        SbbStatsUtils.handleProcessingException(e1, anSbbUsage);
        if (!e1.isSkipErrorLogging()) {
            if (e1.isIsWarning()) {
                this.logger.warning(e1.getMessage());
            } else {
                this.logger.severe(e1.getMessage(), e1);
            }
            smscStatAggregator.updateMsgInFailedAll();
        }
        if (smscPropertiesManagement.isGenerateRejectionCdr() && !e1.isMessageRejectCdrCreated()) {
            if (sms != null) {
                generateCDR(sms, CdrGenerator.CDR_SUBMIT_FAILED_ESME, e1.getMessage(), false, true);
            } else {
                generateCDR(parseShortMessageText(event), esme.getNetworkId(), esme.getSystemId(), event.getSourceAddress().getAddress(), event.getSourceAddress().getTon(), event.getSourceAddress().getNpi(), event.getDestAddress().getAddress(), event.getDestAddress().getTon(), event.getDestAddress().getNpi(), CdrGenerator.CDR_SUBMIT_FAILED_ESME, e1.getMessage(), true);
            }
        }
        DataSmResp response = event.createResponse();
        response.setCommandStatus(e1.getSmppErrorCode());
        String s = e1.getMessage();
        if (s != null) {
            if (s.length() > 255)
                s = s.substring(0, 255);
            Tlv tlv;
            try {
                tlv = TlvUtil.createNullTerminatedStringTlv(SmppConstants.TAG_ADD_STATUS_INFO, s);
                response.addOptionalParameter(tlv);
            } catch (TlvConvertException e) {
                this.logger.severe("TlvConvertException while storing TAG_ADD_STATUS_INFO Tlv parameter", e);
            }
        }
        // Lets send the Response with error here
        long timestampB = 0L;
        try {
            this.smppServerSessions.sendResponsePdu(esme, event, response);
            timestampB = System.currentTimeMillis();
        } catch (Exception e) {
            anSbbUsage.incrementCounterErrorDataSmResponding(ONE);
            this.logger.severe("Error while trying to send DataSmResponse=" + response, e);
        }
        EventType eventType = null;
        if (e1.getInternalErrorCode() == SmscProcessingException.INTERNAL_ERROR_STATE_OVERLOADED) {
            eventType = EventType.IN_SMPP_REJECT_CONG;
        } else {
            eventType = EventType.IN_SMPP_REJECT_FORBIDDEN;
        }
        if (sms != null) {
            sms.setTimestampB(System.currentTimeMillis());
            generateRejectDetailedCdr(e1.getInternalErrorCode(), sms, eventType, ErrorCode.REJECT_INCOMING, CdrDetailedGenerator.CDR_MSG_TYPE_DATASM, e1.getSmppErrorCode(), esme.getRemoteAddressAndPort(), event.getSequenceNumber());
        } else {
            generateRejectDetailedCdr(e1.getInternalErrorCode(), event, esme, eventType, ErrorCode.REJECT_INCOMING, CdrDetailedGenerator.CDR_MSG_TYPE_SUBMITSM, e1.getSmppErrorCode(), parseShortMessageText(event), timestampB);
        }
        return;
    } catch (Throwable e1) {
        anSbbUsage.incrementCounterErrorDataSm(ONE);
        String s = "Exception when processing dataSm message: " + e1.getMessage();
        this.logger.severe(s, e1);
        smscStatAggregator.updateMsgInFailedAll();
        if (smscPropertiesManagement.isGenerateRejectionCdr()) {
            generateCDR(parseShortMessageText(event), esme.getNetworkId(), esme.getSystemId(), event.getSourceAddress().getAddress(), event.getSourceAddress().getTon(), event.getSourceAddress().getNpi(), event.getDestAddress().getAddress(), event.getDestAddress().getTon(), event.getDestAddress().getNpi(), CdrGenerator.CDR_SUBMIT_FAILED_ESME, e1.getMessage(), true);
        }
        DataSmResp response = event.createResponse();
        response.setCommandStatus(SmppConstants.STATUS_SYSERR);
        if (s.length() > 255)
            s = s.substring(0, 255);
        Tlv tlv;
        try {
            tlv = TlvUtil.createNullTerminatedStringTlv(SmppConstants.TAG_ADD_STATUS_INFO, s);
            response.addOptionalParameter(tlv);
        } catch (TlvConvertException e) {
            this.logger.severe("TlvConvertException while storing TAG_ADD_STATUS_INFO Tlv parameter", e);
        }
        // Lets send the Response with error here
        try {
            this.smppServerSessions.sendResponsePdu(esme, event, response);
            if (sms != null) {
                sms.setTimestampB(System.currentTimeMillis());
                generateFailureDetailedCdr(sms, EventType.IN_SMPP_ERROR, ErrorCode.REJECT_INCOMING, CdrDetailedGenerator.CDR_MSG_TYPE_DATASM, SmppConstants.STATUS_SYSERR, esme.getRemoteAddressAndPort(), event.getSequenceNumber());
            }
        } catch (Exception e) {
            anSbbUsage.incrementCounterErrorDataSmResponding(ONE);
            this.logger.severe("Error while trying to send SubmitSmResponse=" + response, e);
        }
        return;
    }
    DataSmResp response = event.createResponse();
    response.setMessageId(sms.getMessageIdText());
    // Lets send the Response with success here
    try {
        if (sms.getMessageDeliveryResultResponse() == null) {
            this.smppServerSessions.sendResponsePdu(esme, event, response);
            sms.setTimestampB(System.currentTimeMillis());
            generateDetailedCDR(sms, EventType.IN_SMPP_RECEIVED, CdrDetailedGenerator.CDR_MSG_TYPE_DATASM, SmppConstants.STATUS_OK, esme.getRemoteAddressAndPort(), event.getSequenceNumber());
        }
    } catch (Exception e) {
        anSbbUsage.incrementCounterErrorDataSmResponding(ONE);
        this.logger.severe("Error while trying to send DataSmResponse=" + response, e);
    }
}

Example 19 with Esme

use of org.restcomm.smpp.Esme in project smscgateway by RestComm.

the class SubmitCommonSbb method forwardMessage.

protected void forwardMessage(Sms sms0, boolean withCharging, SmscStatAggregator smscStatAggregator, String messageType, int seqNumber) throws SmscProcessingException {
    ChargingMedium chargingMedium = null;
    EventType eventTypeFailure = null;
    int statusCode = 0;
    switch(sms0.getOriginationType()) {
        case SMPP:
            chargingMedium = ChargingMedium.TxSmppOrig;
            eventTypeFailure = EventType.IN_SMPP_REJECT_MPROC;
            break;
        case SS7_MO:
        case SS7_HR:
            chargingMedium = ChargingMedium.MoOrig;
            break;
        case SIP:
            chargingMedium = ChargingMedium.TxSipOrig;
            break;
        case HTTP:
            chargingMedium = ChargingMedium.HttpOrig;
            eventTypeFailure = EventType.IN_HTTP_REJECT_MPROC;
            break;
    }
    if (withCharging) {
        ChargingSbbLocalObject chargingSbb = getChargingSbbObject();
        chargingSbb.setupChargingRequestInterface(chargingMedium, sms0);
    } else {
        // applying of MProc
        MProcResult mProcResult = MProcManagement.getInstance().applyMProcArrival(itsMProcRa, sms0, persistence);
        FastList<Sms> smss = mProcResult.getMessageList();
        if (smss != null) {
            for (FastList.Node<Sms> n = smss.head(), end = smss.tail(); (n = n.getNext()) != end; ) {
                Sms sms = n.getValue();
                TargetAddress ta = new TargetAddress(sms.getSmsSet());
                TargetAddress lock = persistence.obtainSynchroObject(ta);
                try {
                    sms.setTimestampC(System.currentTimeMillis());
                    synchronized (lock) {
                        boolean storeAndForwMode = MessageUtil.isStoreAndForward(sms);
                        if (!storeAndForwMode) {
                            try {
                                this.scheduler.injectSmsOnFly(sms.getSmsSet(), true);
                            } catch (Exception e) {
                                throw new SmscProcessingException("Exception when running injectSmsOnFly(): " + e.getMessage(), SmppConstants.STATUS_SYSERR, MAPErrorCode.systemFailure, SmscProcessingException.HTTP_ERROR_CODE_NOT_SET, null, e, SmscProcessingException.INTERNAL_ERROR_INJECT_STORE_AND_FORWARD_NOT_SET);
                            }
                        } else {
                            // store and forward
                            if (smscPropertiesManagement.getStoreAndForwordMode() == StoreAndForwordMode.fast && sms.getScheduleDeliveryTime() == null) {
                                try {
                                    sms.setStoringAfterFailure(true);
                                    this.scheduler.injectSmsOnFly(sms.getSmsSet(), true);
                                } catch (Exception e) {
                                    throw new SmscProcessingException("Exception when running injectSmsOnFly(): " + e.getMessage(), SmppConstants.STATUS_SYSERR, MAPErrorCode.systemFailure, SmscProcessingException.HTTP_ERROR_CODE_NOT_SET, null, e, SmscProcessingException.INTERNAL_ERROR_INJECT_STORE_AND_FORWARD_FAST);
                                }
                            } else {
                                try {
                                    sms.setStored(true);
                                    this.scheduler.setDestCluster(sms.getSmsSet());
                                    persistence.c2_scheduleMessage_ReschedDueSlot(sms, smscPropertiesManagement.getStoreAndForwordMode() == StoreAndForwordMode.fast, false);
                                } catch (PersistenceException e) {
                                    throw new SmscProcessingException("PersistenceException when storing LIVE_SMS : " + e.getMessage(), SmppConstants.STATUS_SUBMITFAIL, MAPErrorCode.systemFailure, SmscProcessingException.HTTP_ERROR_CODE_NOT_SET, null, e, SmscProcessingException.INTERNAL_ERROR_INJECT_STORE_AND_FORWARD_NORMAL);
                                }
                            }
                        }
                    }
                } finally {
                    persistence.releaseSynchroObject(lock);
                }
            }
        }
        if (mProcResult.isMessageRejected()) {
            sms0.setMessageDeliveryResultResponse(null);
            if (eventTypeFailure != null) {
                String sourceAddrAndPort = null;
                if (eventTypeFailure == EventType.IN_SMPP_REJECT_MPROC) {
                    EsmeManagement esmeManagement = EsmeManagement.getInstance();
                    if (esmeManagement != null) {
                        // for testing there is no EsmeManagement
                        Esme esme = esmeManagement.getEsmeByClusterName(sms0.getOrigEsmeName());
                        // null check is for testing
                        if (esme != null) {
                            sourceAddrAndPort = esme.getRemoteAddressAndPort();
                        }
                    }
                    statusCode = mProcResult.getSmppErrorCode();
                } else if (eventTypeFailure == EventType.IN_HTTP_REJECT_MPROC) {
                    statusCode = mProcResult.getHttpErrorCode();
                }
                generateMprocFailureDetailedCdr(sms0, eventTypeFailure, ErrorCode.REJECT_INCOMING_MPROC, messageType, statusCode, mProcResult.getRuleIdDropReject(), sourceAddrAndPort, seqNumber);
            }
            rejectSmsByMProc(sms0, "Message is rejected by MProc rules.", mProcResult);
        }
        if (mProcResult.isMessageDropped()) {
            sms0.setMessageDeliveryResultResponse(null);
            smscStatAggregator.updateMsgInFailedAll();
            if (eventTypeFailure != null) {
                String sourceAddrAndPort = null;
                if (eventTypeFailure == EventType.IN_SMPP_REJECT_MPROC) {
                    eventTypeFailure = EventType.IN_SMPP_DROP_MPROC;
                    EsmeManagement esmeManagement = EsmeManagement.getInstance();
                    if (esmeManagement != null) {
                        // for testing there is no EsmeManagement
                        Esme esme = esmeManagement.getEsmeByClusterName(sms0.getOrigEsmeName());
                        // null check is for testing
                        if (esme != null) {
                            sourceAddrAndPort = esme.getRemoteAddressAndPort();
                        }
                    }
                    statusCode = mProcResult.getSmppErrorCode();
                } else if (eventTypeFailure == EventType.IN_HTTP_REJECT_MPROC) {
                    eventTypeFailure = EventType.IN_HTTP_DROP_MPROC;
                    statusCode = mProcResult.getHttpErrorCode();
                }
                generateMprocFailureDetailedCdr(sms0, eventTypeFailure, ErrorCode.REJECT_INCOMING_MPROC, messageType, statusCode, mProcResult.getRuleIdDropReject(), sourceAddrAndPort, seqNumber);
            }
            rejectSmsByMProc(sms0, "Message is dropped by MProc rules.", mProcResult);
        }
        smscStatAggregator.updateMsgInReceivedAll();
        switch(sms0.getOriginationType()) {
            case SMPP:
                smscStatAggregator.updateMsgInReceivedSmpp();
                break;
            case SS7_MO:
                smscStatAggregator.updateMsgInReceivedSs7();
                smscStatAggregator.updateMsgInReceivedSs7Mo();
                break;
            case SS7_HR:
                smscStatAggregator.updateMsgInReceivedSs7();
                smscStatAggregator.updateMsgInReceivedSs7Hr();
                break;
            case SIP:
                smscStatAggregator.updateMsgInReceivedSip();
                break;
        }
    }
}

Example 20 with Esme

use of org.restcomm.smpp.Esme in project smscgateway by RestComm.

the class RxSmppServerSbb method handleResponse.

/**
 * Processing of a positive delivery response to smpp destination.
 *
 * @param event
 * @throws Exception
 */
private void handleResponse(BaseSmResp event) throws Exception {
    long ts = System.currentTimeMillis();
    if (isDeliveringEnded()) {
        if (logger.isFineEnabled()) {
            this.logger.fine("SMPP Response received when DeliveringEnded state: status=" + event.getCommandStatus());
        }
    }
    if (isDeliveringEnded()) {
        logger.info("RxSmppServerSbb.handleResponse(): received submit/deliver_sm_response but delivery process is already ended, dropping of a response");
        return;
    }
    SmsSet smsSet = getSmsSet();
    if (smsSet == null) {
        logger.severe("RxSmppServerSbb.handleResponse(): CMP smsSet is missed");
        markDeliveringIsEnded(true);
        return;
    }
    int status = event.getCommandStatus();
    if (status == 0) {
        smscStatAggregator.updateMsgOutSentAll();
        smscStatAggregator.updateMsgOutSentSmpp();
        boolean destAddressLimitationEnabled = false;
        EsmeManagement esmeManagement = EsmeManagement.getInstance();
        Esme esme = esmeManagement.getEsmeByClusterName(smsSet.getDestClusterName());
        if (esme != null) {
            destAddressLimitationEnabled = esme.getDestAddrSendLimit() != 0;
        }
        int realID = -1;
        Boolean sentListChanged = false;
        SentItemsList list = null;
        if (destAddressLimitationEnabled) {
            list = retreiveSentChunks();
            for (int i = 0; i < list.getSentList().size(); i++) {
                if (list.getSentList().get(i).getRemoteSequenceNumber() == event.getSequenceNumber()) {
                    realID = list.getSentList().get(i).getLocalSequenceNumber();
                    list.getSentList().remove(i);
                    sentListChanged = true;
                    break;
                }
            }
        } else {
            realID = event.getSequenceNumber();
        }
        ConfirmMessageInSendingPool confirmMessageInSendingPool = null;
        if (realID != -1)
            confirmMessageInSendingPool = confirmMessageInSendingPool(realID);
        if (realID == -1 || !confirmMessageInSendingPool.sequenceNumberFound) {
            this.logger.severe("RxSmppServerSbb.handleResponse(): no sms in MessageInSendingPool: UnconfirmedCnt=" + this.getUnconfirmedMessageCountInSendingPool() + ", sequenceNumber=" + event.getSequenceNumber() + ", realID=" + realID + ", confirmMessageInSendingPool=" + confirmMessageInSendingPool);
            this.onDeliveryError(smsSet, ErrorAction.temporaryFailure, ErrorCode.SC_SYSTEM_ERROR, "Received undefined SequenceNumber: " + event.getSequenceNumber() + ", SmsSet=" + smsSet, EventType.OUT_SMPP_ERROR, realID);
            if (sentListChanged)
                setSentChunks(list);
            return;
        }
        Sms sms = confirmMessageInSendingPool.sms;
        if (sms != null) {
            sms.setTimestampC(System.currentTimeMillis());
        }
        if (destAddressLimitationEnabled) {
            ChunkDataList dataList = retreivePendingChunks();
            if (dataList != null && !dataList.getPendingList().isEmpty()) {
                // so checking if has window
                if (list.getSentList().size() < esme.getDestAddrSendLimit()) {
                    ChunkData current = dataList.getPendingList().remove(0);
                    setPendingChunks(dataList);
                    if (current != null) {
                        SentItem newItem = sendNextChunk(current, smsSet, esme);
                        SentItemsList sentChunks = retreiveSentChunks();
                        sentChunks.getSentList().add(newItem);
                        sentListChanged = true;
                    }
                }
            }
        }
        if (sentListChanged)
            setSentChunks(list);
        if (!confirmMessageInSendingPool.confirmed) {
            this.generateCDR(sms, CdrGenerator.CDR_PARTIAL_ESME, CdrGenerator.CDR_SUCCESS_NO_REASON, true, false, event.getSequenceNumber());
            String messageType = esme.getSmppSessionType() == Type.CLIENT ? CdrDetailedGenerator.CDR_MSG_TYPE_SUBMITSM : CdrDetailedGenerator.CDR_MSG_TYPE_DELIVERSM;
            this.generateDetailedCDR(sms, EventType.OUT_SMPP_SENT, sms.getSmsSet().getStatus(), messageType, status, esme.getRemoteAddressAndPort(), event.getSequenceNumber());
            return;
        }
        // firstly we store remote messageId if sms has a request to delivery receipt
        String clusterName = smsSet.getDestClusterName();
        String dlvMessageId = event.getMessageId();
        sms.setDlvMessageId(dlvMessageId);
        // if (MessageUtil.isDeliveryReceiptRequest(sms)) {
        // SmsSetCache.getInstance().putDeliveredRemoteMsgIdValue(dlvMessageId, clusterName, sms.getMessageId(), 30);
        // }
        // current message is sent
        // firstly sending of a positive response for transactional mode
        sendTransactionalResponseSuccess(sms);
        // mproc rules applying for delivery phase
        this.applyMprocRulesOnSuccess(sms, ProcessingType.SMPP);
        // Processing succeeded
        sms.getSmsSet().setStatus(ErrorCode.SUCCESS);
        this.postProcessSucceeded(sms, dlvMessageId, clusterName);
        // success CDR generating
        boolean isPartial = MessageUtil.isSmsNotLastSegment(sms);
        this.generateCDR(sms, isPartial ? CdrGenerator.CDR_PARTIAL_ESME : CdrGenerator.CDR_SUCCESS_ESME, CdrGenerator.CDR_SUCCESS_NO_REASON, confirmMessageInSendingPool.splittedMessage, true, event.getSequenceNumber());
        String messageType = null;
        String remoteAddr = null;
        if (esme != null) {
            messageType = esme.getSmppSessionType() == Type.CLIENT ? CdrDetailedGenerator.CDR_MSG_TYPE_SUBMITSM : CdrDetailedGenerator.CDR_MSG_TYPE_DELIVERSM;
            remoteAddr = esme.getRemoteAddressAndPort();
        }
        if (messageType == null) {
            if (event.getCommandId() == SmppConstants.CMD_ID_DELIVER_SM_RESP) {
                messageType = CdrDetailedGenerator.CDR_MSG_TYPE_DELIVERSM;
            } else {
                messageType = CdrDetailedGenerator.CDR_MSG_TYPE_SUBMITSM;
            }
        }
        this.generateDetailedCDR(sms, EventType.OUT_SMPP_SENT, sms.getSmsSet().getStatus(), messageType, status, remoteAddr, event.getSequenceNumber());
        // adding a success receipt if it is needed
        this.generateSuccessReceipt(smsSet, sms);
        if (this.getUnconfirmedMessageCountInSendingPool() == 0) {
            // all sent messages are confirmed - we are sending new message set
            TargetAddress lock = persistence.obtainSynchroObject(new TargetAddress(smsSet));
            try {
                synchronized (lock) {
                    // marking the message in cache as delivered
                    this.commitSendingPoolMsgCount();
                    ts = warnIfLong(logger, ts, "handleResponse/status=0/in-lock/commitSendingPoolMsgCount");
                    // now we are trying to sent other messages
                    if (this.getTotalUnsentMessageCount() > 0) {
                        try {
                            this.sendDeliverSm(smsSet);
                            ts = warnIfLong(logger, ts, "handleResponse/status=0/in-lock/sendDeliverSm");
                            return;
                        } catch (SmscProcessingException e) {
                            SbbStatsUtils.handleProcessingException(e, getDefaultSbbUsageParameterSet());
                            String s = "SmscProcessingException when sending next sendDeliverSm()=" + e.getMessage() + ", Message=" + sms;
                            logger.severe(s, e);
                            this.onDeliveryError(smsSet, ErrorAction.temporaryFailure, ErrorCode.SC_SYSTEM_ERROR, s, EventType.OUT_SMPP_ERROR, event.getSequenceNumber());
                        }
                    }
                    // no more messages to send - remove smsSet
                    smsSet.setStatus(ErrorCode.SUCCESS);
                    this.markDeliveringIsEnded(true);
                }
            } finally {
                persistence.releaseSynchroObject(lock);
            }
        }
    } else {
        ErrorAction errorAction = ErrorAction.permanentFailure;
        smsSet.setSmppCommandStatus(status);
        if (status == SmppConstants.STATUS_THROTTLED || status == SmppConstants.STATUS_X_T_APPN || status == SmppConstants.STATUS_SYSERR || status == SmppConstants.STATUS_INVBNDSTS || status == SmppConstants.STATUS_MSGQFUL)
            errorAction = ErrorAction.temporaryFailure;
        logger.warning("RxSmppServerSbb.handleResponse(): error code response received: status=" + status + ", errorAction=" + errorAction + ", smsSet=" + smsSet);
        this.onDeliveryError(smsSet, errorAction, ErrorCode.SC_SYSTEM_ERROR, event.getName() + " has a bad status: " + status, EventType.OUT_SMPP_REJECTED, event.getSequenceNumber());
    }
}