docs: @Override
      public int checkStillBlocked()
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "checkStillBlocked");
  
          // For safety, we assume that the destination is blocked (def 244425 and 464463)
          int blockingReason = DestinationHandler.OUTPUT_HANDLER_NOT_FOUND;
  
          if (!_isLink)
          {
              // For non-links we want to process ackExpecteds as normal
              blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
          }
          else
          {
              // If this is a link then we are potentially interested in a number of destinations: the destination
              // currently blocking the link, its exception destination, the link's exception destination and maybe
              // the system exception destination. For example, if no link exception destination is defined and a
              // message could not be delivered on either the target destination or the target's exception destination,
              // then the entire link will be blocked until that message can be delivered or has been deleted at the
              // source end.
              //
              // If a link does have an exception destination defined then there are situations where that exception
              // destination itself may be unable to accept messages and will therefore lead to the link being blocked.
              // If the condition that led to the blocking of the link no longer applies and if no other blocking
              // condition has arisen then we can start sending NACKs to the source as there will be space for what
              // might be returned. If it still cannot accept messages then we are still not able to send NACKs.
  
              // If the link was blocked because the routing destination or the configured exception destinations
              // were full, then check that they now have room
              boolean checkedTarget = false;
              try
              {
                  // Do a general message acceptance test on the link blocking destination and any associated
                  // exception destination if the link is still marked as blocked.
                  blockingReason =
                                  checkTargetAbleToAcceptOrExceptionMessage(_linkBlockingDestination);
  
                  // We've checked the target and have a return code
                  checkedTarget = true;
              } catch (SIMPNotPossibleInCurrentConfigurationException e)
              {
                  // No FFDC code needed
  
                  // There's a problem with the configuration of the target destination - so set checkedTarget to
                  // true, retain the OUTPUT_HANDLER_NOT_FOUND return code and continue processing. If we find that
                  // the link exception destination is also unable to accept the message then we want to report
                  // the target blocking reason rather than the link blocking reason, which may be different.
                  checkedTarget = true;
  
                  // Log the exception
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.exception(tc, e);
              } catch (SIException e)
              {
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.PtoPInputHandler.checkStillBlocked",
                                              "1:3720:1.323",
                                              this);
              }
  
              // If still blocked, then are we able to exploit the link exception destination
              try
              {
                  if (blockingReason != DestinationHandler.OUTPUT_HANDLER_FOUND)
                  {
                      int linkBlockingReason = checkLinkAbleToExceptionMessage();
  
                      // If we can exception the message then reset the blockingReason return code
                      if (linkBlockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
                          blockingReason = DestinationHandler.OUTPUT_HANDLER_FOUND;
                      // If we didn't get a reason code from checking the target or its exception destination
                      // then use the link's.
                      else if (!checkedTarget)
                          blockingReason = linkBlockingReason;
                  }
              } catch (SIException e)
              {
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.PtoPInputHandler.checkStillBlocked",
                                              "1:3745:1.323",
                                              this);
              }
  
              // If the link is no longer blocked, clear out the blocking destination
              if (blockingReason == DestinationHandler.OUTPUT_HANDLER_FOUND)
                  _linkBlockingDestination = null;
          } // eof processing specific to link
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "checkStillBlocked", new Integer(blockingReason));
          return blockingReason;
      }