1 files changed, 362 insertions, 0 deletions
diff --git a/mobile/android/thirdparty/org/mozilla/apache/commons/codec/net/URLCodec.java b/mobile/android/thirdparty/org/mozilla/apache/commons/codec/net/URLCodec.java
new file mode 100644
index 000000000..74699310f
--- /dev/null
+++ b/mobile/android/thirdparty/org/mozilla/apache/commons/codec/net/URLCodec.java
@@ -0,0 +1,362 @@
+// Mozilla has modified this file - see http://hg.mozilla.org/ for details.
+/*
+ * 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.mozilla.apache.commons.codec.net;
+
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.BitSet;
+
+import org.mozilla.apache.commons.codec.BinaryDecoder;
+import org.mozilla.apache.commons.codec.BinaryEncoder;
+import org.mozilla.apache.commons.codec.DecoderException;
+import org.mozilla.apache.commons.codec.EncoderException;
+import org.mozilla.apache.commons.codec.CharEncoding;
+import org.mozilla.apache.commons.codec.StringDecoder;
+import org.mozilla.apache.commons.codec.StringEncoder;
+import org.mozilla.apache.commons.codec.binary.StringUtils;
+
+/**
+ * <p>Implements the 'www-form-urlencoded' encoding scheme, 
+ * also misleadingly known as URL encoding.</p>
+ *  
+ * <p>For more detailed information please refer to 
+ * <a href="http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1">
+ * Chapter 17.13.4 'Form content types'</a> of the 
+ * <a href="http://www.w3.org/TR/html4/">HTML 4.01 Specification<a></p>
+ * 
+ * <p> 
+ * This codec is meant to be a replacement for standard Java classes
+ * {@link java.net.URLEncoder} and {@link java.net.URLDecoder} 
+ * on older Java platforms, as these classes in Java versions below 
+ * 1.4 rely on the platform's default charset encoding.
+ * </p>
+ * 
+ * @author Apache Software Foundation
+ * @since 1.2
+ * @version $Id: URLCodec.java 1079537 2011-03-08 20:56:19Z ggregory $
+ */
+public class URLCodec implements BinaryEncoder, BinaryDecoder, StringEncoder, StringDecoder {
+    
+    /**
+     * Radix used in encoding and decoding.
+     */
+    static final int RADIX = 16;
+    
+    /**
+     * The default charset used for string decoding and encoding. Consider this field final. The next major release may
+     * break compatibility and make this field be final.
+     */
+    protected String charset;
+    
+    /**
+     * Release 1.5 made this field final.
+     */
+    protected static final byte ESCAPE_CHAR = '%';
+    /**
+     * BitSet of www-form-url safe characters.
+     */
+    protected static final BitSet WWW_FORM_URL = new BitSet(256);
+    
+    // Static initializer for www_form_url
+    static {
+        // alpha characters
+        for (int i = 'a'; i <= 'z'; i++) {
+            WWW_FORM_URL.set(i);
+        }
+        for (int i = 'A'; i <= 'Z'; i++) {
+            WWW_FORM_URL.set(i);
+        }
+        // numeric characters
+        for (int i = '0'; i <= '9'; i++) {
+            WWW_FORM_URL.set(i);
+        }
+        // special chars
+        WWW_FORM_URL.set('-');
+        WWW_FORM_URL.set('_');
+        WWW_FORM_URL.set('.');
+        WWW_FORM_URL.set('*');
+        // blank to be replaced with +
+        WWW_FORM_URL.set(' ');
+    }
+
+
+    /**
+     * Default constructor.
+     */
+    public URLCodec() {
+        this(CharEncoding.UTF_8);
+    }
+
+    /**
+     * Constructor which allows for the selection of a default charset
+     * 
+     * @param charset the default string charset to use.
+     */
+    public URLCodec(String charset) {
+        super();
+        this.charset = charset;
+    }
+
+    /**
+     * Encodes an array of bytes into an array of URL safe 7-bit characters. Unsafe characters are escaped.
+     * 
+     * @param urlsafe
+     *            bitset of characters deemed URL safe
+     * @param bytes
+     *            array of bytes to convert to URL safe characters
+     * @return array of bytes containing URL safe characters
+     */
+    public static final byte[] encodeUrl(BitSet urlsafe, byte[] bytes) {
+        if (bytes == null) {
+            return null;
+        }
+        if (urlsafe == null) {
+            urlsafe = WWW_FORM_URL;
+        }
+
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        for (int i = 0; i < bytes.length; i++) {
+            int b = bytes[i];
+            if (b < 0) {
+                b = 256 + b;
+            }
+            if (urlsafe.get(b)) {
+                if (b == ' ') {
+                    b = '+';
+                }
+                buffer.write(b);
+            } else {
+                buffer.write(ESCAPE_CHAR);
+                char hex1 = Character.toUpperCase(Character.forDigit((b >> 4) & 0xF, RADIX));
+                char hex2 = Character.toUpperCase(Character.forDigit(b & 0xF, RADIX));
+                buffer.write(hex1);
+                buffer.write(hex2);
+            }
+        }
+        return buffer.toByteArray();
+    }
+
+    /**
+     * Decodes an array of URL safe 7-bit characters into an array of 
+     * original bytes. Escaped characters are converted back to their 
+     * original representation.
+     *
+     * @param bytes array of URL safe characters
+     * @return array of original bytes 
+     * @throws DecoderException Thrown if URL decoding is unsuccessful
+     */
+    public static final byte[] decodeUrl(byte[] bytes) throws DecoderException {
+        if (bytes == null) {
+            return null;
+        }
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        for (int i = 0; i < bytes.length; i++) {
+            int b = bytes[i];
+            if (b == '+') {
+                buffer.write(' ');
+            } else if (b == ESCAPE_CHAR) {
+                try {
+                    int u = Utils.digit16(bytes[++i]);
+                    int l = Utils.digit16(bytes[++i]);
+                    buffer.write((char) ((u << 4) + l));
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    throw new DecoderException("Invalid URL encoding: ", e);
+                }
+            } else {
+                buffer.write(b);
+            }
+        }
+        return buffer.toByteArray();
+    }
+
+    /**
+     * Encodes an array of bytes into an array of URL safe 7-bit 
+     * characters. Unsafe characters are escaped.
+     *
+     * @param bytes array of bytes to convert to URL safe characters
+     * @return array of bytes containing URL safe characters
+     */
+    public byte[] encode(byte[] bytes) {
+        return encodeUrl(WWW_FORM_URL, bytes);
+    }
+
+
+    /**
+     * Decodes an array of URL safe 7-bit characters into an array of 
+     * original bytes. Escaped characters are converted back to their 
+     * original representation.
+     *
+     * @param bytes array of URL safe characters
+     * @return array of original bytes 
+     * @throws DecoderException Thrown if URL decoding is unsuccessful
+     */
+    public byte[] decode(byte[] bytes) throws DecoderException {
+        return decodeUrl(bytes);
+    }
+
+    /**
+     * Encodes a string into its URL safe form using the specified string charset. Unsafe characters are escaped.
+     * 
+     * @param pString
+     *            string to convert to a URL safe form
+     * @param charset
+     *            the charset for pString
+     * @return URL safe string
+     * @throws UnsupportedEncodingException
+     *             Thrown if charset is not supported
+     */
+    public String encode(String pString, String charset) throws UnsupportedEncodingException {
+        if (pString == null) {
+            return null;
+        }
+        return StringUtils.newStringUsAscii(encode(pString.getBytes(charset)));
+    }
+
+    /**
+     * Encodes a string into its URL safe form using the default string 
+     * charset. Unsafe characters are escaped.
+     *
+     * @param pString string to convert to a URL safe form
+     * @return URL safe string
+     * @throws EncoderException Thrown if URL encoding is unsuccessful
+     * 
+     * @see #getDefaultCharset()
+     */
+    public String encode(String pString) throws EncoderException {
+        if (pString == null) {
+            return null;
+        }
+        try {
+            return encode(pString, getDefaultCharset());
+        } catch (UnsupportedEncodingException e) {
+            throw new EncoderException(e.getMessage(), e);
+        }
+    }
+
+
+    /**
+     * Decodes a URL safe string into its original form using the 
+     * specified encoding. Escaped characters are converted back 
+     * to their original representation.
+     *
+     * @param pString URL safe string to convert into its original form
+     * @param charset the original string charset
+     * @return original string 
+     * @throws DecoderException Thrown if URL decoding is unsuccessful
+     * @throws UnsupportedEncodingException Thrown if charset is not
+     *                                      supported 
+     */
+    public String decode(String pString, String charset) throws DecoderException, UnsupportedEncodingException {
+        if (pString == null) {
+            return null;
+        }
+        return new String(decode(StringUtils.getBytesUsAscii(pString)), charset);
+    }
+
+    /**
+     * Decodes a URL safe string into its original form using the default
+     * string charset. Escaped characters are converted back to their 
+     * original representation.
+     *
+     * @param pString URL safe string to convert into its original form
+     * @return original string 
+     * @throws DecoderException Thrown if URL decoding is unsuccessful
+     * 
+     * @see #getDefaultCharset()
+     */
+    public String decode(String pString) throws DecoderException {
+        if (pString == null) {
+            return null;
+        }
+        try {
+            return decode(pString, getDefaultCharset());
+        } catch (UnsupportedEncodingException e) {
+            throw new DecoderException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Encodes an object into its URL safe form. Unsafe characters are 
+     * escaped.
+     *
+     * @param pObject string to convert to a URL safe form
+     * @return URL safe object
+     * @throws EncoderException Thrown if URL encoding is not 
+     *                          applicable to objects of this type or
+     *                          if encoding is unsuccessful
+     */
+    public Object encode(Object pObject) throws EncoderException {
+        if (pObject == null) {
+            return null;
+        } else if (pObject instanceof byte[]) {
+            return encode((byte[])pObject);
+        } else if (pObject instanceof String) {
+            return encode((String)pObject);
+        } else {
+            throw new EncoderException("Objects of type " +
+                pObject.getClass().getName() + " cannot be URL encoded"); 
+              
+        }
+    }
+
+    /**
+     * Decodes a URL safe object into its original form. Escaped characters are converted back to their original
+     * representation.
+     * 
+     * @param pObject
+     *                  URL safe object to convert into its original form
+     * @return original object
+     * @throws DecoderException
+     *                  Thrown if the argument is not a <code>String</code> or <code>byte[]</code>. Thrown if a failure condition is
+     *                  encountered during the decode process.
+     */
+    public Object decode(Object pObject) throws DecoderException {
+        if (pObject == null) {
+            return null;
+        } else if (pObject instanceof byte[]) {
+            return decode((byte[]) pObject);
+        } else if (pObject instanceof String) {
+            return decode((String) pObject);
+        } else {
+            throw new DecoderException("Objects of type " + pObject.getClass().getName() + " cannot be URL decoded");
+
+        }
+    }
+
+    /**
+     * The <code>String</code> encoding used for decoding and encoding.
+     * 
+     * @return Returns the encoding.
+     * 
+     * @deprecated Use {@link #getDefaultCharset()}, will be removed in 2.0.
+     */
+    public String getEncoding() {
+        return this.charset;
+    }
+
+    /**
+     * The default charset used for string decoding and encoding.
+     *
+     * @return the default string charset.
+     */
+    public String getDefaultCharset() {
+        return this.charset;
+    }
+
+}