private void writeRequestLine(PrintStream writer, HTTPRequest request) { writer.print(String.format("%s %s HTTP/1.1\r\n", request.getMethod().toString(), request.getRequestURI().getPath())); } }
public static RequestDigest newInstance(UsernamePasswordChallenge challenge, HTTPRequest request, Digest digest) { return new RequestDigest(challenge, request.getMethod(), URI.create(request.getRequestURI().getRawPath()), digest); }
public void afterFailedAuthentication(HTTPRequest request, Headers responseHeaders) { HTTPHost host = new HTTPHost(request.getRequestURI()); registry.remove(host); } }
public boolean canAuthenticatePreemptively(HTTPRequest request) { return canAuthenticatePreemptively(new HTTPHost(request.getRequestURI())); }
@Override protected HTTPResponse resolveImpl(HTTPRequest request) throws IOException { URL url = request.getRequestURI().toURL(); URLConnection openConnection = url.openConnection(); if (openConnection instanceof HttpsURLConnection) { HttpsURLConnection connection = (HttpsURLConnection) openConnection; doRequest(request, connection); return convertResponse(connection); } else if (openConnection instanceof HttpURLConnection) { HttpURLConnection connection = (HttpURLConnection) openConnection; doRequest(request, connection); return convertResponse(connection); } throw new HTTPException("This resolver only supports HTTP calls"); }
@Override public synchronized CacheItem get(HTTPRequest request) { Connection connection = getConnection(); PreparedStatement statement = null; ResultSet rs = null; try { statement = connection.prepareStatement("select * from response where uri = ?"); statement.setString(1, request.getRequestURI().toString()); rs = statement.executeQuery(); while (rs.next()) { CacheItemHolder holder = mapper.mapRow(rs); if (holder.getVary().matches(request)) { return holder.getCacheItem(); } } } catch (SQLException e) { throw new DataAccessException(e); } finally { JdbcUtil.close(rs); JdbcUtil.close(statement); JdbcUtil.close(connection); } return null; }
public void afterSuccessfulAuthentication(HTTPRequest request, Headers responseHeaders) { HTTPHost host = new HTTPHost(request.getRequestURI()); if (registry.matches(host)) { AuthScheme scheme = registry.get(host); Pair<AuthenticatorStrategy, AuthScheme> select = select(Arrays.asList(scheme)); AuthScheme updatedScheme = select.getKey().afterSuccessfulAuthentication(scheme, responseHeaders); if (updatedScheme != scheme) { registry.register(host, updatedScheme); } } }
public HTTPRequest copy() { return new HTTPRequest( getRequestURI(), getMethod(), getHeaders(), getChallenge(), getPayload() ); }
private HTTPRequest doAuth(HTTPRequest request, List<AuthScheme> schemes) { if (!configuration.isHostIgnored(request.getRequestURI().getHost())) { Pair<AuthenticatorStrategy,AuthScheme> selected = select(schemes); if (selected.getValue() != null) { HTTPRequest req = selected.getKey().prepareWithProxy(request, proxyChallenge, selected.getValue()); if (req != request) { registry.register(configuration.getHost(), selected.getValue()); } return req; } } return request; }
public static MutableRequest fromHTTPRequest(HTTPRequest request) { MutableRequest mutableRequest = new MutableRequest( request.getRequestURI(), request.getMethod(), new MutableHeaders(request.getHeaders()), new MutableConditionals(request.getHeaders().getConditionals()) ); mutableRequest.setChallenge(request.getChallenge().orElse(null)); if (request.getMethod().canHavePayload()) { mutableRequest.setPayload(request.getPayload().orElse(null)); } return mutableRequest; }
public final HTTPRequest prepareAuthentication(final HTTPRequest request, final HTTPResponse response) { HTTPRequest req = request; HTTPHost host = new HTTPHost(request.getRequestURI()); if (response == null && registry.matches(host)) { //preemptive auth. AuthScheme authScheme = registry.get(host); Pair<AuthenticatorStrategy, AuthScheme> selected = select(Arrays.asList(authScheme)); return selected.getKey().prepare(request, authScheme); } if (response != null && response.getStatus() == Status.UNAUTHORIZED) { List<AuthScheme> schemes = toAuthSchemes(response, HeaderConstants.WWW_AUTHENTICATE); if (!schemes.isEmpty() && request.getChallenge() != null) { Pair<AuthenticatorStrategy, AuthScheme> selected = select(schemes); if (selected.getValue() != null) { req = selected.getKey().prepare(request, selected.getValue()); if (req != request) { //If authentication header was added registry.register(host, selected.getValue()); } } } } return req; }
private HTTPRequest prepare(final HTTPRequest request, Challenge challenge, AuthScheme scheme, boolean proxy) { Digest digest = new Digest(new HTTPHost(request.getRequestURI()), scheme); HTTPRequest req = request; if (challenge instanceof UsernamePasswordChallenge) { UsernamePasswordChallenge upc = (UsernamePasswordChallenge) challenge; RequestDigest requestDigest = RequestDigest.newInstance(upc, req, digest); Header authHeader; if (proxy) { authHeader = new Header(HeaderConstants.PROXY_AUTHORIZATION, requestDigest.toHeaderValue()); } else { authHeader = new Header(HeaderConstants.AUTHORIZATION, requestDigest.toHeaderValue()); } req = req.addHeader(authHeader); } return req; }