mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
363 lines
12 KiB
Java
363 lines
12 KiB
Java
// 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;
|
|
}
|
|
|
|
}
|