private static void writeConfig(
final ContextManager contextManager, final StoredConfigurationImpl storedConfiguration)
throws PwmOperationalException, PwmUnrecoverableException {
ConfigurationReader configReader = contextManager.getConfigReader();
PwmApplication pwmApplication = contextManager.getPwmApplication();
try {
// add a random security key
storedConfiguration.initNewRandomSecurityKey();
storedConfiguration.writeConfigProperty(
StoredConfigurationImpl.ConfigProperty.PROPERTY_KEY_CONFIG_IS_EDITABLE, "true");
configReader.saveConfiguration(storedConfiguration, pwmApplication, null);
contextManager.requestPwmApplicationRestart();
} catch (PwmException e) {
throw new PwmOperationalException(e.getErrorInformation());
} catch (Exception e) {
final ErrorInformation errorInformation =
new ErrorInformation(
PwmError.ERROR_INVALID_CONFIG,
"unable to save configuration: " + e.getLocalizedMessage());
throw new PwmOperationalException(errorInformation);
}
}
/**
* Maps a named servlet to a particular path or extension. If the named servlet is unregistered,
* it will be added and subsequently mapped.
*
* <p>Note that the order of resolution to handle a request is:
*
* <p>exact mapped servlet (eg /catalog) prefix mapped servlets (eg /foo/bar/*) extension mapped
* servlets (eg *jsp) default servlet
*/
public void addServletMapping(String path, String servletName) throws TomcatException {
if (mappings.get(path) != null) {
log("Removing duplicate " + path + " -> " + mappings.get(path));
mappings.remove(path);
Container ct = (Container) containers.get(path);
removeContainer(ct);
}
ServletWrapper sw = (ServletWrapper) servlets.get(servletName);
if (sw == null) {
// Workaround for frequent "bug" in web.xmls
// Declare a default mapping
log("Mapping with unregistered servlet " + servletName);
sw = addServlet(servletName, servletName);
}
if ("/".equals(path)) defaultServlet = sw;
mappings.put(path, sw);
Container map = new Container();
map.setContext(this);
map.setHandler(sw);
map.setPath(path);
contextM.addContainer(map);
containers.put(path, map);
}
/** Return the absolute path for the docBase, if we are file-system based, null otherwise. */
public String getAbsolutePath() {
if (absPath != null) return absPath;
if (FileUtil.isAbsolute(docBase)) absPath = docBase;
else absPath = contextM.getHome() + File.separator + docBase;
try {
absPath = new File(absPath).getCanonicalPath();
} catch (IOException npe) {
}
return absPath;
}
public void start() throws Exception {
if (con == null) throw new Exception("Invalid ConnectionHandler");
con.setAttribute("context.manager", cm);
ep.setPort(port);
ep.setAddress(address);
if (socketFactory != null) {
ep.setServerSocketFactory(socketFactory);
}
ep.setConnectionHandler(con);
ep.startEndpoint();
cm.log("Starting endpoint port=\"" + port + "\" handler=\"" + con.getClass().getName() + "\" ");
}
public Context getContext(String path) {
if (!path.startsWith("/")) {
return null; // according to spec, null is returned
// if we can't return a servlet, so it's more probable
// servlets will check for null than IllegalArgument
}
// Return null if cross context lookups are not allowed
if (!crossContext) return null;
// absolute path
Request lr = contextM.createRequest(path);
if (vhost != null) lr.setServerName(vhost);
getContextManager().processRequest(lr);
return lr.getContext();
}
public static void restUploadConfig(final PwmRequest pwmRequest)
throws PwmUnrecoverableException, IOException, ServletException {
final PwmApplication pwmApplication = pwmRequest.getPwmApplication();
final PwmSession pwmSession = pwmRequest.getPwmSession();
final HttpServletRequest req = pwmRequest.getHttpServletRequest();
if (pwmApplication.getApplicationMode() == PwmApplication.MODE.RUNNING) {
final String errorMsg = "config upload is not permitted when in running mode";
final ErrorInformation errorInformation =
new ErrorInformation(PwmError.CONFIG_UPLOAD_FAILURE, errorMsg, new String[] {errorMsg});
pwmRequest.respondWithError(errorInformation, true);
return;
}
if (ServletFileUpload.isMultipartContent(req)) {
final InputStream uploadedFile = ServletHelper.readFileUpload(req, "uploadFile");
if (uploadedFile != null) {
try {
final StoredConfigurationImpl storedConfig =
StoredConfigurationImpl.fromXml(uploadedFile);
final List<String> configErrors = storedConfig.validateValues();
if (configErrors != null && !configErrors.isEmpty()) {
throw new PwmOperationalException(
new ErrorInformation(PwmError.CONFIG_FORMAT_ERROR, configErrors.get(0)));
}
writeConfig(ContextManager.getContextManager(req.getSession()), storedConfig);
LOGGER.trace(pwmSession, "read config from file: " + storedConfig.toString());
final RestResultBean restResultBean = new RestResultBean();
restResultBean.setSuccessMessage("read message");
pwmRequest.getPwmResponse().outputJsonResult(restResultBean);
req.getSession().invalidate();
} catch (PwmException e) {
final RestResultBean restResultBean =
RestResultBean.fromError(e.getErrorInformation(), pwmRequest);
pwmRequest.getPwmResponse().outputJsonResult(restResultBean);
LOGGER.error(pwmSession, e.getErrorInformation().toDebugStr());
}
} else {
final ErrorInformation errorInformation =
new ErrorInformation(
PwmError.CONFIG_UPLOAD_FAILURE,
"error reading config file: no file present in upload");
final RestResultBean restResultBean =
RestResultBean.fromError(errorInformation, pwmRequest);
pwmRequest.getPwmResponse().outputJsonResult(restResultBean);
LOGGER.error(pwmSession, errorInformation.toDebugStr());
}
}
}
/**
* Will add a new security constraint: For all paths: if( match(path) && match(method) && match(
* transport ) ) then require("roles")
*
* <p>This is equivalent with adding a Container with the path, method and transport. If the
* container will be matched, the request will have to pass the security constraints.
*/
public void addSecurityConstraint(
String path[], String methods[], String roles[], String transport) throws TomcatException {
for (int i = 0; i < path.length; i++) {
Container ct = new Container();
ct.setContext(this);
ct.setTransport(transport);
ct.setRoles(roles);
ct.setPath(path[i]);
ct.setMethods(methods);
// XXX check if exists, merge if true.
constraints.put(path[i], ct);
// contextM.addSecurityConstraint( this, path[i], ct);
contextM.addContainer(ct);
}
}
/**
* @deprecated - use getDocBase and URLUtil if you need it as URL NOT USED INSIDE TOMCAT - ONLY IN
* OLD J2EE CONNECTORS !
*/
public URL getDocumentBase() {
if (documentBase == null) {
if (docBase == null) return null;
try {
String absPath = docBase;
// detect absolute path ( use the same logic in all tomcat )
if (FileUtil.isAbsolute(docBase)) absPath = docBase;
else absPath = contextM.getHome() + File.separator + docBase;
try {
absPath = new File(absPath).getCanonicalPath();
} catch (IOException npe) {
}
documentBase = new URL("file", "", absPath);
} catch (MalformedURLException ex) {
ex.printStackTrace();
}
}
return documentBase;
}
private void restGotoStep(final PwmRequest pwmRequest, final ConfigGuideBean configGuideBean)
throws PwmUnrecoverableException, IOException, ServletException {
final String requestedStep = pwmRequest.readParameterAsString("step");
STEP step = null;
if (requestedStep != null && requestedStep.length() > 0) {
try {
step = STEP.valueOf(requestedStep);
} catch (IllegalArgumentException e) {
/* */
}
}
final boolean ldapSchemaPermitted =
"LDAP".equals(configGuideBean.getFormData().get(PARAM_CR_STORAGE_PREF))
&& configGuideBean.getSelectedTemplate() == PwmSettingTemplate.NOVL;
if ("NEXT".equals(requestedStep)) {
step = configGuideBean.getStep().next();
if (step == STEP.LDAP_SCHEMA && !ldapSchemaPermitted) {
step = step.next();
}
} else if ("PREVIOUS".equals(requestedStep)) {
step = configGuideBean.getStep().previous();
if (step == STEP.LDAP_SCHEMA && !ldapSchemaPermitted) {
step = step.previous();
}
}
if (step == null) {
final String errorMsg = "unknown goto step request: " + requestedStep;
final ErrorInformation errorInformation =
new ErrorInformation(PwmError.CONFIG_FORMAT_ERROR, errorMsg);
final RestResultBean restResultBean = RestResultBean.fromError(errorInformation, pwmRequest);
LOGGER.error(pwmRequest, errorInformation.toDebugStr());
pwmRequest.outputJsonResult(restResultBean);
return;
}
if (step == STEP.FINISH) {
final ContextManager contextManager = ContextManager.getContextManager(pwmRequest);
try {
writeConfig(contextManager, configGuideBean);
} catch (PwmException e) {
final RestResultBean restResultBean =
RestResultBean.fromError(e.getErrorInformation(), pwmRequest);
pwmRequest.outputJsonResult(restResultBean);
return;
} catch (Exception e) {
final RestResultBean restResultBean =
RestResultBean.fromError(
new ErrorInformation(
PwmError.ERROR_UNKNOWN, "error during save: " + e.getMessage()),
pwmRequest);
pwmRequest.outputJsonResult(restResultBean);
return;
}
final HashMap<String, String> resultData = new HashMap<>();
resultData.put("serverRestart", "true");
pwmRequest.outputJsonResult(new RestResultBean(resultData));
pwmRequest.invalidateSession();
} else {
configGuideBean.setStep(step);
pwmRequest.outputJsonResult(new RestResultBean());
LOGGER.trace("setting current step to: " + step);
}
}
public void stop() throws Exception {
cm.log("Stoping endpoint port=\"" + port + "\" handler=\"" + con.getClass().getName() + "\" ");
ep.stopEndpoint();
}
