import org.openid4java.message.DirectError; //导入依赖的package包/类
public void handleError(HttpServletResponse response, HttpServletRequest request, final String errorMessage, final int ERROR_CODE) throws IOException {
    LOG.info("--> BEGIN handleError");
    Message openidResponse = DirectError.createDirectError(errorMessage);
    response.setStatus(ERROR_CODE);
    response.setContentType("text/html;charset=utf-8");
    String responseText = openidResponse.keyValueFormEncoding();
    response.getWriter().println(responseText);
    String requestContent = String.format("%s %s\n\nParameters:\n\n%s",
      request.getMethod(),
      request.getRequestURL(),
      new ParameterList(request.getParameterMap()));
    RequestLogger.getInstance().add(RequestType.ERROR, errorMessage, requestContent, errorMessage, idpType);
    LOG.info("--> END handleError");
}
 

import org.openid4java.message.DirectError; //导入依赖的package包/类
/**
 * Process the request.
 *
 * @param httpReq
 *            the HTTP request
 * @param httpResp
 *            the HTTp resposne
 * @return process result string
 * @throws Exception
 *             indicate authenticate error
 */
private String processRequest(final HttpServletRequest httpReq,
		final HttpServletResponse httpResp) throws MessageException,
		IOException {
	Domain domain = this.getDomain(httpReq);
	if (getLog().isDebugEnabled()) {
		getLog().debug("domain: " + domain);
	}
	ServerManager serverManager =
		this.getJosService().getServerManager(domain);

	// extract the parameters from the request
	ParameterList request = new ParameterList(httpReq.getParameterMap());

	String mode = request.getParameterValue("openid.mode");

	Message response;
	String responseText;

	if ("associate".equals(mode)) {
		// --- process an association request ---
		response = serverManager.associationResponse(request);
		responseText = response.keyValueFormEncoding();
	} else if ("checkid_setup".equals(mode)
			|| "checkid_immediate".equals(mode)) {
		AuthRequest authReq = AuthRequest.createAuthRequest(request,
				serverManager.getRealmVerifier());
		new ApprovingRequestProcessor(httpReq, httpResp, getJosService(),
				serverManager, new ApprovingRequest(authReq)).checkId();
		responseText = null;
	} else if ("check_authentication".equals(mode)) {
		// --- processing a verification request ---
		response = serverManager.verify(request);
		responseText = response.keyValueFormEncoding();
	} else {
		// --- error response ---
		response = DirectError.createDirectError("Unknown request");
		responseText = response.keyValueFormEncoding();
	}

	// return the result to the user
	return responseText;
}
 

import org.openid4java.message.DirectError; //导入依赖的package包/类
public Message verify(ParameterList requestParams) {

        if(log.isDebugEnabled()) {
            log.debug("Processing verification request...");
        }

        boolean isVersion2 = true;

        try {
            // build request message from response params (+ ntegrity check)
            VerifyRequest vrfyReq = VerifyRequest.createVerifyRequest(requestParams);
            isVersion2 = vrfyReq.isVersion2();
            String handle = vrfyReq.getHandle();

            boolean verified = false;

            Association assoc = getPrivateAssociations().load(handle);
            String sigMod = null;
            if (assoc != null) { // verify the signature
                if (log.isDebugEnabled()) {
                    log.debug("Loaded private association; handle: " + handle);
                }
                sigMod = vrfyReq.getSignature().replaceAll("\\s", "+");
                verified = assoc.verifySignature(vrfyReq.getSignedText(), sigMod);

                // remove the association so that the request
                // cannot be verified more than once
                getPrivateAssociations().remove(handle);
            } else {
                log.error("No association loaded from the database; handle: " + handle);
            }

            VerifyResponse vrfyResp =
                    VerifyResponse.createVerifyResponse(!vrfyReq.isVersion2());

            vrfyResp.setSignatureVerified(verified);

            if (verified) {
                String invalidateHandle = vrfyReq.getInvalidateHandle();
                if (invalidateHandle != null &&
                        getSharedAssociations().load(invalidateHandle) == null) {
                    if (log.isDebugEnabled()) {
                        log.debug("Shared association invalidated; handle: " + invalidateHandle);
                    }

                    vrfyResp.setInvalidateHandle(invalidateHandle);
                }
            } else {
                log.error("Signature verification failed. handle : " + handle +
                        " , signed text : " + vrfyReq.getSignedText() +
                        " , signature : " + sigMod);
            }

            if (log.isDebugEnabled()) {
                log.debug("Responding with " + (verified ? "positive" : "negative") + " verification response");
            }

            return vrfyResp;
        } catch (OpenIDException e) {
            log.error("Error processing verification request; responding with verification error", e);
            return DirectError.createDirectError(e, !isVersion2);
        }
    }
 

import org.openid4java.message.DirectError; //导入依赖的package包/类
/**
 * Return the error response message based on the given message
 *
 * @param message Error message
 * @return Direct error
 */
private String getErrorResponseText(String message) {
    log.error(message);
    return DirectError.createDirectError(message).keyValueFormEncoding();
}