Refine search
/** Decoded parameters to Map. * @param in the stream containing the encoded parameters * @param map the MultiMap to decode into * @param charset the charset to use for decoding * @param maxLength the maximum length of the form to decode * @param maxKeys the maximum number of keys to decode * @throws IOException if unable to decode input stream */ public static void decodeTo(InputStream in, MultiMap<String> map, String charset, int maxLength, int maxKeys) throws IOException { if (charset==null) { if (ENCODING.equals(StandardCharsets.UTF_8)) decodeUtf8To(in,map,maxLength,maxKeys); else decodeTo(in,map,ENCODING,maxLength,maxKeys); } else if (StringUtil.__UTF8.equalsIgnoreCase(charset)) decodeUtf8To(in,map,maxLength,maxKeys); else if (StringUtil.__ISO_8859_1.equalsIgnoreCase(charset)) decode88591To(in,map,maxLength,maxKeys); else if (StringUtil.__UTF16.equalsIgnoreCase(charset)) decodeUtf16To(in,map,maxLength,maxKeys); else decodeTo(in,map,Charset.forName(charset),maxLength,maxKeys); }
decodeUtf8To(content,0,content.length(),map); return; int l=i-mark-1; value = l==0?"": (encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1,i)); mark=i; encoded=false; if (key != null) map.add(key,value); map.add(value,""); if (key!=null) break; key = encoded?decodeString(content,mark+1,i-mark-1,charset):content.substring(mark+1,i); mark=i; encoded=false; value = l==0?"":(encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1)); map.add(key,value); ?decodeString(content,mark+1,content.length()-mark-1,charset) :content.substring(mark+1); if (key != null && key.length() > 0)
/** */ @Override public Object clone() { return new UrlEncoded(this); } }
decodeUtf8To(in,map,maxLength,maxKeys); return; decode88591To(in,map,maxLength,maxKeys); return; decodeUtf16To(in,map,maxLength,maxKeys); return; if (key != null) map.add(key,value); map.add(value,""); if (maxKeys>0 && map.size()>maxKeys) throw new IllegalStateException(String.format("Form with too many keys [%d > %d]",map.size(),maxKeys)); break; int code0=in.read(); int code1=in.read(); output.write(decodeHexChar(code0,code1)); break; default:
public WebSocketSession(URI requestURI, EventDriver websocket, LogicalConnection connection) { if (requestURI == null) { throw new RuntimeException("Request URI cannot be null"); } this.requestURI = requestURI; this.websocket = websocket; this.connection = connection; this.outgoingHandler = connection; this.incomingHandler = websocket; // Get the parameter map (use the jetty MultiMap to do this right) MultiMap<String> params = new MultiMap<>(); String query = requestURI.getQuery(); if (StringUtil.isNotBlank(query)) { UrlEncoded.decodeTo(query,params,StringUtil.__UTF8_CHARSET,-1); } for (String name : params.keySet()) { List<String> valueList = params.getValues(name); String valueArr[] = new String[valueList.size()]; valueArr = valueList.toArray(valueArr); parameterMap.put(name,valueArr); } }
int l=i-mark-1; value = l==0?"": (encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1,i)); mark=i; encoded=false; if (key != null) map.add(key,value); map.add(value,""); if (maxKeys>0 && map.size()>maxKeys) throw new IllegalStateException("Form too many keys"); break; if (key!=null) break; key = encoded?decodeString(content,mark+1,i-mark-1,charset):content.substring(mark+1,i); mark=i; encoded=false; value = l==0?"":(encoded?decodeString(content,mark+1,l,charset):content.substring(mark+1)); map.add(key,value); ?decodeString(content,mark+1,content.length()-mark-1,charset) :content.substring(mark+1); if (key != null && key.length() > 0)
MultiMap<String> parameterMap = new MultiMap<String>(); UrlEncoded.decodeTo(request.getQueryString(), parameterMap, UTF_8); for (Entry<String, String[]> paramEntry : parameterMap.toStringArrayMap().entrySet()) { String[] values = paramEntry.getValue(); for (String value : values) {
public void mergeQueryParameters(String newQuery, boolean updateQueryString) MultiMap<String> newQueryParams = new MultiMap<>(); UrlEncoded.decodeTo(newQuery, newQueryParams, UrlEncoded.ENCODING, -1); oldQueryParams = new MultiMap<>(); UrlEncoded.decodeTo(_queryString, oldQueryParams, getQueryEncoding(), -1); mergedQueryParams = new MultiMap<>(newQueryParams); mergedQueryParams.addAllValues(oldQueryParams);
final String singleEncodedContent = UrlEncoded.decodeString( doubleEncodedContent, 0, doubleEncodedContent.length(), utf8); final MultiMap<String> tempParameters = new MultiMap<String>(); UrlEncoded.decodeTo(singleEncodedContent, tempParameters, utf8, 10); parameters = new HashMap<String, String[]>(); final Iterator<Map.Entry<String, List<String>>> iter = tempParameters .entrySet().iterator(); while (iter.hasNext()) { final Map.Entry<String, List<String>> e = iter.next();
@Override public Map<String, List<String>> getParameterMap() { Map<String,List<String>> paramMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); String query = getQueryString(); MultiMap<String> multimap = new MultiMap<>(); UrlEncoded.decodeTo(query,multimap,StandardCharsets.UTF_8); paramMap.putAll(multimap); return paramMap; }
public void decodeQueryTo(MultiMap<String> parameters, Charset encoding) throws UnsupportedEncodingException { if (_query==null) return; if (encoding==null || StandardCharsets.UTF_8.equals(encoding)) UrlEncoded.decodeUtf8To(_query,parameters); else UrlEncoded.decodeTo(_query,parameters,encoding); }
public void decode(String query) { decodeTo(query,this,ENCODING); }
/** * @return The key values pairs that are in the query string of this url. */ private static MultiMap<String> parseQueryString(String url) { MultiMap<String> res = new MultiMap<String>(); int questionMarkIndex = url.indexOf('?'); if (questionMarkIndex == -1) { return res; } int poundIndex = url.indexOf('#'); if (poundIndex == -1) { poundIndex = url.length(); } UrlEncoded.decodeUtf8To(url, questionMarkIndex+1, poundIndex - questionMarkIndex - 1, res); return res; }
for(Map.Entry<String, List<String>> entry: map.entrySet()) result.append(encodeString(key,charset)); if(equalsForNullValue) result.append('='); result.append('&'); String val=list.get(i); result.append(encodeString(key,charset)); result.append(encodeString(str,charset));
/** Encode MultiMap with % encoding for UTF8 sequences. * @return the MultiMap as a string with % encoding */ public String encode() { return encode(ENCODING,false); }
public static void decodeUtf8To(String query, MultiMap<String> map) { decodeUtf8To(query,0,query.length(),map); }
/** Perform URL encoding. * @param string the string to encode * @return encoded string. */ public static String encodeString(String string) { return encodeString(string,ENCODING); }
/** Decode String with % encoding. * This method makes the assumption that the majority of calls * will need no decoding. * @param encoded the encoded string to decode * @return the decoded string */ public static String decodeString(String encoded) { return decodeString(encoded,0,encoded.length(),ENCODING); }
String uuid = UrlEncoded.encodeString(event.uuid); sb.append("&uuid_").append(index).append("=").append(uuid); String jsonData = UrlEncoded.encodeString(JSONValue.toJSONString(event.data)); sb.append("&data_").append(index).append("=").append(jsonData); + UrlEncoded.decodeString(sb.toString(), 0, sb.length(), StandardCharsets.UTF_8));
@Override public String extractAuthCodeFromAuthResponse(@NonNull String redirectURLwithParams) throws OAuthException { // parse the redirectURL try { URL redirectURLObject = new URL(redirectURLwithParams); UrlEncoded urlEncoded = new UrlEncoded(redirectURLObject.getQuery()); String stateFromRedirectURL = urlEncoded.getValue(STATE, 0); // may contain multiple... if (stateFromRedirectURL == null) { if (persistedParams.state == null) { // This should not happen as the state is usually set return urlEncoded.getValue(CODE, 0); } // else throw new OAuthException(String.format("state from redirectURL is incorrect. Expected: %s Found: %s", persistedParams.state, stateFromRedirectURL)); } else { if (stateFromRedirectURL.equals(persistedParams.state)) { return urlEncoded.getValue(CODE, 0); } // else throw new OAuthException(String.format("state from redirectURL is incorrect. Expected: %s Found: %s", persistedParams.state, stateFromRedirectURL)); } } catch (MalformedURLException e) { throw new OAuthException("Redirect URL is malformed", e); } }