/** * Returns the full URL of the given request. * * @param request an HTTP servlet request * @return the full URL, including the query string */ public static String getFullUrl(HttpServletRequest request) { if (request.getQueryString() == null) { return request.getRequestURI(); } return request.getRequestURI() + "?" + request.getQueryString(); } }
/** * Constructs a new instance from the given HTTP request. * * @param request the current request to save. */ public SavedRequest(HttpServletRequest request) { this.method = request.getMethod(); this.queryString = request.getQueryString(); this.requestURI = request.getRequestURI(); }
/** * @return part of request URL after servlet path */ private static String getPluginKeyAndResourcePath(HttpServletRequest request) { return StringUtils.substringAfter(request.getRequestURI(), request.getContextPath() + request.getServletPath() + "/"); }
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String contextPath = request.getContextPath(); String servletPath = request.getServletPath(); String requestURI = request.getRequestURI(); if (request.getQueryString() != null && request.getQueryString().length() > 0) { fullUrl += "?" + request.getQueryString();
void insertIntoMDC(ServletRequest request) { MDC.put(ClassicConstants.REQUEST_REMOTE_HOST_MDC_KEY, request.getRemoteHost()); if (request instanceof HttpServletRequest) { HttpServletRequest httpServletRequest = (HttpServletRequest) request; MDC.put(ClassicConstants.REQUEST_REQUEST_URI, httpServletRequest.getRequestURI()); StringBuffer requestURL = httpServletRequest.getRequestURL(); if (requestURL != null) { MDC.put(ClassicConstants.REQUEST_REQUEST_URL, requestURL.toString()); } MDC.put(ClassicConstants.REQUEST_METHOD, httpServletRequest.getMethod()); MDC.put(ClassicConstants.REQUEST_QUERY_STRING, httpServletRequest.getQueryString()); MDC.put(ClassicConstants.REQUEST_USER_AGENT_MDC_KEY, httpServletRequest.getHeader("User-Agent")); MDC.put(ClassicConstants.REQUEST_X_FORWARDED_FOR, httpServletRequest.getHeader("X-Forwarded-For")); } }
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest req = (HttpServletRequest) request; /* allow signup from the Jenkins home page, or /manage, which is where a /configureSecurity form redirects to */ if(req.getRequestURI().equals(req.getContextPath()+"/") || req.getRequestURI().equals(req.getContextPath() + "/manage")) { if (needsToCreateFirstUser()) { ((HttpServletResponse)response).sendRedirect("securityRealm/firstUser"); } else {// the first user already created. the role of this filter is over. PluginServletFilter.removeFilter(this); chain.doFilter(request,response); } } else chain.doFilter(request,response); }
putAttribute(attributes, HTTPUtils.HTTP_CONTEXT_ID, contextIdentifier); putAttribute(attributes, "mime.type", request.getContentType()); putAttribute(attributes, "http.servlet.path", request.getServletPath()); putAttribute(attributes, "http.context.path", request.getContextPath()); putAttribute(attributes, "http.method", request.getMethod()); putAttribute(attributes, "http.local.addr", request.getLocalAddr()); putAttribute(attributes, HTTPUtils.HTTP_LOCAL_NAME, request.getLocalName()); final String queryString = request.getQueryString(); if (queryString != null) { putAttribute(attributes, "http.query.string", URLDecoder.decode(queryString, charset)); putAttribute(attributes, "http.remote.user", request.getRemoteUser()); putAttribute(attributes, "http.protocol", request.getProtocol()); putAttribute(attributes, HTTPUtils.HTTP_REQUEST_URI, request.getRequestURI()); putAttribute(attributes, "http.request.url", request.getRequestURL().toString()); putAttribute(attributes, "http.auth.type", request.getAuthType()); while (headerNames.hasMoreElements()) { final String headerName = headerNames.nextElement(); final String headerValue = request.getHeader(headerName); putAttribute(attributes, "http.headers." + headerName, headerValue);
private boolean requestIsOfType(String type, HttpServletRequest request) { String header = request.getHeader("Accept"); String contentType = request.getContentType(); String url = request.getRequestURI(); return header != null && header.contains(type) || url != null && url.endsWith(type) || contentType != null && contentType.contains(type); }
public String getRequestInfo(HttpServletRequest request) { return String.format("URI: %s; Scheme: %s; Host: %s; Port: %s; Origin: %s; Method: %s", request.getRequestURI(), request.getScheme(), request.getServerName(), request.getServerPort(), request.getHeader("Origin"), request.getMethod()); }
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { final HttpSession session = request.getSession(); LOGGER.debug("Session info for url: {}, Current session: {}, Requested session id: {}", request.getRequestURI(), session.getId(), request.getRequestedSessionId()); filterChain.doFilter(request, response); }
contentLength = request.getContentLength(); contentType = request.getContentType(); contextPath = request.getContextPath(); cookies = request.getCookies(); requestHeaderNames = request.getHeaderNames(); localName = request.getLocalName(); localPort = request.getLocalPort(); method = request.getMethod(); pathInfo = request.getPathInfo(); pathTranslated = request.getPathTranslated(); protocol = request.getProtocol(); queryString = request.getQueryString(); remoteAddr = request.getRemoteAddr(); remoteHost = request.getRemoteHost(); remotePort = request.getRemotePort(); remoteUser = request.getRemoteUser(); requestURI = request.getRequestURI(); requestURL = request.getRequestURL(); requestedSessionId = request.getRequestedSessionId(); serverName = request.getServerName(); serverPort = request.getServerPort(); servletPath = request.getServletPath(); if (request.isRequestedSessionIdValid()) { session = request.getSession();
@Override public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { String uri = request.getRequestURI(); HessianSkeleton skeleton = skeletonMap.get(uri); if (!request.getMethod().equalsIgnoreCase("POST")) { response.setStatus(500); } else { RpcContext.getContext().setRemoteAddress(request.getRemoteAddr(), request.getRemotePort()); Enumeration<String> enumeration = request.getHeaderNames(); while (enumeration.hasMoreElements()) { String key = enumeration.nextElement(); if (key.startsWith(Constants.DEFAULT_EXCHANGER)) { RpcContext.getContext().setAttachment(key.substring(Constants.DEFAULT_EXCHANGER.length()), request.getHeader(key)); } } try { skeleton.invoke(request.getInputStream(), response.getOutputStream()); } catch (Throwable e) { throw new ServletException(e); } } }
public ActionEnter(HttpServletRequest request, String rootPath) { this.request = request; this.rootPath = rootPath; this.actionType = request.getParameter("action"); this.contextPath = request.getContextPath(); this.configManager = ConfigManager.getInstance(this.rootPath, this.contextPath, request.getRequestURI()); }
public boolean matches(HttpServletRequest request) { String uri = request.getRequestURI(); String query = request.getQueryString(); if (query != null) { uri += "?" + query; } if ("".equals(request.getContextPath())) { return uri.equals(processUrl); } return uri.equals(request.getContextPath() + processUrl); }
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws IOException, ServletException { if (request.getMethod().equals("GET") || request.getMethod().equals("HEAD")) { LOGGER.debug("Saving request {}", request.getRequestURI()); SessionUtils.saveRequest(request); } filterChain.doFilter(request, response); } }
@VisibleForTesting Request asApolloRequest(HttpServletRequest req) throws IOException { final String uri = req.getRequestURI() + (req.getQueryString() == null ? "" : "?" + req.getQueryString()); final String method = req.getMethod(); final int contentLength = req.getContentLength(); final ImmutableMap.Builder<String, String> headersBuilder = ImmutableMap.builder(); toStream(req.getHeaderNames()) .forEachOrdered( name -> headersBuilder.put( name, toStream(req.getHeaders(name)).collect(Collectors.joining(",")) )); final ImmutableMap<String, String> headers = headersBuilder.build(); Request request = Request.forUri(uri, method).withHeaders(headers); final Optional<String> callingService = request.header("X-Calling-Service"); if (callingService.isPresent() && !callingService.get().isEmpty()) { request = request.withService(callingService.get()); } Optional<ByteString> payload = readPayload(req, contentLength); if (payload.isPresent()) { request = request.withPayload(payload.get()); } return request; }
@Override public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { String uri = request.getRequestURI(); HttpInvokerServiceExporter skeleton = skeletonMap.get(uri); if (!request.getMethod().equalsIgnoreCase("POST")) { response.setStatus(500); } else { RpcContext.getContext().setRemoteAddress(request.getRemoteAddr(), request.getRemotePort()); try { skeleton.handleRequest(request, response); } catch (Throwable e) { throw new ServletException(e); } } }
private static boolean shouldRequestBeChecked(HttpServletRequest request) { if (UPDATE_METHODS.contains(request.getMethod())) { String path = request.getRequestURI().replaceFirst(request.getContextPath(), ""); return path.startsWith(API_URL); } return false; }
String requestFullPath = StringUtils.defaultString(theRequest.getRequestURI()); String servletPath = StringUtils.defaultString(theRequest.getServletPath()); StringBuffer requestUrl = theRequest.getRequestURL(); String servletContextPath = IncomingRequestAddressStrategy.determineServletContextPath(theRequest, this); if (isNotBlank(theRequest.getQueryString())) { completeUrl = requestUrl + "?" + theRequest.getQueryString(); String contentType = theRequest.getHeader(Constants.HEADER_CONTENT_TYPE); if (theRequestType == RequestTypeEnum.POST && isNotBlank(contentType) && contentType.startsWith(Constants.CT_X_FORM_URLENCODED)) { String requestBody = new String(requestDetails.loadRequestContents(), Constants.CHARSET_UTF8); params = UrlUtil.parseQueryStrings(theRequest.getQueryString(), requestBody); } else if (theRequestType == RequestTypeEnum.GET) { params = UrlUtil.parseQueryString(theRequest.getQueryString()); if (isNotBlank(theRequest.getHeader(Constants.HEADER_CONTENT_ENCODING))) { if (isNotBlank(theRequest.getQueryString())) { params = UrlUtil.parseQueryString(theRequest.getQueryString()); String contentLocation = theRequest.getHeader(Constants.HEADER_CONTENT_LOCATION); if (contentLocation != null) { id = myFhirContext.getVersion().newIdType();
private void verifyNoRedirection(String requestUrl, @Nullable String queryString) throws IOException, ServletException { when(request.getRequestURI()).thenReturn(requestUrl); when(request.getQueryString()).thenReturn(queryString); when(request.getParameter(anyString())).thenReturn(null); underTest.doFilter(request, response, chain); verify(chain).doFilter(request, response); verifyZeroInteractions(response); reset(response, chain); } }