src/main/java/org/apache/sling/engine/impl/parameters/Util.java - sling-org-apache-sling-engine - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.sling.engine.impl.parameters;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.LinkedHashMap;
 import java.util.Map;

 import org.apache.sling.api.request.RequestParameter;

 public class Util {

     // ISO-8859-1 mapps all characters 0..255 to \u0000..\u00ff directly
     public static final String ENCODING_DIRECT = "ISO-8859-1";

     // Default query (and www-form-encoded) parameter encoding as per
     // HTML spec.
     // see http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
     public static final String ENCODING_DEFAULT = "UTF-8";

     public static final byte[] NO_CONTENT = new byte[0];

     // the default encoding used in #fixEncoding if the _charset_ request
     // parameter is not set
     private static String defaultFixEncoding = ENCODING_DIRECT;

     /** Parse state constant */
     private static final int BEFORE_NAME = 0;

     /** Parse state constant */
     private static final int INSIDE_NAME = BEFORE_NAME + 1;

     /** Parse state constant */
     private static final int ESC_NAME = INSIDE_NAME + 1;

     /** Parse state constant */
     private static final int BEFORE_EQU = ESC_NAME + 1;

     /** Parse state constant */
     private static final int BEFORE_VALUE = BEFORE_EQU + 1;

     /** Parse state constant */
     private static final int INSIDE_VALUE = BEFORE_VALUE + 1;

     /** Parse state constant */
     private static final int ESC_VALUE = INSIDE_VALUE + 1;

     /** Parse state constant */
     private static final int AFTER_VALUE = INSIDE_VALUE + 1;

     /** Parse state constant */
     private static final int BEFORE_SEP = AFTER_VALUE + 1;

     public static void setDefaultFixEncoding(final String encoding) {
         defaultFixEncoding = validateEncoding(encoding);
     }

     static String getDefaultFixEncoding() {
         return defaultFixEncoding;
     }

     static String toIdentityEncodedString(byte[] data) {
         if (data == null) {
             return null;
         }

         char[] characters = new char[data.length];
         for (int i = 0; i < characters.length; i++) {
             characters[i] = (char) (data[i] & 0xff);
         }
         return new String(characters);
     }

     static byte[] fromIdentityEncodedString(String string) {
         if (string == null) {
             return NO_CONTENT;
         }

         byte[] data = new byte[string.length()];
         for (int i = 0; i < data.length; i++) {
             data[i] = (byte) (string.charAt(i) & 0xff);
         }
         return data;
     }

     static InputStream toInputStream(String source) {
         byte[] data = fromIdentityEncodedString(source);
         return new ByteArrayInputStream(data);
     }

     static void fixEncoding(ParameterMap parameterMap) {
         // default the encoding to defaultFixEncoding
         String formEncoding = getDefaultFixEncoding();

         // check whether a form encoding parameter overwrites this default
         RequestParameter[] feParm = parameterMap.get(ParameterSupport.PARAMETER_FORMENCODING);
         if (feParm != null) {
             // get and check form encoding
             byte[] rawEncoding = feParm[0].get();
             formEncoding = toIdentityEncodedString(rawEncoding);
             formEncoding = validateEncoding(formEncoding);
         }

         // map for rename parameters due to encoding fixes
         LinkedHashMap<String, String> renameMap = new LinkedHashMap<String, String>();

         // convert the map of lists to a map of arrays
         for (Map.Entry<String, RequestParameter[]> paramEntry : parameterMap.entrySet()) {
             RequestParameter[] params = paramEntry.getValue();
             String parName = null;
             for (int i = 0; i < params.length; i++) {
                 if (params[i] instanceof AbstractRequestParameter) {
                     AbstractRequestParameter param = (AbstractRequestParameter) params[i];

                     // fix encoding if different
                     if (!formEncoding.equalsIgnoreCase(param.getEncoding())) {
                         param.setEncoding(formEncoding);

                         // prepare the parameter for renaming
                         if (parName == null) {
                             parName = paramEntry.getKey();
                             String name = reencode(parName, formEncoding);
                             if (!parName.equals(name)) {
                                 renameMap.put(parName, name);
                             }
                         }
                     }
                 }
             }
         }

         // apply mappings of deinternationalized names
         if (!renameMap.isEmpty()) {
             for (Map.Entry<String, String> entry : renameMap.entrySet()) {
                 parameterMap.renameParameter(entry.getKey(), entry.getValue());
             }
         }
     }

     private static String reencode(String parName, String encoding) {
         // re-encode the parameter to the encoding
         if (!ENCODING_DIRECT.equalsIgnoreCase(encoding)) {
             try {
                 return new String(parName.getBytes(ENCODING_DIRECT), encoding);
             } catch (UnsupportedEncodingException uee) {
                 // unexpected, as the encoding is assumed to have been checked !
             }
         }

         // otherwise just return the name unmodified
         return parName;
     }

     /**
      * Checks whether the given encoding is known and supported by the platform
      * or not. If the platform supports the encoding the parameter is returned.
      * Otherwise or if the encoding argument is <code>null</code> or an empty
      * string {@link #defaultFixEncoding} is returned.
      *
      * @param encoding The encoding to validate
      * @return The encoding if supported or {@link #defaultFixEncoding}
      */
     private static String validateEncoding(final String encoding) {
         if (encoding != null && encoding.length() > 0) {
             // check for the existence of the encoding
             try {
                 "".getBytes(encoding);
                 return encoding;
             } catch (UnsupportedEncodingException e) {
                 // log.warn("HttpMulitpartPost: Character encoding {0} is not "
                 // + "supported, using default {1}", formEncodingParam,
                 // DEFAULT_ENCODING);
             }
         }

         // no encoding or unsupported encoding
         return getDefaultFixEncoding();
     }

     /**
      * Parse a query string and store entries inside a map
      *
      * @param data querystring data
      * @param encoding encoding to use for converting bytes to characters
      * @param map map to populate
      * @param prependNew whether to prepend new values
      * @throws IllegalArgumentException if the nv string is malformed
      * @throws UnsupportedEncodingException if the {@code encoding} is not
      *             supported
      * @throws IOException if an error occurrs reading from {@code data}
      */
     public static void parseQueryString(InputStream data, String encoding, ParameterMap map, boolean prependNew)
             throws UnsupportedEncodingException, IOException {

         parseNVPairString(data, encoding, map, '&', false, prependNew);
     }

     /**
      * Parse a name/value pair string and populate a map with key -> value[s]
      *
      * @param data name value data
      * @param encoding encoding to use for converting bytes to characters
      * @param map map to populate
      * @param separator multi-value separator character
      * @param allowSpaces allow spaces inside name/values
      * @param prependNew whether to prepend new values
      * @throws IllegalArgumentException if the nv string is malformed
      * @throws UnsupportedEncodingException if the {@code encoding} is not
      *             supported
      * @throws IOException if an error occurrs reading from {@code data}
      */
     private static void parseNVPairString(
             InputStream data,
             String encoding,
             ParameterMap map,
             char separator,
             boolean allowSpaces,
             boolean prependNew)
             throws UnsupportedEncodingException, IOException {

         ByteArrayOutputStream keyBuffer = new ByteArrayOutputStream(256);
         ByteArrayOutputStream valueBuffer = new ByteArrayOutputStream(256);
         char[] chCode = new char[2];

         int state = BEFORE_NAME;
         int subState = 0;

         for (int in = data.read(); in >= 0; in = data.read()) {
             char ch = (char) in;

             switch (state) {
                 case BEFORE_NAME:
                     if (ch == ' ') {
                         continue;
                     } else if (ch == '%') {
                         state = ESC_NAME;
                         subState = 0;
                     } else if (ch == '+' && !allowSpaces) {
                         keyBuffer.write(' ');
                         state = INSIDE_NAME;
                     } else {
                         keyBuffer.write(ch);
                         state = INSIDE_NAME;
                     }
                     break;
                 case INSIDE_NAME:
                     if (ch == '=') {
                         state = BEFORE_VALUE;
                     } else if (ch == '+' && !allowSpaces) {
                         keyBuffer.write(' ');
                     } else if (ch == '%') {
                         state = ESC_NAME;
                         subState = 0;
                     } else if (ch == '&') {
                         addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
                         state = BEFORE_NAME;
                     } else {
                         keyBuffer.write(ch);
                     }
                     break;
                 case ESC_NAME:
                     chCode[subState++] = ch;
                     if (subState == chCode.length) {
                         String code = new String(chCode);
                         try {
                             keyBuffer.write(Integer.parseInt(code, 16));
                         } catch (NumberFormatException e) {
                             throw new IllegalArgumentException("Bad escape sequence: %" + code);
                         }
                         state = INSIDE_NAME;
                     }
                     break;
                 case BEFORE_EQU:
                     if (ch == '=') {
                         state = BEFORE_VALUE;
                     }
                     break;
                 case BEFORE_VALUE:
                     if (ch == ' ') {
                         continue;
                     } else if (ch == '%') {
                         state = ESC_VALUE;
                         subState = 0;
                     } else if (ch == '+' && !allowSpaces) {
                         valueBuffer.write(' ');
                         state = INSIDE_VALUE;
                     } else if (ch == separator) {
                         addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
                         state = BEFORE_NAME;
                     } else {
                         valueBuffer.write(ch);
                         state = INSIDE_VALUE;
                     }
                     break;
                 case INSIDE_VALUE:
                     if (ch == separator) {
                         addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
                         state = BEFORE_NAME;
                     } else if (ch == '+' && !allowSpaces) {
                         valueBuffer.write(' ');
                     } else if (ch == '%') {
                         state = ESC_VALUE;
                         subState = 0;
                     } else {
                         valueBuffer.write(ch);
                     }
                     break;
                 case ESC_VALUE:
                     chCode[subState++] = ch;
                     if (subState == chCode.length) {
                         String code = new String(chCode);
                         try {
                             valueBuffer.write(Integer.parseInt(code, 16));
                         } catch (NumberFormatException e) {
                             throw new IllegalArgumentException("Bad escape sequence: %" + code);
                         }
                         state = INSIDE_VALUE;
                     }
                     break;
                 case BEFORE_SEP:
                     if (ch == separator) {
                         state = BEFORE_NAME;
                     }
                     break;
             }
         }

         if (keyBuffer.size() > 0) {
             addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
         }
     }

     private static void addNVPair(
             ParameterMap map,
             ByteArrayOutputStream keyBuffer,
             ByteArrayOutputStream valueBuffer,
             String encoding,
             boolean prependNew)
             throws UnsupportedEncodingException {
         final String key = keyBuffer.toString(encoding);
         final String value = valueBuffer.toString(encoding);
         map.addParameter(new ContainerRequestParameter(key, value, encoding), prependNew);
         keyBuffer.reset();
         valueBuffer.reset();
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.sling.engine.impl.parameters;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.UnsupportedEncodingException;
	import java.util.LinkedHashMap;
	import java.util.Map;

	import org.apache.sling.api.request.RequestParameter;

	public class Util {

	// ISO-8859-1 mapps all characters 0..255 to \u0000..\u00ff directly
	public static final String ENCODING_DIRECT = "ISO-8859-1";

	// Default query (and www-form-encoded) parameter encoding as per
	// HTML spec.
	// see http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
	public static final String ENCODING_DEFAULT = "UTF-8";

	public static final byte[] NO_CONTENT = new byte[0];

	// the default encoding used in #fixEncoding if the _charset_ request
	// parameter is not set
	private static String defaultFixEncoding = ENCODING_DIRECT;

	/** Parse state constant */
	private static final int BEFORE_NAME = 0;

	/** Parse state constant */
	private static final int INSIDE_NAME = BEFORE_NAME + 1;

	/** Parse state constant */
	private static final int ESC_NAME = INSIDE_NAME + 1;

	/** Parse state constant */
	private static final int BEFORE_EQU = ESC_NAME + 1;

	/** Parse state constant */
	private static final int BEFORE_VALUE = BEFORE_EQU + 1;

	/** Parse state constant */
	private static final int INSIDE_VALUE = BEFORE_VALUE + 1;

	/** Parse state constant */
	private static final int ESC_VALUE = INSIDE_VALUE + 1;

	/** Parse state constant */
	private static final int AFTER_VALUE = INSIDE_VALUE + 1;

	/** Parse state constant */
	private static final int BEFORE_SEP = AFTER_VALUE + 1;

	public static void setDefaultFixEncoding(final String encoding) {
	defaultFixEncoding = validateEncoding(encoding);
	}

	static String getDefaultFixEncoding() {
	return defaultFixEncoding;
	}

	static String toIdentityEncodedString(byte[] data) {
	if (data == null) {
	return null;
	}

	char[] characters = new char[data.length];
	for (int i = 0; i < characters.length; i++) {
	characters[i] = (char) (data[i] & 0xff);
	}
	return new String(characters);
	}

	static byte[] fromIdentityEncodedString(String string) {
	if (string == null) {
	return NO_CONTENT;
	}

	byte[] data = new byte[string.length()];
	for (int i = 0; i < data.length; i++) {
	data[i] = (byte) (string.charAt(i) & 0xff);
	}
	return data;
	}

	static InputStream toInputStream(String source) {
	byte[] data = fromIdentityEncodedString(source);
	return new ByteArrayInputStream(data);
	}

	static void fixEncoding(ParameterMap parameterMap) {
	// default the encoding to defaultFixEncoding
	String formEncoding = getDefaultFixEncoding();

	// check whether a form encoding parameter overwrites this default
	RequestParameter[] feParm = parameterMap.get(ParameterSupport.PARAMETER_FORMENCODING);
	if (feParm != null) {
	// get and check form encoding
	byte[] rawEncoding = feParm[0].get();
	formEncoding = toIdentityEncodedString(rawEncoding);
	formEncoding = validateEncoding(formEncoding);
	}

	// map for rename parameters due to encoding fixes
	LinkedHashMap<String, String> renameMap = new LinkedHashMap<String, String>();

	// convert the map of lists to a map of arrays
	for (Map.Entry<String, RequestParameter[]> paramEntry : parameterMap.entrySet()) {
	RequestParameter[] params = paramEntry.getValue();
	String parName = null;
	for (int i = 0; i < params.length; i++) {
	if (params[i] instanceof AbstractRequestParameter) {
	AbstractRequestParameter param = (AbstractRequestParameter) params[i];

	// fix encoding if different
	if (!formEncoding.equalsIgnoreCase(param.getEncoding())) {
	param.setEncoding(formEncoding);

	// prepare the parameter for renaming
	if (parName == null) {
	parName = paramEntry.getKey();
	String name = reencode(parName, formEncoding);
	if (!parName.equals(name)) {
	renameMap.put(parName, name);
	}
	}
	}
	}
	}
	}

	// apply mappings of deinternationalized names
	if (!renameMap.isEmpty()) {
	for (Map.Entry<String, String> entry : renameMap.entrySet()) {
	parameterMap.renameParameter(entry.getKey(), entry.getValue());
	}
	}
	}

	private static String reencode(String parName, String encoding) {
	// re-encode the parameter to the encoding
	if (!ENCODING_DIRECT.equalsIgnoreCase(encoding)) {
	try {
	return new String(parName.getBytes(ENCODING_DIRECT), encoding);
	} catch (UnsupportedEncodingException uee) {
	// unexpected, as the encoding is assumed to have been checked !
	}
	}

	// otherwise just return the name unmodified
	return parName;
	}

	/**
	* Checks whether the given encoding is known and supported by the platform
	* or not. If the platform supports the encoding the parameter is returned.
	* Otherwise or if the encoding argument is <code>null</code> or an empty
	* string {@link #defaultFixEncoding} is returned.
	*
	* @param encoding The encoding to validate
	* @return The encoding if supported or {@link #defaultFixEncoding}
	*/
	private static String validateEncoding(final String encoding) {
	if (encoding != null && encoding.length() > 0) {
	// check for the existence of the encoding
	try {
	"".getBytes(encoding);
	return encoding;
	} catch (UnsupportedEncodingException e) {
	// log.warn("HttpMulitpartPost: Character encoding {0} is not "
	// + "supported, using default {1}", formEncodingParam,
	// DEFAULT_ENCODING);
	}
	}

	// no encoding or unsupported encoding
	return getDefaultFixEncoding();
	}

	/**
	* Parse a query string and store entries inside a map
	*
	* @param data querystring data
	* @param encoding encoding to use for converting bytes to characters
	* @param map map to populate
	* @param prependNew whether to prepend new values
	* @throws IllegalArgumentException if the nv string is malformed
	* @throws UnsupportedEncodingException if the {@code encoding} is not
	* supported
	* @throws IOException if an error occurrs reading from {@code data}
	*/
	public static void parseQueryString(InputStream data, String encoding, ParameterMap map, boolean prependNew)
	throws UnsupportedEncodingException, IOException {

	parseNVPairString(data, encoding, map, '&', false, prependNew);
	}

	/**
	* Parse a name/value pair string and populate a map with key -> value[s]
	*
	* @param data name value data
	* @param encoding encoding to use for converting bytes to characters
	* @param map map to populate
	* @param separator multi-value separator character
	* @param allowSpaces allow spaces inside name/values
	* @param prependNew whether to prepend new values
	* @throws IllegalArgumentException if the nv string is malformed
	* @throws UnsupportedEncodingException if the {@code encoding} is not
	* supported
	* @throws IOException if an error occurrs reading from {@code data}
	*/
	private static void parseNVPairString(
	InputStream data,
	String encoding,
	ParameterMap map,
	char separator,
	boolean allowSpaces,
	boolean prependNew)
	throws UnsupportedEncodingException, IOException {

	ByteArrayOutputStream keyBuffer = new ByteArrayOutputStream(256);
	ByteArrayOutputStream valueBuffer = new ByteArrayOutputStream(256);
	char[] chCode = new char[2];

	int state = BEFORE_NAME;
	int subState = 0;

	for (int in = data.read(); in >= 0; in = data.read()) {
	char ch = (char) in;

	switch (state) {
	case BEFORE_NAME:
	if (ch == ' ') {
	continue;
	} else if (ch == '%') {
	state = ESC_NAME;
	subState = 0;
	} else if (ch == '+' && !allowSpaces) {
	keyBuffer.write(' ');
	state = INSIDE_NAME;
	} else {
	keyBuffer.write(ch);
	state = INSIDE_NAME;
	}
	break;
	case INSIDE_NAME:
	if (ch == '=') {
	state = BEFORE_VALUE;
	} else if (ch == '+' && !allowSpaces) {
	keyBuffer.write(' ');
	} else if (ch == '%') {
	state = ESC_NAME;
	subState = 0;
	} else if (ch == '&') {
	addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
	state = BEFORE_NAME;
	} else {
	keyBuffer.write(ch);
	}
	break;
	case ESC_NAME:
	chCode[subState++] = ch;
	if (subState == chCode.length) {
	String code = new String(chCode);
	try {
	keyBuffer.write(Integer.parseInt(code, 16));
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException("Bad escape sequence: %" + code);
	}
	state = INSIDE_NAME;
	}
	break;
	case BEFORE_EQU:
	if (ch == '=') {
	state = BEFORE_VALUE;
	}
	break;
	case BEFORE_VALUE:
	if (ch == ' ') {
	continue;
	} else if (ch == '%') {
	state = ESC_VALUE;
	subState = 0;
	} else if (ch == '+' && !allowSpaces) {
	valueBuffer.write(' ');
	state = INSIDE_VALUE;
	} else if (ch == separator) {
	addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
	state = BEFORE_NAME;
	} else {
	valueBuffer.write(ch);
	state = INSIDE_VALUE;
	}
	break;
	case INSIDE_VALUE:
	if (ch == separator) {
	addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
	state = BEFORE_NAME;
	} else if (ch == '+' && !allowSpaces) {
	valueBuffer.write(' ');
	} else if (ch == '%') {
	state = ESC_VALUE;
	subState = 0;
	} else {
	valueBuffer.write(ch);
	}
	break;
	case ESC_VALUE:
	chCode[subState++] = ch;
	if (subState == chCode.length) {
	String code = new String(chCode);
	try {
	valueBuffer.write(Integer.parseInt(code, 16));
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException("Bad escape sequence: %" + code);
	}
	state = INSIDE_VALUE;
	}
	break;
	case BEFORE_SEP:
	if (ch == separator) {
	state = BEFORE_NAME;
	}
	break;
	}
	}

	if (keyBuffer.size() > 0) {
	addNVPair(map, keyBuffer, valueBuffer, encoding, prependNew);
	}
	}

	private static void addNVPair(
	ParameterMap map,
	ByteArrayOutputStream keyBuffer,
	ByteArrayOutputStream valueBuffer,
	String encoding,
	boolean prependNew)
	throws UnsupportedEncodingException {
	final String key = keyBuffer.toString(encoding);
	final String value = valueBuffer.toString(encoding);
	map.addParameter(new ContainerRequestParameter(key, value, encoding), prependNew);
	keyBuffer.reset();
	valueBuffer.reset();
	}
	}