Refine search
@Override public String readAttribute(final HttpServerExchange exchange) { HeaderValues header = exchange.getResponseHeaders().get(responseHeader); if (header == null) { return null; } else if(header.size() == 1) { return header.getFirst(); } StringBuilder sb = new StringBuilder(); sb.append("["); for (int i = 0; i < header.size(); ++i) { if (i != 0) { sb.append(", "); } sb.append(header.get(i)); } sb.append("]"); return sb.toString(); }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { if(exchange.getRequestMethod().equals(Methods.TRACE)) { exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, "message/http"); StringBuilder body = new StringBuilder("TRACE "); body.append(exchange.getRequestURI()); if(!exchange.getQueryString().isEmpty()) { body.append('?'); body.append(exchange.getQueryString()); } body.append(' '); body.append(exchange.getProtocol().toString()); body.append("\r\n"); for(HeaderValues header : exchange.getRequestHeaders()) { for(String value : header) { body.append(header.getHeaderName()); body.append(": "); body.append(value); body.append("\r\n"); } } body.append("\r\n"); exchange.getResponseSender().send(body.toString()); } else { handler.handleRequest(exchange); } }
private void setCorsResponseHeaders(HttpServerExchange exchange) throws Exception { HeaderMap headers = exchange.getRequestHeaders(); if (headers.contains(Headers.ORIGIN)) { if(matchOrigin(exchange, allowedOrigins) != null) { exchange.getResponseHeaders().addAll(ACCESS_CONTROL_ALLOW_ORIGIN, headers.get(Headers.ORIGIN)); exchange.getResponseHeaders().add(Headers.VARY, Headers.ORIGIN_STRING); } } exchange.getResponseHeaders().addAll(ACCESS_CONTROL_ALLOW_METHODS, allowedMethods); HeaderValues requestedHeaders = headers.get(ACCESS_CONTROL_REQUEST_HEADERS); if (requestedHeaders != null && !requestedHeaders.isEmpty()) { exchange.getResponseHeaders().addAll(ACCESS_CONTROL_ALLOW_HEADERS, requestedHeaders); } else { exchange.getResponseHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, Headers.CONTENT_TYPE_STRING); exchange.getResponseHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, Headers.WWW_AUTHENTICATE_STRING); exchange.getResponseHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, Headers.AUTHORIZATION_STRING); } exchange.getResponseHeaders().add(ACCESS_CONTROL_ALLOW_CREDENTIALS, "true"); exchange.getResponseHeaders().add(ACCESS_CONTROL_MAX_AGE, ONE_HOUR_IN_SECONDS); }
@Override public Map<String, String> toSingleValueMap() { Map<String, String> singleValueMap = new LinkedHashMap<>(this.headers.size()); this.headers.forEach(values -> singleValueMap.put(values.getHeaderName().toString(), values.getFirst())); return singleValueMap; }
@Override public String readAttribute(HttpServerExchange exchange) { HeaderValues values = exchange.getResponseHeaders().get(parameter); if (values != null && values.size() > 0) { StringBuilder buffer = new StringBuilder(); for (int i = 0; i < values.size(); i++) { String string = values.get(i); buffer.append(string); if (i + 1 < values.size()) buffer.append(","); } return buffer.toString(); } return null; }
@Override public String readAttribute(final HttpServerExchange exchange) { HeaderValues header = exchange.getRequestHeaders().get(requestHeader); if (header == null) { return null; } else if(header.size() == 1) { return header.getFirst(); } StringBuilder sb = new StringBuilder(); sb.append("["); for (int i = 0; i < header.size(); ++i) { if (i != 0) { sb.append(", "); } sb.append(header.get(i)); } sb.append("]"); return sb.toString(); }
HeaderMap requestHeaders = new HeaderMap(); for(HeaderValues hv : initial.getRequestHeaders()) { requestHeaders.putAll(hv.getHeaderName(), hv); final HttpServerExchange exchange = new HttpServerExchange(connection, requestHeaders, sink.getHeaders(), maxEntitySize); if(initial.getRequestHeaders().contains(Headers.EXPECT)) { HttpContinue.markContinueResponseSent(exchange);
final StringBuilder sb = new StringBuilder(); final SecurityContext sc = exchange.getSecurityContext(); sb.append("\n----------------------------REQUEST---------------------------\n"); sb.append(" URI=" + exchange.getRequestURI() + "\n"); sb.append(" characterEncoding=" + exchange.getRequestHeaders().get(Headers.CONTENT_ENCODING) + "\n"); sb.append(" contentLength=" + exchange.getRequestContentLength() + "\n"); sb.append(" contentType=" + exchange.getRequestHeaders().get(Headers.CONTENT_TYPE) + "\n"); for (HeaderValues header : exchange.getRequestHeaders()) { for (String value : header) { sb.append(" header=" + header.getHeaderName() + "=" + value + "\n"); sb.append(" locale=" + LocaleUtils.getLocalesFromHeader(exchange.getRequestHeaders().get(Headers.ACCEPT_LANGUAGE)) + "\n"); sb.append(" method=" + exchange.getRequestMethod() + "\n"); Map<String, Deque<String>> pnames = exchange.getQueryParameters();
protected String sendRequest(String url, HttpServerExchange exchange, Map<String,List<String>> responseHeaders, String page, String pageSize) throws Exception { URL obj = new URL(url + exchange.getRequestPath() + "?" + exchange.getQueryString().replaceAll(REPLACE_PAGE, "page=" + page).replaceAll(REPLACE_PAGE_SIZE, "pageSize="+pageSize)); HttpURLConnection con = (HttpURLConnection) obj.openConnection(); con.setRequestMethod("GET"); //add request headers exchange.getRequestHeaders().forEach(h -> { con.setRequestProperty(h.getHeaderName().toString(), h.getFirst()); }); log.debugf("Sending 'GET' request to URL : %s", obj); int responseCode = con.getResponseCode(); log.debugf("Response Code : %s", responseCode); Map<String, List<String>> headers = con.getHeaderFields(); headers.forEach((k, v) -> { if (k != null) { responseHeaders.put(k, v); } }); BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream())); String inputLine; StringBuffer response = new StringBuffer(); while ((inputLine = in.readLine()) != null) { response.append(inputLine); } in.close(); return response.toString(); }
public String userAgent() { HeaderValues userAgent = exchange.getRequestHeaders().get(Headers.USER_AGENT); if (userAgent != null && !userAgent.isEmpty()) { return userAgent.getFirst(); } return null; }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { if(!Methods.GET.equals(exchange.getRequestMethod())) { fail(exchange, StatusCodes.METHOD_NOT_ALLOWED, "Only GET is allowed"); exchange.getResponseHeaders().put(Headers.ALLOW,Methods.GET_STRING); } else if(!APPLICATION_JSON.equals(exchange.getRequestHeaders().get(Headers.ACCEPT).getFirst())) { fail(exchange, StatusCodes.NOT_ACCEPTABLE, "Only application/json representations can be retrieved"); } else { try { final T entity=this.provider.getEntity(new Parameters(exchange)); if(entity!=null) { answer(exchange,StatusCodes.OK,APPLICATION_JSON,JsonUtil.marshall(entity)); } else if(APIVersion.v1.equals(this.version)) { answer(exchange,StatusCodes.OK,APPLICATION_JSON,"false"); } else { // API Version must be V2 fail(exchange,StatusCodes.NOT_FOUND,"Unknown resource '%s'",exchange.getRequestURL()); } } catch (final Exception e) { fail(exchange,e,"Upps!!\n%s",Throwables.getStackTraceAsString(e)); } } }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { HeaderValues accept = exchange.getRequestHeaders().get(Headers.ACCEPT); HeaderValues kieContentType = exchange.getRequestHeaders().get("X-KIE-ContentType"); String acceptRequest = ""; if (accept != null) { acceptRequest = accept.stream().collect(Collectors.joining(",")); } String kieContentTypeRequest = ""; if (kieContentType != null) { kieContentTypeRequest = kieContentType.stream().collect(Collectors.joining(",")); } String response = JAXB_RESPONSE; String contentTypeResponse = "application/xml"; if (acceptRequest.toLowerCase().contains("json") || kieContentTypeRequest.toLowerCase().contains("json")) { response = JSON_RESPONSE; contentTypeResponse = "application/json"; } else if (kieContentTypeRequest.toLowerCase().contains("xstream")) { response = XSTREAM_RESPONSE; contentTypeResponse = "application/xml"; } exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, contentTypeResponse); exchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, response.getBytes("UTF-8").length); exchange.getResponseSender().send(response); }
public static void trySaveRequest(final HttpServerExchange exchange, final byte[] buffer, int length) { int maxSize = exchange.getConnection().getUndertowOptions().get(UndertowOptions.MAX_BUFFERED_REQUEST_SIZE, UndertowOptions.DEFAULT_MAX_BUFFERED_REQUEST_SIZE); if (maxSize > 0) { if (length > maxSize) { UndertowLogger.REQUEST_LOGGER.debugf("Request to %s was to large to save", exchange.getRequestURI()); return;//failed to save the request, we just return } //TODO: we should really be used pooled buffers //TODO: we should probably limit the number of saved requests at any given time HeaderMap headers = new HeaderMap(); for (HeaderValues entry : exchange.getRequestHeaders()) { if (entry.getHeaderName().equals(Headers.CONTENT_LENGTH) || entry.getHeaderName().equals(Headers.TRANSFER_ENCODING) || entry.getHeaderName().equals(Headers.CONNECTION)) { continue; } headers.putAll(entry.getHeaderName(), entry); } SavedRequest request = new SavedRequest(buffer, length, exchange.getRequestMethod(), exchange.getRelativePath(), exchange.getRequestHeaders()); final ServletRequestContext sc = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY); HttpSessionImpl session = sc.getCurrentServletContext().getSession(exchange, true); Session underlyingSession; if (System.getSecurityManager() == null) { underlyingSession = session.getSession(); } else { underlyingSession = AccessController.doPrivileged(new HttpSessionImpl.UnwrapSessionAction(session)); } underlyingSession.setAttribute(SESSION_KEY, request); } }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { if (exchange.isInIoThread()) { HeaderValues upgrade = exchange.getRequestHeaders().get(Headers.UPGRADE); if (upgrade != null && upgrade.contains("h2c")) { // reset protocol exchange.setProtocol(Protocols.HTTP_1_1); } exchange.dispatch(this); return; } handler.handle(new UndertowRequest(exchange, config), new UndertowResponse(exchange)); }
private MediaType matchConsumesMime(HttpServerExchange exchange) { HeaderValues bodyContentType = exchange.getRequestHeaders().get(Headers.CONTENT_TYPE); boolean hasContentType = bodyContentType != null && !bodyContentType.isEmpty(); if (hasContentType) { return consumes.match(bodyContentType); } //If no content type is specified, text/plain is used return MediaType.TEXT_PLAIN_TYPE; }
String contentLength = headers.getFirst(Headers.CONTENT_LENGTH); if (contentLength != null) { dataSize = Long.parseLong(contentLength); throw UndertowMessages.MESSAGES.fixedLengthOverflow(); } else if (isWritesShutdown() && !headers.contains(Headers.TRANSFER_ENCODING)) { headers.put(Headers.CONTENT_LENGTH, dataInBuffer); dataSize = dataInBuffer; requestedChunkSize = maxData; } else { headers.put(Headers.TRANSFER_ENCODING, Headers.CHUNKED.toString()); dataSize = -1; requestedChunkSize = 0; for (HttpString name : responseHeaders.getHeaderNames()) { headers += responseHeaders.get(name).size(); putString(buffer, method.toString());
private HttpHandler resolveHandlers(HttpHandler rest, HttpHandler ws, HttpHandler file, List<MappedEndpoint> mappedEndpoints) { PredicateHandler websocketRestResolved = Handlers.predicate(value -> { HeaderValues upgradeHeader = value.getRequestHeaders().get(Headers.UPGRADE); return upgradeHeader != null && upgradeHeader.stream().anyMatch(v -> v.equalsIgnoreCase("websocket")); }, ws, rest); if (file != null) { String[] mappedServices = HandlerUtil.removePathTemplate(mappedEndpoints); Predicate mappedPredicate = Predicates.prefixes(mappedServices); return Handlers.predicate(mappedPredicate, websocketRestResolved, file); } return websocketRestResolved; }
sb.append(" contentLength=" + exchange.getResponseContentLength() + "\n"); sb.append(" contentType=" + exchange.getResponseHeaders().getFirst(Headers.CONTENT_TYPE) + "\n"); Map<String, Cookie> cookies = exchange.getResponseCookies(); if (cookies != null) { for (Cookie cookie : cookies.values()) { for (HeaderValues header : exchange.getResponseHeaders()) { for (String value : header) { sb.append(" header=" + header.getHeaderName() + "=" + value + "\n");
httpServerExchange = new HttpServerExchange(connection, maxEntitySize); httpServerExchange.setRequestScheme(connection.getSslSession() != null ? "https" : "http"); this.httpServerExchange = null; requestStateUpdater.set(this, 1); if(httpServerExchange.getProtocol() == Protocols.HTTP_2_0) { free = handleHttp2PriorKnowledge(pooled, httpServerExchange); return; HeaderValues host = httpServerExchange.getRequestHeaders().get(Headers.HOST); if(host != null && host.size() > 1) { sendBadRequestAndClose(connection.getChannel(), UndertowMessages.MESSAGES.moreThanOneHostHeader()); return; if(requireHostHeader && httpServerExchange.getProtocol().equals(Protocols.HTTP_1_1)) { if(host == null || host.size() ==0 || host.getFirst().isEmpty()) { sendBadRequestAndClose(connection.getChannel(), UndertowMessages.MESSAGES.noHostInHttp11Request()); return;
buffer.put((byte) 0); buffer.put((byte) 4); putInt(buffer, exchange.getStatusCode()); String reason = exchange.getReasonPhrase(); if(reason == null) { reason = StatusCodes.getReason(exchange.getStatusCode()); final HeaderMap responseHeaders = exchange.getResponseHeaders(); for (HttpString name : responseHeaders.getHeaderNames()) { headers += responseHeaders.get(name).size(); for (final HttpString header : responseHeaders.getHeaderNames()) { for (String headerValue : responseHeaders.get(header)) { if(buffer.remaining() < header.length() + headerValue.length() + 6) {