docs: private Message receiveInboundMessage(boolean waiting, long timeout) throws JMSException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "receiveInboundMessage", new Object[] { waiting, timeout });
          Message msg = null;
          String bus = null;
          String destName = null;
          SIBusMessage coreMsg = null;
  
          SITransaction st = session.getTransaction();
  
          // 304501.api Check for XD pacing
          MessagePacingControl mpc = MessagePacingControlFactory.getInstance();
          if (mpc != null && mpc.isActive()) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "about to call preSynchReceive");
              Object context = coreConsumerSession;
              bus = coreConsumerSession.getDestinationAddress().getBusName();
              if (bus == null)
                  bus = defaultBusName; // Default to the value from the connection factory
              destName = coreConsumerSession.getDestinationAddress().getDestinationName();
              if (waiting) {
                  timeout = mpc.preSynchReceive(bus, destName, context, timeout);
              }
              else {
                  mpc.preSynchReceive(bus, destName, context, -1);
              }
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "preSynchReceive complete");
          }
  
          try {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  SibTr.debug(this, tc, "About to call receive method; transaction: " + st + (waiting ? " timeout: " + timeout : ""));
                  // Put a big warning in if they have called receive without starting
                  // the connection.
                  // This won't cause a problem if the connection is started before the timeout
                  // elapses, but in 90% of cases is caused by a rookie programming error because
                  // they have forgotton to start the application at all - then they wonder why
                  // no messages are received. (Note that you can still send messages - just not
                  // receive them).
                  if (session.getState() != STARTED) {
                      SibTr.debug(this, tc, "WARNING - APPLICATION CALLED RECEIVE BUT CONNECTION IS NOT STARTED");
                  }
              }
  
              // We now branch depending on which of the two core receive
              // calls we are interested in.
              if (waiting) {
                  // This is a get with timeout, or infinite wait
                  coreMsg = coreConsumerSession.receiveWithWait(st, timeout);
  
                  // d248044 Provide a warning if receive(wait) returns null on a stopped connection
                  if (coreMsg == null && session.getState() != STARTED) {
                      // Find the stack entry of the caller of the receive method.
                      // d386440 - in some cases it seems that the first line of the stack can
                      //   be for the Throwable constructor, which throws off the fixed-offset
                      //   approach, and means we quote a line reference the JmsMsgConsumerImpl
                      //   class. This approach checks when we leave the JMS package.
                      String caller = JmsErrorUtils.getFirstApplicationStackString();
                      SibTr.warning(tc, "MC_CONN_STOPPED_CWSIA0087", caller);
                  }
              }
              else {
                  // This is a get with no wait.
                  coreMsg = coreConsumerSession.receiveNoWait(st);
  
              }
  
              // Convert the core message to a JMS version - pass the session's 'pass thru props' so certain
              // properties will be associated with the message (SIB0121)
              msg = JmsInternalsFactory.getSharedUtils().inboundMessagePath(coreMsg, session, session.getPassThruProps());
  
              if (msg != null) {
                  if (((JmsMessageImpl) msg).getMsgReference().getJmsDestination() == null) {
                      // The received message did not come from JMS (or had the JmsDestination field
                      // deliberately excluded).
                      JmsDestinationImpl dest = (JmsDestinationImpl) props.getJmsDestination();
                      if (!dest._getInhibitJMSDestination()) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "This message was not sent by a JMS client, and so has no JmsDestination field set. Setting it to: "
                                                    + props.getJmsDestination().getDestName());
                          msg.setJMSDestination(dest);
                      }
                  }
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "sessionAckMode : " + sessionAckMode);
  
              // This handles the commit of transaction for dups ok, and keeping a
              // tally of the number uncommitted messages received.
              // Optimise to call only if transaction is non-null, because we know
              // that it does nothing if it is null.
              if ((msg != null) && (st != null)) {
                  session.notifyMessageConsumed(st);
              }
          } catch (SISessionUnavailableException oce) {
              // No FFDC code needed
              // This is normal if blocking receive is interrupted by close().
              // Trace and discard, will return null from this method.
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "caught SISessionUnavailableException: " + oce);
              // We do need to ensure this consumer is marked as closed, as we
              // may also enter this block if the ME becomes unavailable (but the
              // server stays active). PK53368
              close();
  
              // There is one known case where an SISessionUnavailableException
              // exception is thrown for a reason that we do need to report
              // to the user. This is when the receiver is created against a
              // destination that is stricly ordered, and there is an indoubt
              // transaction on that destination that prevents the consumer
              // from consuming messages.
              // The only way we have to test for this special case is using
              // the NLS message identifier
              String exceptionMsg = oce.getMessage();
              if (exceptionMsg != null &&
                  (exceptionMsg.contains("CWSIP0180E") ||
                  exceptionMsg.contains("CWSIP0194E"))) {
                  throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class,
                                                                  "INBOUND_MSG_ERROR_CWSIA0103",
                                                                  new Object[] { oce },
                                                                  oce,
                                                                  null, // null probeId = no FFDC
                                                                  this,
                                                                  tc);
              }
          } catch (SIException sice) {
              // No FFDC code needed
  
              // d238447 FFDC Review. Need to group the following into those requiring FFDC and those that don't:
              // Not much doc' available, I suspect that all of these are either external/app errors and/or
              // will already have been FFDCd. Don't generate FFDC here.
              //        SISessionUnavailableException, SISessionDroppedException,
              //        SIConnectionUnavailableException, SIConnectionDroppedException,
              //        SIResourceException, SIConnectionLostException, SILimitExceededException,
              //        SINotAuthorizedException,
              //        SIIncorrectCallException - thrown when in use for async delivery
              throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class,
                                                              "INBOUND_MSG_ERROR_CWSIA0103",
                                                              new Object[] { sice },
                                                              sice,
                                                              null, // null probeId = no FFDC
                                                              this,
                                                              tc);
          }
          // 304501.api XD pacing
          if (mpc != null && mpc.isActive()) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "about to call postSynchReceive");
              Object context = coreConsumerSession;
              boolean msgReceived = msg != null;
              mpc.postSynchReceive(bus, destName, context, msgReceived);
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "postSynchReceive complete");
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "receiveInboundMessage", msg);
          return msg;
      }