/** * Used to get the base ssl context in which to create the server socket. This is basically just * so we can have a custom location for key stores. */ public SSLContext getSSLContext(String keyStoreName, String password) throws IOException { try { // Check the key manager factory KeyManagerFactory kmf = KeyManagerFactory.getInstance(this.keyManagerType); File ksFile = new File(keyStoreName); if (!ksFile.exists() || !ksFile.isFile()) throw new WinstoneException( SSL_RESOURCES.getString("HttpsListener.KeyStoreNotFound", ksFile.getPath())); InputStream in = new FileInputStream(ksFile); char[] passwordChars = password == null ? null : password.toCharArray(); KeyStore ks = KeyStore.getInstance("JKS"); ks.load(in, passwordChars); kmf.init(ks, passwordChars); Logger.log(Logger.FULL_DEBUG, SSL_RESOURCES, "HttpsListener.KeyCount", ks.size() + ""); for (Enumeration e = ks.aliases(); e.hasMoreElements(); ) { String alias = (String) e.nextElement(); Logger.log( Logger.FULL_DEBUG, SSL_RESOURCES, "HttpsListener.KeyFound", new String[] {alias, ks.getCertificate(alias) + ""}); } SSLContext context = SSLContext.getInstance("SSL"); context.init(kmf.getKeyManagers(), null, null); Arrays.fill(passwordChars, 'x'); return context; } catch (IOException err) { throw err; } catch (Throwable err) { throw new WinstoneException( SSL_RESOURCES.getString("HttpsListener.ErrorGettingContext"), err); } }
public String toString() { return DS_RESOURCES.getString( "WinstoneDataSource.StatusMsg", new String[] { this.name, "" + this.usedRealConnections.size(), "" + this.unusedRealConnections.size() }); }
private void log(int level, String msgKey, String arg[], Throwable err) { if (getLogWriter() != null) { getLogWriter().println(DS_RESOURCES.getString(msgKey, arg)); if (err != null) { err.printStackTrace(getLogWriter()); } } else { Logger.log(level, DS_RESOURCES, msgKey, arg, err); } }
public void contextInitialized(ServletContextEvent sce) { this.webAppConfig = (WebAppConfiguration) sce.getServletContext(); this.interrupted = false; synchronized (this) { this.loadedClasses.clear(); } Thread thread = new Thread(this, CL_RESOURCES.getString("ReloadingClassLoader.ThreadName")); thread.setDaemon(true); thread.setPriority(Thread.MIN_PRIORITY); thread.start(); }
protected boolean doRoleCheck( HttpServletRequest request, HttpServletResponse response, String pathRequested) throws IOException, ServletException { // Loop through constraints boolean foundApplicable = false; for (int n = 0; (n < this.constraints.length) && !foundApplicable; n++) { Logger.log( Logger.FULL_DEBUG, AUTH_RESOURCES, "BaseAuthenticationHandler.EvalConstraint", this.constraints[n].getName()); // Find one that applies, then if (this.constraints[n].isApplicable(pathRequested, request.getMethod())) { Logger.log( Logger.FULL_DEBUG, AUTH_RESOURCES, "BaseAuthenticationHandler.ApplicableConstraint", this.constraints[n].getName()); foundApplicable = true; if (this.constraints[n].needsSSL() && !request.isSecure()) { Logger.log( Logger.DEBUG, AUTH_RESOURCES, "BaseAuthenticationHandler.ConstraintNeedsSSL", this.constraints[n].getName()); response.sendError( HttpServletResponse.SC_FORBIDDEN, AUTH_RESOURCES.getString( "BaseAuthenticationHandler.ConstraintNeedsSSL", this.constraints[n].getName())); return false; } else if (!this.constraints[n].isAllowed(request)) { // Logger.log(Logger.FULL_DEBUG, "Not allowed - requesting auth"); requestAuthentication(request, response, pathRequested); return false; } else { // Logger.log(Logger.FULL_DEBUG, "Allowed - authorization accepted"); // Ensure that secured resources are not cached setNoCache(response); } } } // If we made it this far without a check being run, there must be none applicable Logger.log(Logger.FULL_DEBUG, AUTH_RESOURCES, "BaseAuthenticationHandler.PassedAuthCheck"); return true; }
/** Get a read-write connection - preferably from the pool, but fresh if needed */ protected Connection getConnection(int retriesAllowed) throws SQLException { Connection realConnection = null; synchronized (this.unusedRealConnections) { // If we have any spare, get it from the unused pool if (this.unusedRealConnections.size() > 0) { realConnection = (Connection) this.unusedRealConnections.get(0); this.unusedRealConnections.remove(realConnection); this.usedRealConnections.add(realConnection); log( Logger.FULL_DEBUG, "WinstoneDataSource.UsingPooled", new String[] { "" + this.usedRealConnections.size(), "" + this.unusedRealConnections.size() }, null); try { return prepareWrapper(realConnection); } catch (SQLException err) { // Leave the realConnection as non-null, so we know prepareWrapper failed } } // If we are out (and not over our limit), allocate a new one else if (this.usedRealConnections.size() < maxHeldCount) { realConnection = makeNewRealConnection(this.usedRealConnections); log( Logger.FULL_DEBUG, "WinstoneDataSource.UsingNew", new String[] { "" + this.usedRealConnections.size(), "" + this.unusedRealConnections.size() }, null); try { return prepareWrapper(realConnection); } catch (SQLException err) { // Leave the realConnection as non-null, so we know prepareWrapper failed } } } if (realConnection != null) { // prepareWrapper() must have failed, so call this method again realConnection = null; return getConnection(retriesAllowed); } else if (retriesAllowed <= 0) { // otherwise throw fail message - we've blown our limit throw new SQLException( DS_RESOURCES.getString("WinstoneDataSource.Exceeded", "" + maxHeldCount)); } else { log( Logger.FULL_DEBUG, "WinstoneDataSource.Retrying", new String[] {"" + maxHeldCount, "" + retriesAllowed, "" + retryPeriod}, null); // If we are here, it's because we need to retry for a connection try { Thread.sleep(retryPeriod); } catch (InterruptedException err) { } return getConnection(retriesAllowed - 1); } }
private static String transformToFileFormat(String name) { if (!name.startsWith("Class:")) return name; else return WinstoneResourceBundle.globalReplace(name.substring(6), ".", "/") + ".class"; }