@Override public boolean containsKey(Object key) { return (key instanceof String && this.headers.contains((String) key)); }
@Override public boolean containsKey(Object key) { return (key instanceof String && this.headers.contains((String) key)); }
@Override public boolean isPushSupported() { return channel.isPushEnabled() && !exchange.getRequestHeaders().contains(Headers.X_DISABLE_PUSH); }
@Override public boolean resolve(HttpServerExchange value) { if (value.getResponseHeaders().contains(Headers.CONTENT_LENGTH)) { return this.maxContentSize.resolve(value); } return true; }
HttpClientExchange(ClientCallback<ClientExchange> readyCallback, ClientRequest request, HttpClientConnection clientConnection) { this.readyCallback = readyCallback; this.request = request; this.clientConnection = clientConnection; boolean reqContinue = false; if (request.getRequestHeaders().contains(Headers.EXPECT)) { for (String header : request.getRequestHeaders().get(Headers.EXPECT)) { if (header.equals("100-continue")) { reqContinue = true; } } } this.requiresContinue = reqContinue; }
AjpClientExchange(ClientCallback<ClientExchange> readyCallback, ClientRequest request, AjpClientConnection clientConnection) { this.readyCallback = readyCallback; this.request = request; this.clientConnection = clientConnection; boolean reqContinue = false; if (request.getRequestHeaders().contains(Headers.EXPECT)) { for (String header : request.getRequestHeaders().get(Headers.EXPECT)) { if (header.equals("100-continue")) { reqContinue = true; } } } this.requiresContinue = reqContinue; }
@Override public Resource getResource(HttpServerExchange exchange, String path) throws IOException { Resource originalResource = resourceManager.getResource(path); if(exchange.getRequestHeaders().contains(Headers.RANGE)) { //we don't use serve pre compressed resources for range requests return originalResource; } Resource resource = getEncodedResource(exchange, path, originalResource); if(resource == null) { return originalResource; } return resource; }
@Override public void beforeCommit(HttpServerExchange exchange) { if(!exchange.getResponseHeaders().contains(Headers.ACCEPT_RANGES)) { if (exchange.getResponseHeaders().contains(Headers.CONTENT_LENGTH)) { exchange.getResponseHeaders().put(Headers.ACCEPT_RANGES, "bytes"); } else { exchange.getResponseHeaders().put(Headers.ACCEPT_RANGES, "none"); } } }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { if(!exchange.getRequestHeaders().contains(Headers.HOST)) { exchange.getRequestHeaders().put(Headers.HOST, defaultHost + ":" + exchange.getDestinationAddress().getPort()); } next.handleRequest(exchange); } }
private StreamSinkConduit createNextChannel() { if (deflater.finished() && allAreSet(state, WRITTEN_TRAILER)) { //the deflater was fully flushed before we created the channel. This means that what is in the buffer is //all there is int remaining = currentBuffer.getBuffer().remaining(); if (additionalBuffer != null) { remaining += additionalBuffer.remaining(); } if(!exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, Integer.toString(remaining)); } } else { exchange.getResponseHeaders().remove(Headers.CONTENT_LENGTH); } return conduitFactory.create(); }
@Override public void send(final ByteBuffer buffer, final IoCallback callback) { if (inCall) { queue(new ByteBuffer[]{buffer}, callback); return; } else { long responseContentLength = exchange.getResponseContentLength(); if(responseContentLength > 0 && buffer.remaining() > responseContentLength) { callback.onException(exchange, this, UndertowLogger.ROOT_LOGGER.dataLargerThanContentLength(buffer.remaining(), responseContentLength)); return; } if (!exchange.isResponseStarted() && callback == IoCallback.END_EXCHANGE) { if (responseContentLength == -1 && !exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.setResponseContentLength(buffer.remaining()); } } } if (writeBuffer(buffer, callback)) { invokeOnComplete(callback); } }
static void copyHeaders(final HeaderMap to, final HeaderMap from) { long f = from.fastIterateNonEmpty(); HeaderValues values; while (f != -1L) { values = from.fiCurrent(f); if(!to.contains(values.getHeaderName())) { //don't over write existing headers, normally the map will be empty, if it is not we assume it is not for a reason to.putAll(values.getHeaderName(), values); } f = from.fiNextNonEmpty(f); } }
public static void addDateHeaderIfRequired(HttpServerExchange exchange) { HeaderMap responseHeaders = exchange.getResponseHeaders(); if (exchange.getConnection().getUndertowOptions().get(UndertowOptions.ALWAYS_SET_DATE, true) && !responseHeaders.contains(Headers.DATE)) { String dateString = getCurrentDateTime(exchange); responseHeaders.put(Headers.DATE, dateString); } }
@Override public void send(final String data, final Charset charset, final IoCallback callback) { byte[] bytes = data.getBytes(charset); if (inCall) { queue(new ByteBuffer[]{ByteBuffer.wrap(bytes)}, callback); return; }else { long responseContentLength = exchange.getResponseContentLength(); if(responseContentLength > 0 && bytes.length > responseContentLength) { callback.onException(exchange, this, UndertowLogger.ROOT_LOGGER.dataLargerThanContentLength(bytes.length, responseContentLength)); return; } if (!exchange.isResponseStarted() && callback == IoCallback.END_EXCHANGE) { if (responseContentLength == -1 && !exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.setResponseContentLength(bytes.length); } } } try { outputStream.write(bytes); invokeOnComplete(callback); } catch (IOException e) { callback.onException(exchange, this, e); } }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { if (exchange.getRequestHeaders().contains(Headers.CONTENT_TYPE)) { exchange .getResponseHeaders() .put(Headers.CONTENT_TYPE, exchange.getRequestHeaders().get(Headers.CONTENT_TYPE).element()); } else { exchange .getResponseHeaders() .put(Headers.CONTENT_TYPE, contentType); } Handler.next(exchange, next); } }
/** * Upgrade the channel to a raw socket. This method set the response code to 101, and then marks both the * request and response as terminated, which means that once the current request is completed the raw channel * can be obtained from {@link io.undertow.server.protocol.http.HttpServerConnection#getChannel()} * * @throws IllegalStateException if a response or upgrade was already sent, or if the request body is already being * read */ public HttpServerExchange upgradeChannel(final HttpUpgradeListener listener) { if (!connection.isUpgradeSupported()) { throw UndertowMessages.MESSAGES.upgradeNotSupported(); } if(!getRequestHeaders().contains(Headers.UPGRADE)) { throw UndertowMessages.MESSAGES.notAnUpgradeRequest(); } UndertowLogger.REQUEST_LOGGER.debugf("Upgrading request %s", this); connection.setUpgradeListener(listener); setStatusCode(StatusCodes.SWITCHING_PROTOCOLS); getResponseHeaders().put(Headers.CONNECTION, Headers.UPGRADE_STRING); return this; }
@Override public void sendRequest(final ClientRequest request, final ClientCallback<ClientExchange> clientCallback) { if(http2Delegate != null) { http2Delegate.sendRequest(request, clientCallback); return; } if (anyAreSet(state, UPGRADE_REQUESTED | UPGRADED | CLOSE_REQ | CLOSED)) { clientCallback.failed(UndertowClientMessages.MESSAGES.invalidConnectionState()); return; } final HttpClientExchange httpClientExchange = new HttpClientExchange(clientCallback, request, this); boolean ssl = this.connection instanceof SslConnection; if(!ssl && !http2Tried && options.get(UndertowOptions.ENABLE_HTTP2, false) && !request.getRequestHeaders().contains(Headers.UPGRADE)) { //this is the first request, as we want to try a HTTP2 upgrade request.getRequestHeaders().put(new HttpString("HTTP2-Settings"), Http2ClearClientProvider.createSettingsFrame(options, bufferPool)); request.getRequestHeaders().put(Headers.UPGRADE, Http2Channel.CLEARTEXT_UPGRADE_STRING); request.getRequestHeaders().put(Headers.CONNECTION, "Upgrade, HTTP2-Settings"); http2Tried = true; } if (currentRequest == null) { initiateRequest(httpClientExchange); } else { pendingQueue.add(httpClientExchange); } }
@Override public void send(final ByteBuffer[] buffer, final IoCallback callback) { if (inCall) { queue(buffer, callback); return; } else { long responseContentLength = exchange.getResponseContentLength(); if(responseContentLength > 0 && Buffers.remaining(buffer) > responseContentLength) { callback.onException(exchange, this, UndertowLogger.ROOT_LOGGER.dataLargerThanContentLength(Buffers.remaining(buffer), responseContentLength)); return; } if (!exchange.isResponseStarted() && callback == IoCallback.END_EXCHANGE) { if (responseContentLength == -1 && !exchange.getResponseHeaders().contains(Headers.TRANSFER_ENCODING)) { exchange.setResponseContentLength(Buffers.remaining(buffer)); } } } if (!writeBuffer(buffer, callback)) { return; } invokeOnComplete(callback); }
@Override public StreamSinkConduit wrap(final ConduitFactory<StreamSinkConduit> factory, final HttpServerExchange exchange) { if (exchange.getResponseHeaders().contains(Headers.CONTENT_ENCODING)) { //already encoded return factory.create(); } //if this is a zero length response we don't want to encode if (exchange.getResponseContentLength() != 0 && exchange.getStatusCode() != StatusCodes.NO_CONTENT && exchange.getStatusCode() != StatusCodes.NOT_MODIFIED) { EncodingMapping encoding = getEncoding(); if (encoding != null) { exchange.getResponseHeaders().put(Headers.CONTENT_ENCODING, encoding.getName()); if (exchange.getRequestMethod().equals(Methods.HEAD)) { //we don't create an actual encoder for HEAD requests, but we set the header return factory.create(); } else { return encoding.getEncoding().getResponseWrapper().wrap(factory, exchange); } } } return factory.create(); } }