Refine search
/** * Create an HTTPS restlet Server instance matching the given parameters. * * @param port * @param address * @param keystorePath * @param keystorePassword * @param keyPassword */ protected void setupServer(int port, String address, String keystorePath, String keystorePassword, String keyPassword) { Server server = new Server(Protocol.HTTPS,address,port,null); component.getServers().add(server); server.getContext().getParameters().add("keystorePath", keystorePath); server.getContext().getParameters().add("keystorePassword", keystorePassword); server.getContext().getParameters().add("keyPassword", keyPassword); }
public static List<Flash> getFlashes(Request request) { List<Flash> flashes = new LinkedList<Flash>(); Series<Cookie> cookies = request.getCookies(); String flashdrops = cookies.getFirstValue("flashdrop"); if (StringUtils.isBlank(flashdrops)) { return flashes; } for (String dropbox : flashdrops.split(",")) { if(dropbox!=null) { Flash flash = dropboxes.remove(Long.parseLong(dropbox)); if(flash!=null) { flashes.add(flash); } } } return flashes; }
/** * Returns the series of lower-level HTTP headers. Please not that this * method should rarely be used as most HTTP headers are already surfaced by * the Restlet API. The result series can be used to deal with HTTP * extension headers. * * @return The HTTP headers. */ @SuppressWarnings("unchecked") public Series<Header> getHeaders() { Series<Header> headers = (Series<Header>) getAttributes().get(ATTRIBUTE_HEADERS); if (headers == null) { headers = new Series<Header>(Header.class); getAttributes().put(ATTRIBUTE_HEADERS, headers); } return headers; }
private void addHeaderAttribute(ClientResource clientResource, String attrName, String attrValue) { ConcurrentMap<String, Object> attrs = clientResource.getRequest().getAttributes(); Series<Header> headers = (Series<Header>) attrs.get(HeaderConstants.ATTRIBUTE_HEADERS); if (headers == null) { headers = new Series<>(Header.class); Series<Header> prev = (Series<Header>) attrs.putIfAbsent(HeaderConstants.ATTRIBUTE_HEADERS, headers); if (prev != null) { headers = prev; } } headers.add(attrName, attrValue); }
/** * Returns the HTTP headers of the Restlet {@link Request} as {@link Series} . * * @param request * @return Returns the HTTP headers of the Request. */ @SuppressWarnings("unchecked") public static Series<Header> getHttpHeaders(Request request) { Series<Header> headers = (Series<Header>) request.getAttributes().get( HeaderConstants.ATTRIBUTE_HEADERS); if (headers == null) { headers = new Series<Header>(Header.class); request.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, headers); } return headers; }
private void sendXRDSLocation() { ConcurrentMap<String, Object> attribs = getContext().getAttributes(); String id = getQuery().getFirstValue("id"); String xrds = attribs.get("xrds").toString(); String location = (id != null) ? xrds + "?id=" + id : xrds; getLogger().info("XRDS endpoint = " + xrds); @SuppressWarnings("unchecked") Series<Header> headers = (Series<Header>) getResponse().getAttributes() .get(HeaderConstants.ATTRIBUTE_HEADERS); if (headers == null) { headers = new Series<Header>(Header.class); headers.add("X-XRDS-Location", location); getResponse().getAttributes().put( HeaderConstants.ATTRIBUTE_HEADERS, headers); } else { headers.add("X-XRDS-Location", location); } getLogger().info("Sending empty representation."); }
for(String parameter : getContext().getAttributes().keySet()) getContext().getAttributes().get(parameter)); for(Parameter parameter : getContext().getParameters()) this.log.trace("context parameter: <{}> <{}>", parameter.getName(), parameter.getValue()); this.getContext().getParameters().getFirstValue("oasproperties", true, "oas"); this.log.info("Setting up property util using: {}", propertyBundleName); this.propertyUtil = new PropertyUtil(propertyBundleName);
private void validateState(Request request, Form params) throws Exception { String sessionId = request.getCookies().getFirstValue("_state"); String state = (String) getContext().getAttributes().get(sessionId); if (state != null && state.equals(params.getFirstValue(STATE))) { return; } // CSRF detected throw new Exception("The state does not match."); }
private String setupState(Response response) { String sessionId = UUID.randomUUID().toString(); byte[] secret = new byte[20]; random.nextBytes(secret); String state = Base64.encode(secret, false); CookieSetting cs = new CookieSetting("_state", sessionId); response.getCookieSettings().add(cs); getContext().getAttributes().put(sessionId, state); return state; }
protected void setupAuth(Request request) { if (authType == AUTH_TYPE_BASIC) { ChallengeScheme scheme = ChallengeScheme.HTTP_BASIC; ChallengeResponse authentication = new ChallengeResponse(scheme, userName, password); request.setChallengeResponse(authentication); } else if (authType == AUTH_TYPE_SECRET) { Series<Parameter> additionnalHeaders = new Form(); Map<String, String> securityHeaders = PortalSSOAuthenticationProvider.getHeaders(secretToken, userName); for (String hn : securityHeaders.keySet()) { additionnalHeaders.add(hn, securityHeaders.get(hn)); } request.getAttributes().put("org.restlet.http.headers", additionnalHeaders); } }
/** * Unget current authorization session. */ protected void ungetAuthSession() { String sessionId = getCookies().getFirstValue(ClientCookieID); // cleanup cookie. if (sessionId != null && sessionId.length() > 0) { ConcurrentMap<String, Object> attribs = getContext() .getAttributes(); attribs.remove(sessionId); } }
/** * Remove the headers that are mapped to the framework's API from the given message's list of headers. * * @param message * The message to update. */ public static void keepExtensionHeadersOnly(Message message) { Series<Header> headers = message.getHeaders(); Series<Header> extensionHeaders = new Series<Header>(Header.class); for (Header header : headers) { if (!STANDARD_HEADERS.contains(header.getName())) { extensionHeaders.add(header); } } message.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, extensionHeaders); }
@Override public int handle(Request request, Response response, CounterResult counterResult) { Series<Header> headers = response.getHeaders(); headers.set( "X-RateLimit-Remaining", Integer.toString(getLimit(request, counterResult.getCountedValue()) - counterResult.getConsumed())); headers.set( "X-RateLimit-Limit", Integer.toString(getLimit(request, counterResult.getCountedValue()))); headers.set("X-RateLimit-Reset", Long.toString(counterResult.getReset())); response.getAttributes() .put(HeaderConstants.ATTRIBUTE_HEADERS, headers); return super.handle(request, response, counterResult); }
boolean result = equals(ALL) || equals(included); if (getMainType().equals(includedMediaType.getMainType())) { if (getSubType().equals(includedMediaType.getSubType())) { for (int i = 0; result && i < getParameters().size(); i++) { Parameter param = getParameters().get(i); Parameter includedParam = includedMediaType .getParameters().getFirst(param.getName()); result = (includedParam != null && param.getValue() .equals(includedParam.getValue()));
if ("realm".equals(param.getName())) { challenge.setRealm(param.getValue()); } else { challenge.getParameters().add(param); Context.getCurrentLogger() .log(Level.WARNING, "Unable to parse the challenge request header parameter", Context.getCurrentLogger() .log(Level.WARNING, "Unable to parse the challenge request header parameter",
@Override protected void afterHandle(Request request, Response response) { super.afterHandle(request, response); Cookie cookie = request.getCookies().getFirst("Credentials"); if (request.getClientInfo().isAuthenticated() && (cookie == null)) { String identifier = request.getChallengeResponse().getIdentifier(); String secret = new String(request.getChallengeResponse() .getSecret()); CookieSetting cookieSetting = new CookieSetting("Credentials", identifier + "=" + secret); cookieSetting.setAccessRestricted(true); cookieSetting.setPath("/"); cookieSetting.setComment("Unsecured cookie based authentication"); cookieSetting.setMaxAge(30); response.getCookieSettings().add(cookieSetting); } }
/** * Returns the list of request headers. * * @return The list of request headers. */ @Override @SuppressWarnings("unchecked") public Series<Parameter> getRequestHeaders() { if (this.requestHeaders == null) { this.requestHeaders = new Form(); // Copy the headers from the request object String headerName; String headerValue; for (final Enumeration<String> names = getRequest() .getHeaderNames(); names.hasMoreElements();) { headerName = names.nextElement(); for (final Enumeration<String> values = getRequest() .getHeaders(headerName); values.hasMoreElements();) { headerValue = values.nextElement(); this.requestHeaders.add(new Parameter(headerName, headerValue)); } } } return this.requestHeaders; }
/** * Extract the media parameters. Only leave as the quality parameter if * found. Modifies the parameters list. * * @param parameters * All the preference parameters. * @return The media parameters. */ protected Series<Parameter> extractMediaParams(Series<Parameter> parameters) { Series<Parameter> result = null; boolean qualityFound = false; Parameter param = null; if (parameters != null) { result = new Series<Parameter>(Parameter.class); for (final Iterator<Parameter> iter = parameters.iterator(); !qualityFound && iter.hasNext();) { param = iter.next(); if (param.getName().equals("q")) { qualityFound = true; } else { iter.remove(); result.add(param); } } } return result; }
/** * Test method for {@link org.restlet.security.Realm#setParameters(org.restlet.util.Series)}. */ @Test public final void testSetParameters() { Assert.assertEquals(0, this.testRealm.getParameters().size()); final List<Parameter> list = new ArrayList<Parameter>(1); list.add(new Parameter("testName", "123")); this.testRealm.setParameters(new Series<Parameter>(Parameter.class, list)); Assert.assertEquals(1, this.testRealm.getParameters().size()); final Parameter parameter = this.testRealm.getParameters().get(0); Assert.assertEquals("testName", parameter.getName()); Assert.assertEquals("123", parameter.getValue()); }
/** * Returns a list of all the values associated to the parameter name. * * @param name * The parameter name. * @param ignoreCase * Indicates if the name comparison is case sensitive. * @return The list of values. */ public Series<E> subList(String name, boolean ignoreCase) { final Series<E> result = createSeries(null); for (final E param : this) { if (equals(param.getName(), name, ignoreCase)) { result.add(param); } } return result; }