docs: static public void setPropertiesInSMC(SessionManagerConfig smc, Map<String, Object> xtpProperties) {
          final String methodName = "setPropertiesInSMC";
          final String invalidPropFoundMessage = "SessionContext.invalidPropertyFound";
          final String invalidCloneSeparatorMessage = "SessionContext.invalidCloneSeparator";
          String strProp = null;
          Boolean booleanProp;
          Integer integerProp = null;
  
          boolean baseServerLevelConfig = smc.isUsingWebContainerSM();
  
          setDefaultConfiguration(smc, xtpProperties);
  
          // id length - has upper case D for system property...maintain for
          // compatibility
          final String propIdLengthForSys = "HttpSessionIDLength";
          final String propIdLength = "idLength";
          int idLength = -1;
  
          Object propIdLengthValue = xtpProperties.get(propIdLength);
          if (propIdLengthValue instanceof Integer) {
              integerProp = (Integer) propIdLengthValue;
          } else {
              strProp = (String) propIdLengthValue;
              if (strProp == null) {
                  strProp = getSystemProperty(propIdLength);
                  // look for different case on system property
                  if (strProp == null) {
                      strProp = getSystemProperty(propIdLengthForSys);
                  }
              }
          }
  
          if (integerProp != null || strProp != null) {
              try {
                  if (integerProp != null) {
                      idLength = integerProp.intValue();
                  } else {
                      idLength = Integer.parseInt(strProp);
                  }
                  if ((idLength < 8) || (idLength > 128)) {
                      if (idLength < 8)
                          idLength = 8;
                      if (idLength > 128)
                          idLength = 128;
                      LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, "SessionContext.valueOutOfRange", new Object[] { propIdLength, strProp,
                                                                                                                                                       new Integer(idLength) });
                  }
                  if (shouldSetAndDoLogging(propIdLength, true, baseServerLevelConfig, xtpProperties, new Integer(idLength), new Integer(SessionManagerConfig.getSessionIDLength()),
                                            false)) {
                      SessionManagerConfig.setSessionIDLength(idLength);
                  }
              } catch (NumberFormatException nfe) {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propIdLength, strProp });
              }
          }
  
          // id reuse - reuse incoming id even if its not in use by another webapp
          final String propIdReuse = "HttpSessionIdReuse";
          strProp = getStringProperty(propIdReuse, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propIdReuse, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isIdReuse()), false)) {
                  SessionManagerConfig.setIdReuse(booleanProp.booleanValue());
              }
          }
  
          // track gc
          final String propTrackGC = "HttpSessionTrackGC";
          strProp = getStringProperty(propTrackGC, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propTrackGC, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setTrackGCCount(booleanProp.booleanValue());
              }
          }
  
          // reaper poll interval - override how often inval thread runs
          final String propReaperPollInt = "HttpSessionReaperPollInterval";
          strProp = getStringProperty(propReaperPollInt, xtpProperties);
          long longProp = -1;
          try {
              if (strProp != null) {
                  if (shouldSetAndDoLogging(propReaperPollInt, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                      longProp = new Long(strProp).longValue();
                      smc.setReaperPollInterval(longProp);
                  }
              }
          } catch (NumberFormatException nfe) {
              LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propReaperPollInt, strProp });
          }
  
          // use invalidated id - default to true for better performance
          final String propUseRecentInvalId = "UseInvalidatedId";
          strProp = getStringProperty(propUseRecentInvalId, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propUseRecentInvalId, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setCheckRecentlyInvalidList(booleanProp.booleanValue());
              }
          }
  
          // debug session crossover
          final String propDebugSessCross = "DebugSessionCrossover";
          strProp = getStringProperty(propDebugSessCross, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propDebugSessCross, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setDebugSessionCrossover(booleanProp.booleanValue());
                  if (baseServerLevelConfig || xtpProperties.get(propDebugSessCross) != null) {
                      if (booleanProp.booleanValue() == true) {
                          LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, methodName, "SessionContext.DebugCrossoverEnabled");
                      }
                  }
              }
          }
  
          // url rewrite identifier
          final String propSessRewrite = "SessionRewriteIdentifier";
          strProp = getStringProperty(propSessRewrite, xtpProperties);
          if (strProp != null) {
              if (shouldSetAndDoLogging(propSessRewrite, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                  smc.setSessUrlRewritePrefix(";" + strProp + "=");
              }
          }
  
          // clone id
          final String propHttpSessionCloneId = "HttpSessionCloneId";
          strProp = getStringProperty(propHttpSessionCloneId, xtpProperties);
          if (strProp != null) {
              if (shouldSetAndDoLogging(propHttpSessionCloneId, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getCloneId(),
                                        strProp.equals(SessionManagerConfig.getCloneId()))) {
                  SessionManagerConfig.setCloneId(strProp);
                  SessionManagerConfig.setCloneIdPropertySet(true);
              }
          }
  
          // no additional session info - eliminates cache and clone on base server
          final String propNoAddSessInfo = "NoAdditionalSessionInfo";
          strProp = getStringProperty(propNoAddSessInfo, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propNoAddSessInfo, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isTurnOffCacheId()), false)) {
                  SessionManagerConfig.setTurnOffCacheId(booleanProp.booleanValue());
                  SessionManagerConfig.setTurnOffCloneId(booleanProp.booleanValue());
                  if (smc.isUsingMemory()) {
                      SessionManagerConfig.setCacheIdLength(0);
                  }
              }
          }
  
          // session id max length (including all clones)
          final String propSessIdMax = "SessionIdentifierMaxLength";
          strProp = getStringProperty(propSessIdMax, xtpProperties);
          if (strProp != null) {
              try {
                  int maxLength = Integer.parseInt(strProp);
                  if (shouldSetAndDoLogging(propSessIdMax, true, baseServerLevelConfig, xtpProperties, new Integer(maxLength),
                                            new Integer(SessionManagerConfig.getMaxSessionIdentifierLength()), false)) {
                      SessionManagerConfig.setMaxSessionIdentifierLength(maxLength);
                  }
              } catch (NumberFormatException nfe) {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propSessIdMax, strProp });
              }
          }
  
          // clone separator change
          final String propCloneSepChange = "CloneSeparatorChange";
          strProp = getStringProperty(propCloneSepChange, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propCloneSepChange, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                        Boolean.valueOf('+' == SessionManagerConfig.getCloneSeparator()),
                                        false)) {
                  if (booleanProp.booleanValue()) {
                      SessionManagerConfig.setCloneSeparator('+');
                  }
              }
          }
  
          // PM02068 Property for changing CloneSeparator.  
          final String propCloneSeparator = "CloneSeparator";
          strProp = getStringProperty(propCloneSeparator, xtpProperties);
          if (strProp != null) {
              // Must be exactly one char, and cannot be space
              if ((strProp.length() == 1) && (strProp.trim().length() == 1)) {
                  if (shouldSetAndDoLogging(propCloneSeparator, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                      char charProp = strProp.charAt(0);
                      SessionManagerConfig.setCloneSeparator(charProp);
                  }
              } else {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidCloneSeparatorMessage,
                                                       new Object[] { strProp });
              }
          }
  
          // no affinity switch back - stick to new server after failover
          final String propNoAffSwitch = "NoAffinitySwitchBack";
          strProp = getStringProperty(propNoAffSwitch, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propNoAffSwitch, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isNoAffinitySwitchBack()),
                                        false)) {
                  SessionManagerConfig.setNoAffinitySwitchBack(booleanProp.booleanValue());
              }
          }
  
          // use oracle BLOB, rather than long raw, for medium db column
          final String propUseOracleBlob = "UseOracleBLOB";
          strProp = getStringProperty(propUseOracleBlob, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propUseOracleBlob, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setUseOracleBlob(booleanProp.booleanValue());
              }
          }
  
          // START: PM37139 Users who set this property to true should have already created their own index, so we skip index creation
          final String propSessionTableSkipIndexCreation = "SessionTableSkipIndexCreation";
          strProp = getStringProperty(propSessionTableSkipIndexCreation, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propSessionTableSkipIndexCreation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setSessionTableSkipIndexCreation(booleanProp.booleanValue());
              }
          }
          // END: PM37139
  
          // START: PM57590
          final String propCheckSessionNewOnIsValidRequest = "CheckSessionNewOnIsValidRequest";
          strProp = getStringProperty(propCheckSessionNewOnIsValidRequest, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propCheckSessionNewOnIsValidRequest, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setCheckSessionNewOnIsValidRequest(booleanProp.booleanValue());
              }
          }
          // END: PM57590     
  
          // if the data source has a non default schema name, then we need to mark it as so
          final String propUsingCurrentSchemaCustomProperty = "UsingCustomSchemaName";
          strProp = getStringProperty(propUsingCurrentSchemaCustomProperty, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propUsingCurrentSchemaCustomProperty, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setUsingCustomSchemaName(booleanProp.booleanValue());
              }
          }
  
          // hide session values (in trace output)
          final String propHideSessVals = "HideSessionValues";
          strProp = getStringProperty(propHideSessVals, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propHideSessVals, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isHideSessionValues()), false)) {
                  SessionManagerConfig.setHideSessionValues(booleanProp.booleanValue());
                  SessionManagerConfig.setHideSessionValuesPropertySet(true);
              }
          }
  
          // do remote invalidations - forces inval even if scheduled session inval
          // (twice a day) is enabled
          final String propDoRemoteInval = "DoRemoteInvalidations";
          strProp = getStringProperty(propDoRemoteInval, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propDoRemoteInval, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isDoRemoteInvalidations()),
                                        false)) {
                  SessionManagerConfig.setDoRemoteInvalidations(booleanProp.booleanValue());
              }
          }
          // session table name
          final String propSessTable = "SessionTableName";
          strProp = getStringProperty(propSessTable, xtpProperties);
          if (strProp != null) {
              if (shouldSetAndDoLogging(propSessTable, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                  smc.setTableNameValue(strProp);
              }
          }
  
          // zOS Base Server Replication
          final String propZosBaseServerReplication = "HttpSessionEnableUnmanagedServerReplication";
          strProp = getStringProperty(propZosBaseServerReplication, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propZosBaseServerReplication, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setZosBaseServerReplicationEnabled(booleanProp.booleanValue());
              }
          }
  
          // servlet 21 compatibility -- aka global sessions
          final String propServlet21SessionCompat = "Servlet21SessionCompatibility";
          strProp = getStringProperty(propServlet21SessionCompat, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propServlet21SessionCompat, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                        Boolean.valueOf(SessionManagerConfig.getServlet21SessionCompatibility()), false)) {
                  SessionManagerConfig.setServlet21SessionCompatibility(booleanProp.booleanValue());
              }
          }
  
          // always encode the url even if cookies enabled is set
          final String propAlwaysEncode = "AlwaysEncodeURL";
          strProp = getStringProperty(propAlwaysEncode, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propAlwaysEncode, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isAlwaysEncodeURL()), false)) {
                  SessionManagerConfig.setAlwaysEncodeURL(booleanProp.booleanValue());
              }
          }
          
          // START: PM81933 Check session cookie name on EncodeURL method
          final String propCheckSessionCookieNameOnEncodeURL = "CheckSessionCookieNameOnEncodeURL";
          strProp = getStringProperty(propCheckSessionCookieNameOnEncodeURL, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propCheckSessionCookieNameOnEncodeURL, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.checkSessionCookieNameOnEncodeURL()), false)) {
                  SessionManagerConfig.setCheckSessionCookieNameOnEncodeURL(booleanProp.booleanValue());
              }
          }
          // END: PM81933        
  
          // Optimizes the Version Increments if the in-memory session is the same as
          // the one stored on the backend. This property only applies to non-EOS
          // writes since we will always do this for EOS.
          final String propOptimizeCacheIdIncrements = "OptimizeCacheIdIncrements";
          strProp = getStringProperty(propOptimizeCacheIdIncrements, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propOptimizeCacheIdIncrements, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setOptimizeCacheIdIncrements(booleanProp.booleanValue());
              }
          }
  
          // only checks the cache vs the backend for updating the lastAccessedTime
          // during the preInvoke metho
          final String propOnlyCheckInCacheDuringPreInvoke = "OnlyCheckInCacheDuringPreInvoke";
          strProp = getStringProperty(propOnlyCheckInCacheDuringPreInvoke, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propOnlyCheckInCacheDuringPreInvoke, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setOnlyCheckInCacheDuringPreInvoke(booleanProp.booleanValue());
              }
          }
  
          // can be used to disable hot failover by setting to false - default is true
          final String propEnableHotFailover = "EnableHotFailover";
          strProp = getStringProperty(propEnableHotFailover, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propEnableHotFailover, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isEnableHotFailover()),
                                        false)) {
                  SessionManagerConfig.setEnableHotFailover(booleanProp.booleanValue());
              }
          }
  
          // PK38538 Begin
          final String propForceSessionInvalidationMultiple = "ForceSessionInvalidationMultiple";
          strProp = getStringProperty(propForceSessionInvalidationMultiple, xtpProperties);
          if (strProp != null) {
              try {
                  int invalMult = new Integer(strProp).intValue();
                  if (shouldSetAndDoLogging(propForceSessionInvalidationMultiple, false, baseServerLevelConfig, xtpProperties, new Integer(invalMult), null, false)) {
                      smc.setForceSessionInvalidationMultiple(invalMult);
                  }
              } catch (NumberFormatException nfe) {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propForceSessionInvalidationMultiple,
                                                                                                                                          strProp });
              }
          } // PK38538 End
          
          //PI73188 Start
          final String propModifyActiveCountOnInvalidatedSession = "ModifyActiveCountOnInvalidatedSession";
          strProp = getStringProperty(propModifyActiveCountOnInvalidatedSession, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propModifyActiveCountOnInvalidatedSession, true, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setModifyActiveCountOnInvalidatedSession(booleanProp.booleanValue());
              }
          }
          //PI73188 End
          
          
          final String propPersistSessionAfterPassivation = "PersistSessionAfterPassivation";
          strProp = getStringProperty(propPersistSessionAfterPassivation, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propPersistSessionAfterPassivation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setPersistSessionAfterPassivation(booleanProp.booleanValue());
              }
          }
  
          final String propUsingApplicationSessionsAndInvalidateAll = "UsingApplicationSessionsAndInvalidateAll";
          strProp = getStringProperty(propUsingApplicationSessionsAndInvalidateAll, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propUsingApplicationSessionsAndInvalidateAll, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                        Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAndInvalidateAll()), false)) {
                  SessionManagerConfig.setUsingApplicationSessionsAndInvalidateAll(booleanProp.booleanValue());
              }
          }
  
          final String propUsingApplicationSessionsAlwaysRetrieve = "UsingApplicationSessionsAlwaysRetrieve";
          strProp = getStringProperty(propUsingApplicationSessionsAlwaysRetrieve, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propUsingApplicationSessionsAlwaysRetrieve, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                        Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAlwaysRetrieve()), false)) {
                  SessionManagerConfig.setUsingApplicationSessionsAlwaysRetrieve(booleanProp.booleanValue());
              }
          }
  
          // clone id
          final String propSIPCookieName = "SIPCookieName";
          strProp = getStringProperty(propSIPCookieName, xtpProperties);
          if (strProp != null) {
              if (shouldSetAndDoLogging(propSIPCookieName, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getSipSessionCookieName(),
                                        strProp.equals(SessionManagerConfig.getSipSessionCookieName()))) {
                  SessionManagerConfig.setSipSessionCookieName(strProp);
              }
          }
          
          //Property that allows the thread scheduler to be changed
          final String newScheduler= "UseSeparateSessionInvalidatorThreadPool";
          strProp = getStringProperty(newScheduler, xtpProperties);
          if(strProp != null){
              booleanProp=Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(newScheduler, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setUseSeparateSessionInvalidatorThreadPool(booleanProp.booleanValue());
              }
          }        
  
          //PM74718 Property to control how long to delay the start of the invalidation alarm.
          final String invalidatorAlarmDelay = "DelayInvalidationAlarmDuringServerStartup";
          strProp = getStringProperty(invalidatorAlarmDelay, xtpProperties);
          if (strProp != null) {
              try {
                  Integer delayProp = Integer.valueOf(strProp);
                  if (shouldSetAndDoLogging(invalidatorAlarmDelay, false, baseServerLevelConfig, xtpProperties, delayProp, null, false)) {
                      smc.setDelayForInvalidationAlarmDuringServerStartup(delayProp.intValue());
                  }
              } catch (NumberFormatException nfe) {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage,new Object[] {invalidatorAlarmDelay, strProp});
              }
          }
  
          // PK80439 Property for preventing session ids longer than the permissible length getting created
          final String propForceSessionIdLengthCheck = "ForceSessionIdLengthCheck";
          strProp = getStringProperty(propForceSessionIdLengthCheck, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(propForceSessionIdLengthCheck, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setForceSessionIdLengthCheck(booleanProp.booleanValue());
              }
          }
          // PK80439 End
  
          // PM04304 Property for ignoring case while comparing session owner and authorized user
          final String securityUserIgnoreCase = "SecurityUserIgnoreCase";
          strProp = getStringProperty(securityUserIgnoreCase, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(securityUserIgnoreCase, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setSecurityUserIgnoreCase(booleanProp.booleanValue());
              }
          }
  
          //712446
          final String throwSecurityExceptionOnGetSessionFalse = "ThrowSecurityExceptionOnGetSessionFalse";
          strProp = getStringProperty(throwSecurityExceptionOnGetSessionFalse, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(throwSecurityExceptionOnGetSessionFalse, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                  smc.setThrowSecurityExceptionOnGetSessionFalse(booleanProp.booleanValue());
              }
          }
  
          final String invalidateOnUnauthorizedSessionRequestException = "InvalidateOnUnauthorizedSessionRequestException";
          strProp = getStringProperty(invalidateOnUnauthorizedSessionRequestException, xtpProperties);
          if (strProp != null) {
              booleanProp = Boolean.valueOf(strProp);
              if (shouldSetAndDoLogging(invalidateOnUnauthorizedSessionRequestException, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false))
                  smc.setInvalidateOnUnauthorizedSessionRequestException(booleanProp.booleanValue());
          }
          
          
          // PI18177 We will check incoming cloneIds against this string, needs HttpSessionCloneId to be set to take effect
          final String expectedCloneIds = "ExpectedCloneIds";
          strProp = getStringProperty(expectedCloneIds, xtpProperties);
          if (strProp != null) {
              if (shouldSetAndDoLogging(expectedCloneIds, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                  SessionManagerConfig.setExpectedCloneIds(strProp);
                  SessionManagerConfig.setExpectedCloneIdsPropertySet(true);
              }
          }
          
          // Feature 68570 Begin
          final String propConnectionRetryCount = "ConnectionRetryCount";
          strProp = getStringProperty(propConnectionRetryCount, xtpProperties);
          if (strProp != null) {
              try {
                  int retryCount = new Integer(strProp).intValue();
                  if (shouldSetAndDoLogging(propConnectionRetryCount, false, baseServerLevelConfig, xtpProperties, new Integer(retryCount), null, false)) {
                      smc.setConnectionRetryCount(retryCount);
                  }
              } catch (NumberFormatException nfe) {
                  LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propConnectionRetryCount,
                                                                                                                                          strProp });
              }
          } // Feature 68570 End
  
      }