docs: public static void rcvCreateConsumerForDurableSub(CommsByteBuffer request, Conversation conversation,
                                                       int requestNumber,
                                                       boolean allocatedFromBufferPool,
                                                       boolean partOfExchange)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvCreateConsumerForDurableSub",
                                             new Object[]
                                             {
                                                request,
                                                conversation,
                                                ""+requestNumber,
                                                ""+allocatedFromBufferPool
                                              });
  
        ConversationState convState = (ConversationState) conversation.getAttachment();
  
        short connectionObjectID = request.getShort();  // BIT16 ConnectionObjectId
        short clientSessionId = request.getShort();     // BIT16 ClientSessionId
        short consumerFlags = request.getShort();       // BIT16 Consumer Flags
        short reliabilityShort = request.getShort();    // BIT16 Relibility
        int requestedBytes = request.getInt();          // BIT32 Requested bytes
        short unrecovShort = request.getShort();        // BIT16 UnrecoverableReliability
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
           SibTr.debug(tc, "ConnectionObjectId:", connectionObjectID);
           SibTr.debug(tc, "ClientSessionId:", clientSessionId);
           SibTr.debug(tc, "ConsumerFlags:", consumerFlags);
           SibTr.debug(tc, "Reliability:", reliabilityShort);
           SibTr.debug(tc, "RequestedBytes:", requestedBytes);
           SibTr.debug(tc, "UnrecovReliability", unrecovShort);
        }
  
        try
        {
           /**************************************************************/
           /* Reliability                                                */
           /**************************************************************/
           Reliability reliability = null;
           if (reliabilityShort != -1)
           {
              reliability = Reliability.getReliability(reliabilityShort);
           }
  
           /**************************************************************/
           /* Consumer flags                                             */
           /**************************************************************/
  
           final short validFlags = 0x0007|CommsConstants.CF_BIFURCATABLE;
           if ((consumerFlags|validFlags) != validFlags) {
             if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Consumer flags ("+consumerFlags+") not valid, valid flags ="+validFlags);
             SIErrorException e = new SIErrorException(nls.getFormattedMessage("INVALID_PROP_SICO8014", new Object[] {""+consumerFlags }, null));
             FFDCFilter.processException(e, CLASS_NAME + ".rcvCreateConsumerForDurableSub",CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_05);
           }
  
           boolean readAheadPermitted       = (consumerFlags & 0x01) != 0;
           boolean noLocal                  = (consumerFlags & 0x02) != 0;
           boolean supportMultipleConsumers = (consumerFlags & 0x04) != 0;
           boolean bifurcatable             = (consumerFlags & CommsConstants.CF_BIFURCATABLE) != 0;
  
           /**************************************************************/
           /* Unrecoverable Reliability                                  */
           /**************************************************************/
           Reliability unrecoverableReliability = null;
           if (unrecovShort != -1)
           {
              unrecoverableReliability = Reliability.getReliability(unrecovShort);
           }
  
           /**************************************************************/
           /* Destination Info                                           */
           /**************************************************************/
           SIDestinationAddress destAddress = request.getSIDestinationAddress(conversation.getHandshakeProperties().getFapLevel());
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Destination Address", destAddress);
  
           /**************************************************************/
           /* Subscription Name                                          */
           /**************************************************************/
           String subscriptionName = request.getString();
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Subscription Name:", subscriptionName);
  
           /**************************************************************/
           /* Subscription Home                                          */
           /**************************************************************/
           String subscriptionHome = request.getString();
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Subscription Home:", subscriptionHome);
  
           /**************************************************************/
           /* SelectionCriteria                                          */
           /**************************************************************/
           SelectionCriteria criteria = request.getSelectionCriteria();
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Selection Criteria", criteria);
  
           /**************************************************************/
           /* Alternative user                                           */
           /**************************************************************/
           String alternateUser = request.getString();
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Alternate User Id: ", alternateUser);
  
           SICoreConnection connection =
              ((CATConnection) convState.getObject(connectionObjectID)).getSICoreConnection();
  
  
           try
           {
              ConsumerSession session =
                 connection.createConsumerSessionForDurableSubscription(subscriptionName,
                                                                        subscriptionHome,
                                                                        destAddress,
                                                                        criteria,
                                                                        supportMultipleConsumers,
                                                                        noLocal,
                                                                        reliability,
                                                                        readAheadPermitted,
                                                                        unrecoverableReliability,
                                                                        bifurcatable,
                                                                        alternateUser);
  
              CATMainConsumer mainConsumer = new CATMainConsumer(conversation,
                                                                 clientSessionId,
                                                                 session,
                                                                 readAheadPermitted,
                                                                 noLocal,
                                                                 unrecoverableReliability);
  
              short durableSubscriberObjectID = (short) convState.addObject(mainConsumer);
  
              mainConsumer.setConsumerSessionId(durableSubscriberObjectID);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                 SibTr.debug(tc, "Durable Subscription Id:", durableSubscriberObjectID);
  
              // Send the response to the client
              StaticCATHelper.sendSessionCreateResponse(JFapChannelConstants.SEG_CREATE_CONS_FOR_DURABLE_SUB_R,
                                                        requestNumber,
                                                        conversation,
                                                        durableSubscriberObjectID,
                                                        session,
                                                        destAddress);
  
              if (readAheadPermitted)
              {
                 try
                 {
                    mainConsumer.setRequestedBytes(requestedBytes);
                    mainConsumer.setAsynchConsumerCallback(requestNumber,
                                                           0,
                                                           0,
                                                           1,
                                                           null);
                    mainConsumer.start(requestNumber, false, false, null);
                 }
                 catch (RuntimeException e)
                 {
                    // If we get a runtime exception here then our setAsync or start
                    // calls have failed.
                    FFDCFilter.processException(e,
                                                CLASS_NAME + ".rcvCreateConsumerForDurableSub",
                                                CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_01);
  
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    {
                       SibTr.debug(tc, "Unable to create readahead async consumer");
                       SibTr.exception(tc, (Exception) e.getCause());
                    }
  
                    // Now throw a SICoreException to inform the client
                    throw new SIResourceException(e.getMessage());
                 }
              }
           }
           catch (SIDurableSubscriptionNotFoundException e)
           {
              // No FFDC Code Needed
              // We don't want to FFDC here as JMS will cause this exception to happen in the routine
              // creation of a durable subscription. This is not a serious or internal error anyway.
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e, null, conversation, requestNumber);
           }
           catch (SINotAuthorizedException e)
           {
              // No FFDC Code Needed
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    null,
                                                    conversation, requestNumber);
           }
           catch (SIException e)
           {
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if(!convState.hasMETerminated())
              {
                 FFDCFilter.processException(e,
                                             CLASS_NAME + ".rcvCreateConsumerForDurableSub",
                                             CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_02);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                 SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_02,
                                                    conversation, requestNumber);
           }
           catch (ConversationStateFullException e)
           {
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".rcvCreateConsumerForDurableSub",
                                          CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_03);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_03,
                                                    conversation, requestNumber);
  
           }
        }
        catch (Exception e)
        {
           FFDCFilter.processException(e,
                                       CLASS_NAME + ".rcvCreateConsumerForDurableSub",
                                       CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_04);
  
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);
  
           StaticCATHelper.sendExceptionToClient(e,
                                                 CommsConstants.STATICCATSUBSCRIPTION_CREATECONS_04,
                                                 conversation, requestNumber);
  
        }
  
        request.release(allocatedFromBufferPool);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "rcvCreateConsumerForDurableSub");
     }