docs: private static void sendConnMsg(CommsServerByteBuffer request, Conversation conversation,
                                      int requestNumber, boolean partOfExchange,
                                      boolean allocatedFromBufferPool, boolean sendReply,
                                      boolean optimizedTx)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "sendConnMsg",
                          new Object[]
                          {
                           request,
                           conversation,
                           "" + requestNumber,
                           "" + partOfExchange,
                           "" + allocatedFromBufferPool,
                           "" + sendReply,
                           "" + optimizedTx
                          });
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          {
              if (sendReply)
                  SibTr.debug(tc, "The client will be informed of the outcome");
              else
                  SibTr.debug(tc, "The client will NOT be informed of the outcome");
          }
  
          ConversationState convState = (ConversationState) conversation.getAttachment();
          ServerLinkLevelState linkState = (ServerLinkLevelState) conversation.getLinkLevelAttachment();
  
          short connectionObjectId = request.getShort(); // BIT16 ConnectionObjectId
          short orderId = request.getShort(); // BIT16 MessageOrderContextId
          int transactionId = request.getSITransactionId(connectionObjectId, linkState, optimizedTx);
          short destinationTypeShort = request.getShort(); // BIT16 DestinationType
          String alternateUser = request.getString();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          {
              SibTr.debug(tc, "connectionObjectId", connectionObjectId);
              SibTr.debug(tc, "orderId", orderId);
              SibTr.debug(tc, "transactionId", transactionId);
              SibTr.debug(tc, "destinationType", destinationTypeShort);
              SibTr.debug(tc, "alternateUser", alternateUser);
          }
  
          SICoreConnection connection =
                          ((CATConnection) convState.getObject(connectionObjectId)).getSICoreConnection();
  
          /**************************************************************/
          /* Destination type */
          /**************************************************************/
          DestinationType destType = null;
          if (destinationTypeShort != CommsConstants.NO_DEST_TYPE)
          {
              destType = DestinationType.getDestinationType(destinationTypeShort);
          }
  
          try
          {
              /**************************************************************/
              /* Destination address */
              /**************************************************************/
              SIDestinationAddress destAddress = request.getSIDestinationAddress(conversation.getHandshakeProperties().getFapLevel());
  
              int messageLength = (int) request.peekLong();
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, "Message length", "" + messageLength);
  
              // Get the transaction
              SITransaction siTran = null;
              siTran = linkState.getTransactionTable().get(transactionId);
  
              OrderingContext siOrder = null;
              if (orderId != CommsConstants.NO_ORDER_CONTEXT)
              {
                  siOrder = ((CATOrderingContext) convState.getObject(orderId)).getOrderingContext();
              }
  
              try
              {
                  SIBusMessage sibMessage = request.getMessage(null);
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  {
                      SibTr.debug(tc, "Sending client message - " + sibMessage);
                      SibTr.debug(tc, "Destination: " + destAddress);
                      SibTr.debug(tc, "Discriminator: " + sibMessage.getDiscriminator());
                      SibTr.debug(tc, "Reliability: " + sibMessage.getReliability());
                  }
  
                  if (siTran != IdToTransactionTable.INVALID_TRANSACTION)
                  {
                      connection.send(sibMessage, siTran, destAddress, destType, siOrder, alternateUser);
                  }
  
                  if (sendReply)
                  {
                      try
                      {
                          conversation.send(poolManager.allocate(),
                                            JFapChannelConstants.SEG_SEND_CONN_MSG_R,
                                            requestNumber,
                                            JFapChannelConstants.PRIORITY_MEDIUM,
                                            true,
                                            ThrottlingPolicy.BLOCK_THREAD,
                                            null);
                      } catch (SIException e)
                      {
                          FFDCFilter.processException(e,
                                                      CLASS_NAME + ".sendConnMsg",
                                                      CommsConstants.STATICCATPRODUCER_CONNSEND_01);
  
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(tc, e.getMessage(), e);
  
                          SibTr.error(tc, "COMMUNICATION_ERROR_SICO2024", e);
                      }
                  }
              } catch (Exception e)
              {
                  // No FFDC code needed
                  // (actually we FFDC later on - but we need that line to fool the FFDC tool :-)
  
                  // If we are sending replies, rethrow the exception so
                  // that the specific exeption handlers will deal with it
                  // and send the response to the client
                  if (sendReply)
                      throw e;
  
                  // Otherwise, mark this transaction as error
                  if (transactionId != CommsConstants.NO_TRANSACTION)
                  {
                      linkState.getTransactionTable().markAsRollbackOnly(transactionId, e);
                  }
  
                  //No FFDC code needed
                  //Only FFDC if we haven't received a meTerminated event OR if this Exception isn't a SIException.
                  if (!(e instanceof SIException) || !convState.hasMETerminated())
                  {
                      FFDCFilter.processException(e,
                                                  CLASS_NAME + ".sendConnMsg",
                                                  CommsConstants.STATICCATPRODUCER_CONNSEND_02);
                  }
  
                  SibTr.error(tc, SibTr.Suppressor.ALL_FOR_A_WHILE_SIMILAR_INSERTS,
                              "UNABLE_TO_SEND_MESSAGE_SICO2009", e);
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "Failed to send a message", e);
              }
          } 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 - processor will have already FFDC'ed any interesting ones....
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATPRODUCER_CONNSEND_03,
                                                    conversation, requestNumber);
          } catch (Exception e)
          {
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".sendConnMsg",
                                          CommsConstants.STATICCATPRODUCER_CONNSEND_04);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATPRODUCER_CONNSEND_04,
                                                    conversation, requestNumber);
  
          }
  
          request.release(allocatedFromBufferPool);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "sendConnMsg");
      }