public HTTPRequest copy() { return new HTTPRequest( getRequestURI(), getMethod(), getHeaders(), getChallenge(), getPayload() ); }
/** * Returns all headers with the headers from the Payload * * @return All the headers */ public Headers getAllHeaders() { Headers requestHeaders = getHeaders(); requestHeaders = hasPayload() ? requestHeaders.withContentType(getPayload().get().getMimeType()) : requestHeaders; //We don't want to add headers more than once. return requestHeaders; }
public HTTPRequest prepare(HTTPRequest request, AuthScheme scheme) { HTTPRequest req = request; Challenge challenge = request.getChallenge().orElse(null); if (challenge instanceof BearerTokenChallenge) { BearerTokenChallenge token = (BearerTokenChallenge) challenge; req = req.addHeader(HeaderConstants.AUTHORIZATION, token.getToken().toHeaderValue()); } return req; }
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 void write(PrintStream stream, HTTPRequest request) { writeRequestLine(stream, request); Headers all = request.getAllHeaders(); all = all.add(HeaderUtils.toHttpDate("Date", LocalDateTime.now())); all = all.add("Connection", "close"); writeHeaders(stream, all); if (request.hasPayload()) { writeBody(stream, request.getPayload()); } stream.print("\r\n"); stream.flush(); }
public void afterFailedAuthentication(HTTPRequest request, Headers responseHeaders) { HTTPHost host = new HTTPHost(request.getRequestURI()); registry.remove(host); } }
private static Vary determineVariation(Headers responseHeaders, HTTPRequest request) { Headers requestHeaders = request.getAllHeaders(); Optional<String> varyHeader = responseHeaders.getFirstHeaderValue(VARY); Map<String, String> resolvedVaryHeaders = new HashMap<String, String>(); if (varyHeader.isPresent()) { String varyValue = varyHeader.get(); if (varyValue.equals("*")) { return Vary.ALL; } String[] varies = varyValue.split(","); for (String vary : varies) { Optional<String> value = requestHeaders.getFirstHeaderValue(vary); value.ifPresent(s -> resolvedVaryHeaders.put(vary, s)); } } if (request.getChallenge().isPresent() && Boolean.getBoolean("Vary.authorization")) { resolvedVaryHeaders.put(HeaderConstants.AUTHORIZATION, request.getChallenge().get().getIdentifier()); } return new Vary(resolvedVaryHeaders); }
private void doRequest(HTTPRequest request, HttpURLConnection connection) throws IOException { configureConnection(connection); connection.setRequestMethod(request.getMethod().getMethod()); Headers requestHeaders = request.getAllHeaders(); connection.addRequestProperty(HeaderConstants.USER_AGENT, getConfiguration().getUserAgent()); for (Header header : requestHeaders) { connection.addRequestProperty(header.getName(), header.getValue()); } connection.connect(); writeRequest(request, connection); }
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 void writeRequest(HTTPRequest request, HttpURLConnection connection) throws IOException { if (request.hasPayload()) { InputStream requestStream = request.getPayload().getInputStream(); OutputStream connectionStream = null; try { if (getConfiguration().isUseChunked()) { connection.setChunkedStreamingMode(2048); } connectionStream = connection.getOutputStream(); IOUtils.copy(requestStream, connectionStream); } finally { IOUtils.closeQuietly(requestStream); IOUtils.closeQuietly(connectionStream); } } }
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; }
synchronized Optional<Pair<Key, CacheItem>> getItem(HTTPRequest request) { File uri = fileManager.resolve(request.getNormalizedURI()); if (uri.exists()) { DirectoryStream<Path> paths = getMetadata(uri); Stream<Path> stream = StreamSupport.stream(paths.spliterator(), false); return stream.map(f -> readItem(f.toFile())).filter(p -> p != null && p.getKey().getVary().matches(request)).findFirst(); } return Optional.empty(); }
public HTTPRequest prepare(HTTPRequest request, AuthScheme scheme) { return prepare(request, request.getChallenge().orElse(null), scheme, false); }
public HTTPRequest withMethod(HTTPMethod method) { Objects.requireNonNull(method, "You may not set null method"); if (method == this.method) return this; return new HTTPRequest(requestURI, method, headers, challenge, payload); }
private HTTPRequest prepare(final HTTPRequest request, Challenge challenge, boolean proxy) { HTTPRequest req = request; if (challenge instanceof UsernamePasswordChallenge) { UsernamePasswordChallenge upc = (UsernamePasswordChallenge) challenge; String authValue = BasicAuthentication.getHeaderValue(upc); if (proxy) { req = request.addHeader(HeaderConstants.PROXY_AUTHORIZATION, authValue); } else { req = request.addHeader(HeaderConstants.AUTHORIZATION, authValue); } } return req; }
public boolean canAuthenticatePreemptively(HTTPRequest request) { return canAuthenticatePreemptively(new HTTPHost(request.getRequestURI())); }
public static RequestDigest newInstance(UsernamePasswordChallenge challenge, HTTPRequest request, Digest digest) { return new RequestDigest(challenge, request.getMethod(), URI.create(request.getRequestURI().getRawPath()), digest); }
/** * Analyses the headers in the given request to figure out if this {@link Vary variation} matches. * * @param request the request to analyse * @return {@code true} if the request matches the variance. {@code false} if not. */ //todo: cleanup this public boolean matches(final HTTPRequest request) { if (varyHeaders.containsKey("ALL")) return false; Headers headers = request.getAllHeaders(); for (Map.Entry<String, String> varyEntry : varyHeaders.entrySet()) { if (request.getChallenge().isPresent() && varyEntry.getKey().equals(HeaderConstants.AUTHORIZATION)) { if (!request.getChallenge().get().getIdentifier().equals(varyEntry.getValue())) { return false; } } else { List<Header> requestHeaderValue = headers.getHeaders(varyEntry.getKey()); boolean valid = requestHeaderValue.isEmpty() ? varyEntry.getValue() == null : headers.getFirstHeader(varyEntry.getKey()).get().getValue().equals(varyEntry.getValue()); if (!valid) { return false; } } } List<Preference> preferences = new ArrayList<>(); preferences.addAll(headers.getAccept()); preferences.addAll(headers.getAcceptCharset()); preferences.addAll(headers.getAcceptLanguage()); return !(varyHeaders.isEmpty() && !preferences.isEmpty()); }
public static Key create(HTTPRequest request, HTTPResponse response) { URI uri = request.getNormalizedURI(); return new Key(uri, determineVariation(response.getHeaders(), request)); }
public HTTPRequest prepare(HTTPRequest request, AuthScheme scheme) { return prepare(request, request.getChallenge().orElse(null), false); }