import org.openid4java.OpenIDException; //导入依赖的package包/类
public static IndirectError createIndirectError(OpenIDException e,
                                                String msg, String returnTo,
                                                boolean compatibility)
{
    IndirectError err = new IndirectError(e, msg, returnTo, compatibility);

    try
    {
        err.validate();
    }
    catch (MessageException ex)
    {
        _log.error("Invalid " + (compatibility? "OpenID1" : "OpenID2") +
                   " indirect error message created for message: " + msg);
    }

    _log.debug("Created indirect error message:\n" + err.keyValueFormEncoding());

    return err;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void validate() throws MessageException
{
    if (! MODE_CHKAUTH.equals(getParameterValue("openid.mode")))
    {
        throw new MessageException(
            "Invalid openid.mode in verification request: "
            + getParameterValue("openid.mode"),
            OpenIDException.VERIFY_ERROR);
    }

    set("openid.mode", MODE_IDRES);

    if (DEBUG) _log.debug("Delegating verification request validity check " +
                          "to auth response...");

    super.validate();

    set("openid.mode", MODE_CHKAUTH);
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public static DirectError createDirectError(OpenIDException e, String msg, boolean compatibility)
{
    DirectError err = new DirectError(e, msg, compatibility);

    try
    {
        err.validate();
    }
    catch (MessageException ex)
    {
        _log.error("Invalid " + (compatibility? "OpenID1" : "OpenID2") +
                   " direct error message created for message: " + msg);
    }

    _log.debug("Created direct error message:\n" + err.keyValueFormEncoding());

    return err;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Checks the validity of the extension.
 * <p>
 * Used when constructing a extension from a parameter list.
 *
 * @throws MessageException if the PapeRequest is not valid.
 */
public void validate() throws MessageException
{
    if (! _parameters.hasParameter("preferred_auth_policies"))
    {
        throw new MessageException(
            "preferred_auth_policies is required in a PAPE request.",
            OpenIDException.PAPE_ERROR);
    }

    Iterator it = _parameters.getParameters().iterator();
    while (it.hasNext())
    {
        String paramName = ((Parameter) it.next()).getKey();
        if (! PAPE_FIELDS.contains(paramName) && ! paramName.startsWith(PapeMessage.AUTH_LEVEL_NS_PREFIX))
        {
            throw new MessageException(
                "Invalid parameter name in PAPE request: " + paramName,
                OpenIDException.PAPE_ERROR);
        }
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
private HTMLDocumentImpl parseDocument(String htmlData) throws DiscoveryException
{
    OpenID4JavaDOMParser parser = new OpenID4JavaDOMParser();
    try
    {
        parser.parse(OpenID4JavaDOMParser.createInputSource(htmlData));
    }
    catch (Exception e)
    {
        throw new DiscoveryException("Error parsing HTML message",
        		OpenIDException.DISCOVERY_HTML_PARSE_ERROR, e);
    }

    if (parser.isIgnoredHeadStartElement())
    {
        throw new DiscoveryException(
                "HTML response must have exactly one HEAD element.",
                OpenIDException.DISCOVERY_HTML_PARSE_ERROR);
    }

    return (HTMLDocumentImpl) parser.getDocument();
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
private HTMLDocumentImpl parseDocument(String htmlData) throws YadisException
{
    OpenID4JavaDOMParser parser = new OpenID4JavaDOMParser();
    try
    {
        parser.parse(OpenID4JavaDOMParser.createInputSource(htmlData));
    }
    catch (Exception e)
    {
        throw new YadisException("Error parsing HTML message",
                OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, e);
    }

    if (parser.isIgnoredHeadStartElement())
    {
            throw new YadisException("HTML response must have exactly one HEAD element.",
                            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }

    return (HTMLDocumentImpl) parser.getDocument();
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Constructs a URL object from a string;
 * needed by the YadisURL(String) constructor
 *
 * @param urlString         URL-type identifier in string format
 * @return                  URL object
 * @throws YadisException   if the provided string is not a valid URL
 */
private static URL urlFromString(String urlString) throws YadisException
{
    URL url;

    try
    {
        url = new URL(urlString);
    }
    catch (MalformedURLException e)
    {
        throw new YadisException("Invalid URL: " + urlString,
                OpenIDException.YADIS_INVALID_URL, e);
    }

    return url;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public YadisResult discover(String url, int maxRedirects, HttpFetcher httpFetcher, Set serviceTypes)
    throws DiscoveryException
{
    YadisUrl yadisUrl = new YadisUrl(url);

    // try to retrieve the Yadis Descriptor URL with a HEAD call first
    YadisResult result = retrieveXrdsLocation(yadisUrl, false, maxRedirects, serviceTypes);

    // try GET 
    if (result.getXrdsLocation() == null)
        result = retrieveXrdsLocation(yadisUrl, true, maxRedirects, serviceTypes);

    if (result.getXrdsLocation() != null)
    {
        retrieveXrdsDocument(result, maxRedirects, serviceTypes);
    }
    else if (result.hasEndpoints())
    {
        // report the yadis url as the xrds location
        result.setXrdsLocation(url, OpenIDException.YADIS_INVALID_URL);
    }

    _log.info("Yadis discovered " + result.getEndpointCount() + " endpoints from: " + url);
    return result;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Parses the HTML input stream and scans for the Yadis XRDS location
 * in the HTML HEAD Meta tags.
 *
 * @param input             input data stream
 * @return String           the XRDS location URL, or null if not found
 * @throws YadisException   on parsing errors or Yadis protocal violations
 */
private String getHtmlMeta(String input) throws YadisException
{
    String xrdsLocation;

    if (input == null)
        throw new YadisException("Cannot download HTML message",
                OpenIDException.YADIS_HTMLMETA_DOWNLOAD_ERROR);

    xrdsLocation = YADIS_HTML_PARSER.getHtmlMeta(input);
    if (DEBUG)
    {
        _log.debug("input:\n" + input);
        _log.debug("xrdsLocation: " + xrdsLocation);
    }
    return xrdsLocation;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testInvalidUrl()
{
    try
    {
        _resolver.discover("bla.com");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_INVALID_URL);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
                OpenIDException.YADIS_INVALID_URL, expected.getErrorCode());
    }

}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testHeadTransportError() throws Exception
{
    _server.stop();

    try
    {
        _resolver.discover("http://localhost:" + _servletPort +
                           "/?servertopped");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_HEAD_TRANSPORT_ERROR);
    }
    catch (YadisException expected)
    {
        assertEquals(expected.getMessage(),
                OpenIDException.YADIS_HEAD_TRANSPORT_ERROR, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testMultipleXrdsLocationInHtml()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=multiplexrdslocation");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testHtmlHeadElementsNoHead()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=nohead");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testEmptyHtml()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=empty");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testGetError() throws Exception
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=nonexistantfile");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_GET_ERROR);
    }
    catch (YadisException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_GET_ERROR, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testXrdsSizeExceeded()
{
    HttpRequestOptions requestOptions = new HttpRequestOptions();
    requestOptions.setMaxBodySize(10);

    HttpFetcher cache = new HttpCache();
    cache.setDefaultRequestOptions(requestOptions);

    YadisResolver resolver = new YadisResolver(cache);

    try
    {
        resolver.discover("http://localhost:" +
            _servletPort + "/?headers=simpleheaders");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_XRDS_SIZE_EXCEEDED);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_XRDS_SIZE_EXCEEDED, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Send authorization request to OpenID server
 * @param userSuppliedString - OpenID username/login
 * @param req - current request object
 * @param res - current response object
 * @return - true if sent, false if error
 * @throws IOException - other problem
 */
public boolean authorizationRequest(String userSuppliedString, HttpServletRequest req, HttpServletResponse res) throws IOException {
    try {
        List discoveries = manager.discover(userSuppliedString);

        DiscoveryInformation discovered = manager.associate(discoveries);

        req.getSession().setAttribute("openid-disc", discovered);

        AuthRequest authReq = manager.authenticate(discovered, returnToUrl);
        SRegRequest sregReq = SRegRequest.createFetchRequest();

        sregReq.addAttribute("email", true);
        sregReq.addAttribute("fullname", true);
        authReq.addExtension(sregReq);

        res.sendRedirect(authReq.getDestinationUrl(true));

        return true;
    } catch (OpenIDException ex) {
        // logger.error("Exception in authRequest with '" + userSuppliedString + "'", ex);
    }

    return false;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
@Override
@SuppressWarnings("rawtypes")
protected RedirectAction retrieveRedirectAction(final WebContext context) throws HttpAction {
    final String userIdentifier = getUser(context);
    CommonHelper.assertNotBlank("openIdUser", userIdentifier);

    try {
        // perform discovery on the user-supplied identifier
        final List discoveries = this.consumerManager.discover(userIdentifier);

        // attempt to associate with the OpenID provider
        // and retrieve one service endpoint for authentication
        final DiscoveryInformation discoveryInformation = this.consumerManager.associate(discoveries);

        // save discovery information in session
        context.setSessionAttribute(getDiscoveryInformationSessionAttributeName(), discoveryInformation);

        // create authentication request to be sent to the OpenID provider
        final AuthRequest authRequest = this.consumerManager.authenticate(discoveryInformation,
                computeFinalCallbackUrl(context));

        // create fetch request for attributes
        final FetchRequest fetchRequest = getFetchRequest();
        if (fetchRequest != null) {
            authRequest.addExtension(fetchRequest);
        }

        final String redirectionUrl = authRequest.getDestinationUrl(true);
        logger.debug("redirectionUrl: {}", redirectionUrl);
        return RedirectAction.redirect(redirectionUrl);
    } catch (final OpenIDException e) {
        throw new TechnicalException("OpenID exception", e);
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
@Override
protected U retrieveUserProfile(final OpenIdCredentials credentials, final WebContext context) throws HttpAction {
    final ParameterList parameterList = credentials.getParameterList();
    final DiscoveryInformation discoveryInformation = credentials.getDiscoveryInformation();
    logger.debug("parameterList: {}", parameterList);
    logger.debug("discoveryInformation: {}", discoveryInformation);

    try {
        // verify the response
        final VerificationResult verification = this.consumerManager.verify(computeFinalCallbackUrl(context), parameterList,
                discoveryInformation);

        // examine the verification result and extract the verified identifier
        final Identifier verified = verification.getVerifiedId();
        if (verified != null) {
            final AuthSuccess authSuccess = (AuthSuccess) verification.getAuthResponse();
            logger.debug("authSuccess: {}", authSuccess);

            final U profile = createProfile(authSuccess);
            profile.setId(verified.getIdentifier());
            logger.debug("profile: {}", profile);
            return profile;
        }
    } catch (final OpenIDException e) {
        throw new TechnicalException("OpenID exception", e);
    }

    final String message = "No verifiedId found";
    throw new TechnicalException(message);
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
protected IndirectError(OpenIDException e, String msg, String returnTo, boolean compatibility)
{
    set("openid.mode", "error");
    set("openid.error", msg);
    _destinationUrl = returnTo;
    _exception = e;

    if (! compatibility)
        set("openid.ns", OPENID2_NS);
}