docs: @Override
      public void deleteDurableSubscription(String subscriptionName,
                                            String durableSubscriptionHome,
                                            String alternateUser)
  
                      throws SIConnectionUnavailableException, SIConnectionDroppedException,
                      SIResourceException, SIConnectionLostException,
                      SIErrorException,
                      SINotAuthorizedException,
                      SIIncorrectCallException,
                      SIDurableSubscriptionNotFoundException,
                      SIDestinationLockedException
      {
  
          //liberty code change : chetan
          //Since there is no ME-ME communication the durableSubscriptionHome is always the local ME 
          durableSubscriptionHome = _messageProcessor.getMessagingEngineName();
  
          if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
              SibTr.entry(CoreSPIConnection.tc, "deleteDurableSubscription",
                          new Object[] { this, subscriptionName, durableSubscriptionHome, alternateUser });
  
          // Synchronize on the connection object, we don't want the connection closing
          // while we try to delete the subscription.
          synchronized (this)
          {
              SIBUuid8 durableHomeID =
                              checkDurableSubscriptionInformation(subscriptionName,
                                                                  durableSubscriptionHome,
                                                                  null,
                                                                  false,
                                                                  false,
                                                                  true,
                                                                  false);
  
              HashMap durableSubs = _destinationManager.getDurableSubscriptionsTable();
  
              // Is durableHome local?
              if (durableHomeID.equals(_messageProcessor.getMessagingEngineUuid()))
              {
                  // Yes, then there should be an existing consumer dispatcher which we'll
                  // invoke directly
                  synchronized (durableSubs)
                  {
                      //Look up the consumer dispatcher for this subId in the system durable subs list
                      ConsumerDispatcher cd =
                                      (ConsumerDispatcher) durableSubs.get(subscriptionName);
  
                      // Check that the durable subscription existed
                      if (cd == null)
                      {
                          if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
                              SibTr.exit(CoreSPIConnection.tc, "deleteDurableSubscription");
  
                          throw new SIDurableSubscriptionNotFoundException(
                                          nls.getFormattedMessage(
                                                                  "SUBSCRIPTION_DOESNT_EXIST_ERROR_CWSIP0072",
                                                                  new Object[] { subscriptionName,
                                                                                _messageProcessor.getMessagingEngineName() },
                                                                  null));
                      }
  
                      //Obtain the destination from the consumer dispatcher
                      DestinationHandler destination = cd.getDestination();
  
                      // Check that the destination is a TopicSpace
                      if (!destination.isPubSub())
                      {
                          if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
                              SibTr.exit(CoreSPIConnection.tc, "deleteDurableSubscription", "SIDestinationWrongTypeException");
  
                          SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                      new Object[] {
                                                    "com.ibm.ws.sib.processor.impl.ConnectionImpl",
                                                    "1:2759:1.347.1.25" });
  
                          throw new SIErrorException(
                                          nls.getFormattedMessage(
                                                                  "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                                                                  new Object[] { "ConnectionImpl",
                                                                                "1:2765:1.347.1.25" },
                                                                  null));
                      }
  
                      // decalre variables used in security checks
                      AuthUtils sibAuthUtils = _messageProcessor.getAuthorisationUtils();
                      String topicName = null;
                      String topicSpaceName = null;
                      String theUser = null;
  
                      // If security is disabled then we'll bypass the check
                      if (_isBusSecure)
                      {
                          // get the consumer dispatcher state from the consumer dispatcher
                          ConsumerDispatcherState subState = cd.getConsumerDispatcherState();
  
                          topicName = subState.getTopic();
                          topicSpaceName = subState.getTopicSpaceName();
  
                          // Check that the user who is attempting to delete this durable subscription
                          // matches that set in the CD state when the subscription was created           
                          boolean isPriv = false;
                          if (alternateUser == null)
                          {
                              theUser = getResolvedUserid();
                              isPriv = isSIBServerSubject();
                          }
                          else
                          {
                              theUser = alternateUser;
                          }
  
                          boolean userMatch = subState.equalUser(theUser, isPriv);
  
                          // Throw not auth exception if the user who is trying to delete the durable
                          // subscription isn't the same user that created the subscription
                          if (!userMatch)
                          {
                              // ensure that a security audit event takes place for this authorization failure
                              sibAuthUtils.deleteDurSubAuthorizationFailed(theUser, topicName, topicSpaceName, 0L);
  
                              // trace the exception
                              if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
                                  SibTr.exit(CoreSPIConnection.tc, "deleteDurableSubscription", "SINotAuthorizedException");
  
                              // throw the exception
                              throw new SINotAuthorizedException(
                                              nls.getFormattedMessage(
                                                                      "USER_NOT_AUTH_DELETE_ERROR_CWSIP0311",
                                                                      new Object[] { theUser, subscriptionName, destination.getName() },
                                                                      null));
                          }
                      }
  
                      //Call the deleteDurableSubscription method on the destination
                      destination.deleteDurableSubscription(subscriptionName, durableSubscriptionHome);
  
                      if (_isBusSecure)
                      {
                          // ensure that a security audit event takes place for this successful dur sub delete
                          sibAuthUtils.deleteDurSubAuthorizationPassed(theUser, topicName, topicSpaceName, 0L);
                      }
                  }
              }
              else
              {
                  // No, issue a remote request
                  DurableInputHandler.deleteRemoteDurableSub(_messageProcessor,
                                                             subscriptionName,
                                                             getResolvedUserid(),
                                                             durableHomeID);
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && CoreSPIConnection.tc.isEntryEnabled())
              SibTr.exit(CoreSPIConnection.tc, "deleteDurableSubscription");
  
      }