public static boolean authenticate(AuthScheme authscheme,
    HttpMethod method,
    HttpConnection conn,
    HttpState state) throws AuthenticationException 
{
       LOG.trace(
            "enter HttpAuthenticator.authenticate(AuthScheme, HttpMethod, HttpConnection, "
            + "HttpState)");
        return doAuthenticate(authscheme, method, conn, state, false);
}

Attempt to provide requisite authentication credentials to the given method in the given context using the given authentication scheme.

 public static boolean authenticateDefault(HttpMethod method,
    HttpConnection conn,
    HttpState state) throws AuthenticationException 
{
        LOG.trace(
            "enter HttpAuthenticator.authenticateDefault(HttpMethod, HttpConnection, HttpState)");
        return doAuthenticateDefault(method, conn, state, false);
}

Attempt to provide default authentication credentials to the given method in the given context using basic authentication scheme.

 public static boolean authenticateProxy(AuthScheme authscheme,
    HttpMethod method,
    HttpConnection conn,
    HttpState state) throws AuthenticationException 
{
       LOG.trace("enter HttpAuthenticator.authenticateProxy(AuthScheme, HttpMethod, HttpState)");
       return doAuthenticate(authscheme, method, conn, state, true);
}

Attempt to provide requisite proxy authentication credentials to the given method in the given context using the given authentication scheme.

 public static boolean authenticateProxyDefault(HttpMethod method,
    HttpConnection conn,
    HttpState state) throws AuthenticationException 
{
        LOG.trace("enter HttpAuthenticator.authenticateProxyDefault(HttpMethod, HttpState)");
        return doAuthenticateDefault(method, conn, state, true);
}

Attempt to provide default proxy authentication credentials to the given method in the given context using basic authentication scheme.

 public static AuthScheme selectAuthScheme(Header[] challenges) throws MalformedChallengeException 
{
                                                                                                                               
        LOG.trace("enter HttpAuthenticator.selectAuthScheme(Header[])");
        if (challenges == null) {
            throw new IllegalArgumentException("Array of challenges may not be null");
        }
        if (challenges.length == 0) {
            throw new IllegalArgumentException("Array of challenges may not be empty");
        }
        String challenge = null;
        Map challengemap = new HashMap(challenges.length); 
        for (int i = 0; i <  challenges.length; i++) {
            challenge = challenges[i].getValue();
            String s = AuthChallengeParser.extractScheme(challenge);
            challengemap.put(s, challenge);
        }
        challenge = (String) challengemap.get("ntlm");
        if (challenge != null) {
            return new NTLMScheme(challenge);
        }
        challenge = (String) challengemap.get("digest");
        if (challenge != null) {
            return new DigestScheme(challenge);
        }
        challenge = (String) challengemap.get("basic");
        if (challenge != null) {
            return new BasicScheme(challenge);
        }
        throw new UnsupportedOperationException(
          "Authentication scheme(s) not supported: " + challengemap.toString());
}

Chooses the strongest authentication scheme supported from the array of authentication challenges. Currently only NTLM, Digest, Basic schemes are recognized. The NTLM scheme is considered the strongest and is preferred to all others. The Digest scheme is preferred to the Basic one which provides no encryption for credentials. The Basic scheme is used only if it is the only one supported.