docs: public void internalCreateDurableSubscription(String subscriptionName,
                                                    String durableSubscriptionHome,
                                                    SIDestinationAddress destinationAddress,
                                                    boolean supportsMultipleConsumers,
                                                    boolean nolocal,
                                                    String alternateUser,
                                                    SelectionCriteria[] criteriaList,
                                                    HashMap userData)
  
                      throws SIConnectionUnavailableException, SIConnectionDroppedException,
                      SIResourceException, SIConnectionLostException, SILimitExceededException,
                      SIErrorException,
                      SINotAuthorizedException,
                      SIIncorrectCallException,
                      SINotPossibleInCurrentConfigurationException,
                      SIDurableSubscriptionAlreadyExistsException
      {
  
          //liberty code change : chetan
          //Since there is no ME-ME communication the durableSubscriptionHome is always the local ME 
          durableSubscriptionHome = _messageProcessor.getMessagingEngineName();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "internalCreateDurableSubscription",
                          new Object[] {
                                        this,
                                        subscriptionName,
                                        durableSubscriptionHome,
                                        destinationAddress,
                                        Boolean.valueOf(supportsMultipleConsumers),
                                        Boolean.valueOf(nolocal),
                                        alternateUser,
                                        criteriaList,
                                        userData });
  
          // Check that the destination information is correct.
          SIBUuid8 durableHomeID =
                          checkDurableSubscriptionInformation(subscriptionName,
                                                              durableSubscriptionHome,
                                                              destinationAddress,
                                                              supportsMultipleConsumers,
                                                              nolocal,
                                                              false,
                                                              false);
  
          //get the destination
          DestinationHandler destination = null;
          try
          {
              destination =
                              _destinationManager.getDestination(
                                                                 (JsDestinationAddress) destinationAddress,
                                                                 false);
          } catch (SITemporaryDestinationNotFoundException e)
          {
              // No FFDC code needed
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "internalCreateDurableSubscription", "SINotPossibleInCurrentConfigurationException");
              throw new SINotPossibleInCurrentConfigurationException(
                              nls.getFormattedMessage(
                                                      "DURABLE_SUBSCRIPTION_USAGE_ERROR_CWSIP0098",
                                                      new Object[] { subscriptionName, destinationAddress.getDestinationName() },
                                                      null));
          }
  
          // Check the destination is a topicSpace
          if (!destination.isPubSub())
          {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "internalCreateDurableSubscription", "Destination not a topicspace");
  
              throw new SINotPossibleInCurrentConfigurationException(
                              nls.getFormattedMessage(
                                                      "DESTINATION_USEAGE_ERROR_CWSIP0141",
                                                      new Object[] { destinationAddress.getDestinationName(),
                                                                    _messageProcessor.getMessagingEngineName(),
                                                                    subscriptionName },
                                                      null));
          }
          else if (destination.isTemporary())
          {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(tc, "internalCreateDurableSubscription", "Destination is Temporary");
  
              throw new SINotPossibleInCurrentConfigurationException(
                              nls.getFormattedMessage(
                                                      "DURABLE_SUBSCRIPTION_USAGE_ERROR_CWSIP0098",
                                                      new Object[] { subscriptionName, destinationAddress.getDestinationName() },
                                                      null));
          }
  
          //The state for this subscription
          ConsumerDispatcherState subState = null;
  
          boolean hasAtLeastOneTopic = false;
  
          SecurityContext secContext = null; //this will be set if security is enabled
  
          if (_isBusSecure)
          {
              // Feature 219101: Add the alternate user string to the security context
              secContext = new SecurityContext(_subject,
                              alternateUser,
                              null,
                              _messageProcessor.getAuthorisationUtils());
  
              // Set the discriminator to null in this check, so that we check access to
              // the destination only. We break out the discriminator check into a 
              // separate loop below so that allowable discriminators can be processed while
              // those that are disallowed will be discarded.                                     
          }
  
          String topicName = null;
          if (criteriaList != null) {
              SelectionCriteria criteria = criteriaList[0];
              if (criteria != null)
                  topicName = criteria.getDiscriminator();
          }
  
          checkDestinationAuthority(destination, MessagingSecurityConstants.OPERATION_TYPE_RECEIVE, topicName);
  
          //Need to check every discriminator if we have an array of multiple criteria
          //We are checking for duplicate criterias (see defect 355556) and if
          //security is enabled we need to check each individual topic too.
          if (criteriaList != null)
          {
              // A string of disallowed discriminators
              String failedDiscriminators = null;
              for (int i = 0; i < (criteriaList.length); i++)
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "examining  selection criteria " + criteriaList[i]);
  
                  boolean topicIsAllowed = true; //we assume the topic is allowed
                  if (_isBusSecure)
                  {
                      //Security is enabled so we need to check if this topic is allowed
                      String discriminator = null;
                      if (criteriaList[i] != null)
                      {
                          discriminator = criteriaList[i].getDiscriminator();
                      }
  
                      //NOTE: we do not check permission for null discriminators
                      if (discriminator != null)
                      {
                          topicIsAllowed =
                                          checkConsumerDiscriminatorAccess(destination,
                                                                           discriminator,
                                                                           secContext);
                      }
  
                      if (!topicIsAllowed)
                      {
                          // Assemble a string of disallowed discriminators for use in logging
                          if (failedDiscriminators == null)
                          {
                              failedDiscriminators = discriminator;
                          }
                          else
                          {
                              failedDiscriminators = failedDiscriminators + ", " + discriminator;
                          }
                      }
  
                  }//end if(_isBusSecure)
  
                  if (topicIsAllowed)
                  {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "adding selection criteria " + criteriaList[i]);
  
                      if (subState == null)
                      {
                          hasAtLeastOneTopic = true;
                          //This is the first selection criteria in the list that we are allowing
                          //so create a new state object representing the subscription and
                          //this allowed selection criteria. 
                          subState =
                                          new ConsumerDispatcherState(
                                                          subscriptionName,
                                                          destination.getUuid(),
                                                          nolocal,
                                                          durableSubscriptionHome,
                                                          destination.getName(),
                                                          destination.getBus(),
                                                          new SelectionCriteria[] { criteriaList[i] },
                                                          userData);
                      }
                      else
                      {
                          //add this new selection criteria to the list - this will
                          //check for duplicates
                          subState.addSelectionCriteria(criteriaList[i]); //NOTE: this will ignore null selection criterias
                                                                          //This might be a bug
                      }
                  }
                  else
                  {
                      // This is a null selection criteria - ignore it
                      // but output a debug
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          SibTr.debug(tc, "null selection criteria");
                  }
              } // eof loop round list of SelectionCriteria
  
              if (_isBusSecure && !hasAtLeastOneTopic)
              {
                  // Thrown if NO discriminator in the set was allowed access
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(
                                 tc,
                                 "internalCreateDurableSubscription",
                                 "SINotAuthorizedException - allowedCritList.isEmpty()");
                  throw new SINotAuthorizedException(
                                  nls.getFormattedMessage(
                                                          "USER_NOT_AUTH_RECEIVE_ERROR_CWSIP0310",
                                                          new Object[] { destination.getName(),
                                                                        failedDiscriminators,
                                                                        secContext.getUserName(false) },
                                                          null));
              }
          }
  
          if (destination.isOrdered() && supportsMultipleConsumers)
          {
              supportsMultipleConsumers = false;
              // Override and warn if ordered destination
              SibTr.warning(tc, "CLONED_SUBSCRIBER_OVERRIDE_CWSIP0028",
                            new Object[] { subscriptionName, destination.getName() });
          }
  
          subState.setIsCloned(supportsMultipleConsumers);
  
          // Set the user into the state for security checks
          // we'll set the alternate user if that is supplied
          if (alternateUser == null)
              subState.setUser(getResolvedUserid(), isSIBServerSubject());
          else
              subState.setUser(alternateUser, false);
  
          // Is durableHome local?
          if (durableHomeID.equals(_messageProcessor.getMessagingEngineUuid()))
              // We're directly attached to the durable home
              destination.createDurableSubscription(subState, null);
          else
              // Durable home is not local so send off the request
              DurableInputHandler.createRemoteDurableSubscription(
                                                                  _messageProcessor,
                                                                  subState,
                                                                  durableHomeID,
                                                                  destination.getUuid());
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "internalCreateDurableSubscription");
      }