001 package railo.runtime.config; 002 003 import java.io.IOException; 004 import java.net.URL; 005 import java.util.Enumeration; 006 import java.util.Map; 007 008 import javax.servlet.ServletConfig; 009 import javax.servlet.ServletContext; 010 import javax.servlet.http.HttpServletRequest; 011 import javax.servlet.http.HttpServletResponse; 012 013 import org.apache.commons.collections.map.ReferenceMap; 014 import org.xml.sax.SAXException; 015 016 import railo.commons.io.SystemUtil; 017 import railo.commons.io.log.Log; 018 import railo.commons.io.log.LogAndSource; 019 import railo.commons.io.log.LogAndSourceImpl; 020 import railo.commons.io.log.LogConsole; 021 import railo.commons.io.res.Resource; 022 import railo.commons.io.res.ResourceProvider; 023 import railo.commons.io.res.ResourcesImpl; 024 import railo.commons.lang.ClassException; 025 import railo.commons.lang.StringUtil; 026 import railo.commons.lock.KeyLock; 027 import railo.runtime.CFMLFactoryImpl; 028 import railo.runtime.Mapping; 029 import railo.runtime.MappingImpl; 030 import railo.runtime.Page; 031 import railo.runtime.PageContext; 032 import railo.runtime.PageSourceImpl; 033 import railo.runtime.cfx.CFXTagPool; 034 import railo.runtime.compiler.CFMLCompilerImpl; 035 import railo.runtime.debug.DebuggerPool; 036 import railo.runtime.engine.ThreadQueueImpl; 037 import railo.runtime.exp.ExpressionException; 038 import railo.runtime.exp.PageException; 039 import railo.runtime.exp.SecurityException; 040 import railo.runtime.gateway.GatewayEngineImpl; 041 import railo.runtime.gateway.GatewayEntry; 042 import railo.runtime.lock.LockManager; 043 import railo.runtime.lock.LockManagerImpl; 044 import railo.runtime.monitor.ActionMonitorCollector; 045 import railo.runtime.monitor.IntervallMonitor; 046 import railo.runtime.monitor.RequestMonitor; 047 import railo.runtime.net.http.ReqRspUtil; 048 import railo.runtime.security.SecurityManager; 049 import railo.runtime.security.SecurityManagerImpl; 050 import railo.runtime.tag.TagHandlerPool; 051 import railo.runtime.type.scope.Cluster; 052 import railo.runtime.writer.CFMLWriter; 053 import railo.runtime.writer.CFMLWriterImpl; 054 import railo.runtime.writer.CFMLWriterWS; 055 import railo.runtime.writer.CFMLWriterWSPref; 056 import railo.transformer.library.function.FunctionLibException; 057 import railo.transformer.library.tag.TagLibException; 058 059 /** 060 * Web Context 061 */ 062 public final class ConfigWebImpl extends ConfigImpl implements ServletConfig, ConfigWeb { 063 064 private ServletConfig config; 065 private ConfigServerImpl configServer; 066 private SecurityManager securityManager; 067 private static final LockManager lockManager= LockManagerImpl.getInstance(false); 068 private Resource rootDir; 069 private CFMLCompilerImpl compiler=new CFMLCompilerImpl(); 070 private Page baseComponentPage; 071 private MappingImpl serverTagMapping; 072 private MappingImpl serverFunctionMapping; 073 private KeyLock<String> contextLock; 074 private GatewayEngineImpl gatewayEngine; 075 private LogAndSource gatewayLogger=null;//new LogAndSourceImpl(LogConsole.getInstance(Log.LEVEL_INFO),"");private DebuggerPool debuggerPool; 076 private DebuggerPool debuggerPool; 077 078 079 080 //private File deployDirectory; 081 082 /** 083 * constructor of the class 084 * @param configServer 085 * @param config 086 * @param configDir 087 * @param configFile 088 * @param cloneServer 089 */ 090 protected ConfigWebImpl(CFMLFactoryImpl factory,ConfigServerImpl configServer, ServletConfig config, Resource configDir, Resource configFile) { 091 super(factory,configDir, configFile,configServer.getTLDs(),configServer.getFLDs()); 092 this.configServer=configServer; 093 this.config=config; 094 factory.setConfig(this); 095 ResourceProvider frp = ResourcesImpl.getFileResourceProvider(); 096 097 this.rootDir=frp.getResource(ReqRspUtil.getRootPath(config.getServletContext())); 098 099 100 // Fix for tomcat 101 if(this.rootDir.getName().equals(".") || this.rootDir.getName().equals("..")) 102 this.rootDir=this.rootDir.getParentResource(); 103 } 104 105 public void reset() { 106 super.reset(); 107 tagHandlerPool.reset(); 108 contextLock=null; 109 baseComponentPage=null; 110 } 111 112 /* * 113 * Constructor of the class, used for configserver dummy instance 114 * @param factory 115 * @param configServer 116 * @param configx 117 * @param configDir 118 * @param configFile 119 * / 120 protected ConfigWebImpl(CFMLFactoryImpl factory,ConfigServerImpl configServer, Resource configDir, Resource configFile,Resource rootDir) { 121 super(factory,configDir, configFile,configServer.getTLDs(),configServer.getFLDs()); 122 this.configServer=configServer; 123 factory.setConfig(this); 124 125 this.rootDir=rootDir; 126 127 // Fix for tomcat 128 if(this.rootDir.getName().equals(".") || this.rootDir.getName().equals("..")) 129 this.rootDir=this.rootDir.getParentResource(); 130 }*/ 131 132 133 134 @Override 135 public String getServletName() { 136 return config.getServletName(); 137 } 138 139 @Override 140 public ServletContext getServletContext() { 141 return config.getServletContext(); 142 } 143 144 @Override 145 public String getInitParameter(String name) { 146 return config.getInitParameter(name); 147 } 148 149 @Override 150 public Enumeration getInitParameterNames() { 151 return config.getInitParameterNames(); 152 } 153 154 protected ConfigServerImpl getConfigServerImpl() { 155 return configServer; 156 } 157 158 @Override 159 public ConfigServer getConfigServer(String password) throws ExpressionException { 160 if(!configServer.hasPassword()) 161 throw new ExpressionException("Cannot access, no password is defined"); 162 if(!configServer.getPassword().equalsIgnoreCase(password)) 163 throw new ExpressionException("No access, password is invalid"); 164 return configServer; 165 } 166 167 public String getServerId() { 168 return configServer.getId(); 169 } 170 171 public String getServerSecurityKey() { 172 return configServer.getSecurityKey(); 173 } 174 175 public Resource getServerConfigDir() { 176 return configServer.getConfigDir(); 177 } 178 179 180 /** 181 * @return Returns the accessor. 182 */ 183 public SecurityManager getSecurityManager() { 184 return securityManager; 185 } 186 187 /** 188 * @param securityManager The accessor to set. 189 */ 190 protected void setSecurityManager(SecurityManager securityManager) { 191 ((SecurityManagerImpl)securityManager).setRootDirectory(getRootDirectory()); 192 this.securityManager = securityManager; 193 } 194 195 @Override 196 public CFXTagPool getCFXTagPool() throws SecurityException { 197 if(securityManager.getAccess(SecurityManager.TYPE_CFX_USAGE)==SecurityManager.VALUE_YES) return super.getCFXTagPool(); 198 throw new SecurityException("no access to cfx functionality", "disabled by security settings"); 199 } 200 201 /** 202 * @return Returns the rootDir. 203 */ 204 public Resource getRootDirectory() { 205 return rootDir; 206 } 207 208 @Override 209 public String getUpdateType() { 210 return configServer.getUpdateType(); 211 } 212 213 @Override 214 public URL getUpdateLocation() { 215 return configServer.getUpdateLocation(); 216 } 217 218 @Override 219 public LockManager getLockManager() { 220 return lockManager; 221 } 222 223 /** 224 * @return the compiler 225 */ 226 public CFMLCompilerImpl getCompiler() { 227 return compiler; 228 } 229 230 public Page getBaseComponentPage(PageContext pc) throws PageException { 231 if(baseComponentPage==null) { 232 baseComponentPage=((PageSourceImpl)getBaseComponentPageSource(pc)).loadPage(pc); 233 234 } 235 return baseComponentPage; 236 } 237 public void resetBaseComponentPage() { 238 baseComponentPage=null; 239 } 240 241 242 243 244 245 public Mapping getServerTagMapping() { 246 if(serverTagMapping==null){ 247 serverTagMapping=getConfigServerImpl().tagMapping.cloneReadOnly(this); 248 } 249 return serverTagMapping; 250 } 251 public Mapping getServerFunctionMapping() { 252 if(serverFunctionMapping==null){ 253 serverFunctionMapping=getConfigServerImpl().functionMapping.cloneReadOnly(this); 254 } 255 return serverFunctionMapping; 256 } 257 private Map<String,Mapping> applicationMappings=new ReferenceMap(); 258 private TagHandlerPool tagHandlerPool=new TagHandlerPool(this); 259 public Mapping getApplicationMapping(String virtual, String physical) { 260 return getApplicationMapping(virtual, physical, null); 261 } 262 263 public Mapping getApplicationMapping(String virtual, String physical, String archive) { 264 String key=virtual.toLowerCase()+physical.toLowerCase(); 265 Mapping m= applicationMappings.get(key); 266 if(m==null){ 267 m=new MappingImpl(this, 268 virtual, 269 physical, 270 archive,ConfigImpl.INSPECT_UNDEFINED,true,false,false,false,true,false,null 271 ); 272 applicationMappings.put(key, m); 273 } 274 return m; 275 } 276 277 public String getLabel() { 278 String hash=getHash(); 279 String label=hash; 280 Map<String, String> labels = configServer.getLabels(); 281 if(labels!=null) { 282 String l = labels.get(hash); 283 if(!StringUtil.isEmpty(l)) { 284 label=l; 285 } 286 } 287 return label; 288 } 289 290 public String getHash() { 291 return SystemUtil.hash(getServletContext()); 292 } 293 294 public KeyLock<String> getContextLock() { 295 if(contextLock==null) { 296 contextLock=new KeyLock<String>(); 297 } 298 return contextLock; 299 } 300 301 302 protected void setGatewayEntries(Map<String, GatewayEntry> gatewayEntries) { 303 try { 304 getGatewayEngine().addEntries(this,gatewayEntries); 305 } catch (Exception e) { 306 e.printStackTrace(); 307 } 308 } 309 public GatewayEngineImpl getGatewayEngine() { 310 if(gatewayEngine==null){ 311 gatewayEngine=new GatewayEngineImpl(this); 312 } 313 return gatewayEngine; 314 } 315 public void setGatewayEngine(GatewayEngineImpl gatewayEngine) { 316 this.gatewayEngine=gatewayEngine; 317 } 318 319 public LogAndSource getGatewayLogger() { 320 if(gatewayLogger==null)gatewayLogger=new LogAndSourceImpl(LogConsole.getInstance(this,Log.LEVEL_ERROR),""); 321 return gatewayLogger; 322 } 323 324 325 public void setGatewayLogger(LogAndSource gatewayLogger) { 326 this.gatewayLogger=gatewayLogger; 327 } 328 329 public TagHandlerPool getTagHandlerPool() { 330 return tagHandlerPool; 331 } 332 333 public DebuggerPool getDebuggerPool() { 334 if(debuggerPool==null){ 335 Resource dir = getConfigDir().getRealResource("debugger"); 336 dir.mkdirs(); 337 debuggerPool=new DebuggerPool(dir); 338 } 339 return debuggerPool; 340 } 341 342 343 public ThreadQueueImpl getThreadQueue() { 344 return configServer.getThreadQueue(); 345 } 346 347 @Override 348 public int getLoginDelay() { 349 return configServer.getLoginDelay(); 350 } 351 352 @Override 353 public boolean getLoginCaptcha() { 354 return configServer.getLoginCaptcha(); 355 } 356 357 @Override 358 public Resource getSecurityDirectory(){ 359 return configServer.getSecurityDirectory(); 360 } 361 362 @Override 363 public boolean isMonitoringEnabled(){ 364 return configServer.isMonitoringEnabled(); 365 } 366 367 368 369 public RequestMonitor[] getRequestMonitors(){ 370 return configServer.getRequestMonitors(); 371 } 372 373 public RequestMonitor getRequestMonitor(String name) throws PageException{ 374 return configServer.getRequestMonitor(name); 375 } 376 377 public IntervallMonitor[] getIntervallMonitors(){ 378 return configServer.getIntervallMonitors(); 379 } 380 381 public IntervallMonitor getIntervallMonitor(String name) throws PageException{ 382 return configServer.getIntervallMonitor(name); 383 } 384 385 @Override 386 public void checkPermGenSpace(boolean check) { 387 configServer.checkPermGenSpace(check); 388 } 389 390 @Override 391 public Cluster createClusterScope() throws PageException { 392 return configServer.createClusterScope(); 393 } 394 395 @Override 396 public boolean hasServerPassword() { 397 return configServer.hasPassword(); 398 } 399 400 public void setPassword(boolean server, String passwordOld, String passwordNew) 401 throws PageException, SAXException, ClassException, IOException, TagLibException, FunctionLibException { 402 ConfigImpl config=server?configServer:this; 403 404 if(!config.hasPassword()) { 405 config.setPassword(passwordNew); 406 407 ConfigWebAdmin admin = ConfigWebAdmin.newInstance(config,passwordNew); 408 admin.setPassword(passwordNew); 409 admin.store(); 410 } 411 else { 412 ConfigWebUtil.checkGeneralWriteAccess(config,passwordOld); 413 ConfigWebAdmin admin = ConfigWebAdmin.newInstance(config,passwordOld); 414 admin.setPassword(passwordNew); 415 admin.store(); 416 } 417 } 418 419 @Override 420 public Resource getConfigServerDir() { 421 return configServer.getConfigDir(); 422 } 423 424 public Map<String, String> getAllLabels() { 425 return configServer.getLabels(); 426 } 427 428 @Override 429 public boolean allowRequestTimeout() { 430 return configServer.allowRequestTimeout(); 431 } 432 433 public CFMLWriter getCFMLWriter(HttpServletRequest req, HttpServletResponse rsp) { 434 // FUTURE move interface CFMLWriter to Loader and load dynaicly from railo-web.xml 435 if(writerType==CFML_WRITER_WS) 436 return new CFMLWriterWS (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression()); 437 else if(writerType==CFML_WRITER_REFULAR) 438 return new CFMLWriterImpl (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression()); 439 else 440 return new CFMLWriterWSPref (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression()); 441 } 442 443 444 public ActionMonitorCollector getActionMonitorCollector() { 445 return configServer.getActionMonitorCollector(); 446 } 447 448 @Override 449 public boolean getFullNullSupport() { 450 return configServer.getFullNullSupport(); 451 } 452 public boolean hasIndividualSecurityManager() { 453 return configServer.hasIndividualSecurityManager(getId()); 454 } 455 }