/** * Sends correct headers to require basic authentication for the given realm. */ public static void requireAuthentication(final HttpServletResponse resp, final String realm) throws IOException { resp.setHeader(WWW_AUTHENTICATE, "Basic realm=\"" + realm + '\"'); resp.sendError(HttpServletResponse.SC_UNAUTHORIZED); }
/** * Trigger a browser redirect with specific http 3XX status code. * * @param location Where to redirect permanently * @param httpStatusCode the http status code */ public void redirect(String location, int httpStatusCode) { if (LOG.isDebugEnabled()) { LOG.debug("Redirecting ({} to {}", httpStatusCode, location); } response.setStatus(httpStatusCode); response.setHeader("Location", location); response.setHeader("Connection", "close"); try { response.sendError(httpStatusCode); } catch (IOException e) { LOG.warn("Exception when trying to redirect permanently", e); } }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { if (Strings.isNullOrEmpty(req.getPathInfo())) { try (final PrintWriter output = resp.getWriter()) { resp.setContentType(CONTENT_TYPE); getTasks().stream() .map(Task::getName) .sorted() .forEach(output::println); } } else if (tasks.containsKey(req.getPathInfo())) { resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED); } else { resp.sendError(HttpServletResponse.SC_NOT_FOUND); } }
@Override protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException { try { resp.setContentType(JSON_MIME_TYPE); resp.getOutputStream() .println(new GsonBuilder() .setPrettyPrinting() .create() .toJson(this.statusService.getStatus())); resp.setStatus(HttpServletResponse.SC_OK); } catch (final Exception e) { log.error("Error!! while reporting status: ", e); resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage()); } finally { resp.getOutputStream().close(); } } }
if (resultSet.next()) { byte[] content = resultSet.getBytes("content"); response.setContentType(getServletContext().getMimeType(imageName)); response.setContentLength(content.length); response.getOutputStream().write(content); } else { response.sendError(HttpServletResponse.SC_NOT_FOUND); // 404.
public static boolean doXsrfFilter(ServletRequest request, ServletResponse response, Set<String> methodsToIgnore, String headerName) throws IOException, ServletException { HttpServletRequest httpRequest = (HttpServletRequest)request; if (methodsToIgnore == null) { methodsToIgnore = XSRF_METHODS_TO_IGNORE_DEFAULT ; } if (headerName == null ) { headerName = XSRF_HEADER_DEFAULT; } if (methodsToIgnore.contains(httpRequest.getMethod()) || httpRequest.getHeader(headerName) != null) { return true; } else { ((HttpServletResponse)response).sendError( HttpServletResponse.SC_BAD_REQUEST, "Missing Required Header for Vulnerability Protection"); response.getWriter().println( "XSRF filter denial, requests must contain header : " + headerName); return false; } }
if (resource == null) { logger.debug("Resource not found"); response.sendError(HttpServletResponse.SC_NOT_FOUND); return; response.setHeader("Allow", getAllowHeader()); return; if (request.getHeader(HttpHeaders.RANGE) == null) { Assert.state(this.resourceHttpMessageConverter != null, "Not initialized"); setHeaders(response, resource, mediaType); response.setHeader(HttpHeaders.ACCEPT_RANGES, "bytes"); ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(request); try { List<HttpRange> httpRanges = inputMessage.getHeaders().getRange(); response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT); this.resourceRegionHttpMessageConverter.write( HttpRange.toResourceRegions(httpRanges, resource), mediaType, outputMessage); response.setHeader("Content-Range", "bytes */" + resource.contentLength()); response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
/** * Set the response status according to the {@link ResponseStatus} annotation. */ private void setResponseStatus(ServletWebRequest webRequest) throws IOException { HttpStatus status = getResponseStatus(); if (status == null) { return; } HttpServletResponse response = webRequest.getResponse(); if (response != null) { String reason = getResponseStatusReason(); if (StringUtils.hasText(reason)) { response.sendError(status.value(), reason); } else { response.setStatus(status.value()); } } // To be picked up by RedirectView webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status); }
public void handle(String s, Request r, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { if ("POST".equalsIgnoreCase(request.getMethod())) { String p = request.getParameter("test"); if (isNonEmpty(p)) { response.setStatus(HttpServletResponse.SC_OK); response.addHeader("X-Param", p); } else { response.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE); } } else { // this handler is to handle POST request response.sendError(HttpServletResponse.SC_FORBIDDEN); } response.getOutputStream().flush(); response.getOutputStream().close(); } }
@Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { requestHandler.handleRequest(new DataInputStream(request.getInputStream()), new DataOutputStream(response.getOutputStream())); } catch(Exception e) { logger.error("Uncaught exception in store servlet:", e); response.sendError(HttpURLConnection.HTTP_UNAVAILABLE, e.getMessage()); } }
builder.contentLength(payload.size()); String storageClass = request.getHeader("x-amz-storage-class"); if (storageClass == null || storageClass.equalsIgnoreCase("STANDARD")) { String cannedAcl = request.getHeader("x-amz-acl"); if (cannedAcl == null || cannedAcl.equalsIgnoreCase("private")) { access = BlobAccess.PRIVATE; throw new S3Exception(S3ErrorCode.NOT_IMPLEMENTED); } else { response.sendError(HttpServletResponse.SC_BAD_REQUEST); return; try (Writer writer = response.getWriter()) { response.setContentType(XML_CONTENT_TYPE); XMLStreamWriter xml = xmlOutputFactory.createXMLStreamWriter( writer);
@Test public void testNoFileFound() throws IOException { HttpServletResponse mockResponse = mock(HttpServletResponse.class); JdbcJarDownloadServlet servlet = new JdbcJarDownloadServlet(); servlet.doGet(null, mockResponse); verify(mockResponse, times(1)).setHeader( "Content-disposition","attachment; filename=hive-jdbc-standalone.jar"); verify(mockResponse, times(1)).setContentType("application/java-archive"); verify(mockResponse, times(1)).sendError(HttpServletResponse.SC_NOT_FOUND); } }
@Override public void render(final RequestContext context) { final HttpServletResponse response = context.getResponse(); response.setContentType("text/html"); response.setCharacterEncoding("UTF-8"); writer = response.getWriter(); } catch (final Exception e) { try { writer = new PrintWriter(response.getOutputStream()); } catch (final IOException ex) { LOGGER.log(Level.ERROR, "Can not get response writer", ex); response.sendError(HttpServletResponse.SC_NOT_FOUND); } catch (final IOException ex) { LOGGER.log(Level.ERROR, "Can not send error 404!", ex); response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } catch (final IOException ex) { LOGGER.log(Level.ERROR, "Sends error 500 failed", ex);
response.setStatus(HttpServletResponse.SC_FORBIDDEN); return; String authName = request.getHeader(AbstractEurekaIdentity.AUTH_NAME_HEADER_KEY); String authVersion = request.getHeader(AbstractEurekaIdentity.AUTH_VERSION_HEADER_KEY); String authId = request.getHeader(AbstractEurekaIdentity.AUTH_ID_HEADER_KEY); response.sendError(HttpServletResponse.SC_NOT_FOUND, "Request path: " + pathInfo + " not supported by eureka resource mock.");
public void handle(HttpServletRequest request, HttpServletResponse response, String message, HttpStatus httpStatus) throws IOException { if (API_REQUEST_MATCHER.matches(request)) { response.setStatus(HttpStatus.BAD_REQUEST.value()); final ContentTypeAwareResponse contentTypeAwareResponse = CONTENT_TYPE_NEGOTIATION_MESSAGE_HANDLER.getResponse(request); response.setCharacterEncoding("utf-8"); response.setContentType(contentTypeAwareResponse.getContentType().toString()); response.getOutputStream().print(contentTypeAwareResponse.getFormattedMessage(message)); } else { response.sendError(httpStatus.value(), message); } } }
private void doHsErrPid(HttpServletResponse httpResponse, List<JavaInformations> javaInformationsList, String path) throws IOException { for (final JavaInformations javaInformations : javaInformationsList) { for (final HsErrPid hsErrPid : javaInformations.getHsErrPidList()) { if (hsErrPid.getFile().replace('\\', '/').equals(path) && new File(path).exists()) { final File file = new File(path); final OutputStream out = httpResponse.getOutputStream(); httpResponse.setContentType("text/plain"); // attachment et non inline pour proposer le téléchargement et non l'affichage direct dans le navigateur httpResponse.addHeader("Content-Disposition", "attachment;filename=" + file.getName()); InputOutput.pumpFromFile(file, out); return; } } } // si le fichier demandé n'est pas dans la liste des fichiers hs_err_pid*.log, // alors il n'existe plus ou alors le fichier demandé est une invention malveillante httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND); }
@Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { LOG.info("POST"); resp.setContentType("text/html"); PrintWriter out = resp.getWriter(); Reconfigurable reconf = getReconfigurable(req); String nodeName = reconf.getClass().getCanonicalName(); printHeader(out, nodeName); try { applyChanges(out, reconf, req); } catch (ReconfigurationException e) { resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, StringUtils.stringifyException(e)); return; } out.println("<p><a href=\"" + req.getServletPath() + "\">back</a></p>"); printFooter(out); }
@Override public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException { HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) resp; String token = request.getHeader("Authorization"); Long consumerId = consumerAuthUtil.getConsumerId(token); if (consumerId == null) { response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); return; } consumerAuthUtil.storeConsumerId(request, consumerId); consumerAuditUtil.audit(request, consumerId); chain.doFilter(req, resp); }
if (resource == null) { logger.debug("Resource not found"); response.sendError(HttpServletResponse.SC_NOT_FOUND); return; response.setHeader("Allow", getAllowHeader()); return; if (request.getHeader(HttpHeaders.RANGE) == null) { Assert.state(this.resourceHttpMessageConverter != null, "Not initialized"); setHeaders(response, resource, mediaType); response.setHeader(HttpHeaders.ACCEPT_RANGES, "bytes"); ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(request); try { List<HttpRange> httpRanges = inputMessage.getHeaders().getRange(); response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT); this.resourceRegionHttpMessageConverter.write( HttpRange.toResourceRegions(httpRanges, resource), mediaType, outputMessage); response.setHeader("Content-Range", "bytes */" + resource.contentLength()); response.sendError(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);