This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 0e55afa1fc821f70d6e81fe20c096cfba1d2d932
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Tue Apr 16 15:33:41 2024 +0100
Remove the internal fork of Commons Codec.
---
MERGE.txt | 9 -
.../apache/tomcat/util/codec/binary/Base64.java | 661 ---------------------
.../tomcat/util/codec/binary/BaseNCodec.java | 478 ---------------
.../util/codec/binary/LocalStrings.properties | 21 -
.../util/codec/binary/LocalStrings_fr.properties | 20 -
.../util/codec/binary/LocalStrings_ja.properties | 20 -
.../util/codec/binary/LocalStrings_ko.properties | 19 -
.../codec/binary/LocalStrings_zh_CN.properties | 19 -
.../tomcat/util/codec/binary/StringUtils.java | 116 ----
.../tomcat/util/codec/binary/package-info.java | 21 -
webapps/docs/changelog.xml | 3 +-
11 files changed, 2 insertions(+), 1385 deletions(-)
diff --git a/MERGE.txt b/MERGE.txt
index c3e81ab842..a4c15506df 100644
--- a/MERGE.txt
+++ b/MERGE.txt
@@ -39,15 +39,6 @@ src/main/java/org/apache/bcel
The SHA1 ID / tag for the most recent commit to be merged to Tomcat is:
rel/commons-bcel-6.8.2 (2024-02-25)
-Codec
------
-Unused code is removed
-Sub-tree:
-src/main/java/org/apache/commons/codec
-The SHA1 ID / tag for the most recent commit to be merged to Tomcat is:
-rel/commons-codec-1.16.1 (2024-02-09)
-Note: Only classes required for Base64 encoding/decoding. The rest are removed.
-
FileUpload
----------
Unused code is removed
diff --git a/java/org/apache/tomcat/util/codec/binary/Base64.java
b/java/org/apache/tomcat/util/codec/binary/Base64.java
deleted file mode 100644
index e38bf3df17..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/Base64.java
+++ /dev/null
@@ -1,661 +0,0 @@
-/*
- * 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.tomcat.util.codec.binary;
-
-/**
- * Provides Base64 encoding and decoding as defined by <a
href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045</a>.
- *
- * <p>
- * This class implements section <cite>6.8. Base64
Content-Transfer-Encoding</cite> from RFC 2045 <cite>Multipurpose
- * Internet Mail Extensions (MIME) Part One: Format of Internet Message
Bodies</cite> by Freed and Borenstein.
- * </p>
- * <p>
- * The class can be parameterized in the following manner with various
constructors:
- * </p>
- * <ul>
- * <li>URL-safe mode: Default off.</li>
- * <li>Line length: Default 76. Line length that aren't multiples of 4 will
still essentially end up being multiples of
- * 4 in the encoded data.
- * <li>Line separator: Default is CRLF ("\r\n")</li>
- * </ul>
- * <p>
- * The URL-safe parameter is only applied to encode operations. Decoding
seamlessly handles both modes.
- * </p>
- * <p>
- * Since this class operates directly on byte streams, and not character
streams, it is hard-coded to only
- * encode/decode character encodings which are compatible with the lower 127
ASCII chart (ISO-8859-1, Windows-1252,
- * UTF-8, etc).
- * </p>
- * <p>
- * This class is thread-safe.
- * </p>
- *
- * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045</a>
- * @since 1.0
- */
-public class Base64 extends BaseNCodec {
-
- /**
- * BASE64 characters are 6 bits in length.
- * They are formed by taking a block of 3 octets to form a 24-bit string,
- * which is converted into 4 BASE64 characters.
- */
- private static final int BITS_PER_ENCODED_BYTE = 6;
- private static final int BYTES_PER_UNENCODED_BLOCK = 3;
- private static final int BYTES_PER_ENCODED_BLOCK = 4;
-
- /**
- * This array is a lookup table that translates 6-bit positive integer
index values into their "Base64 Alphabet"
- * equivalents as specified in Table 1 of RFC 2045.
- * <p>
- * Thanks to "commons" project in ws.apache.org for this code.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
- */
- private static final byte[] STANDARD_ENCODE_TABLE = {
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
- 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
- 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
- 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
- };
-
- /**
- * This is a copy of the STANDARD_ENCODE_TABLE above, but with + and /
- * changed to - and _ to make the encoded Base64 results more URL-SAFE.
- * This table is only used when the Base64's mode is set to URL-SAFE.
- */
- private static final byte[] URL_SAFE_ENCODE_TABLE = {
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
- 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
- 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
- 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
- };
-
- /**
- * This array is a lookup table that translates Unicode characters drawn
from the "Base64 Alphabet" (as specified
- * in Table 1 of RFC 2045) into their 6-bit positive integer equivalents.
Characters that are not in the Base64
- * alphabet but fall within the bounds of the array are translated to -1.
- * <p>
- * Note: '+' and '-' both decode to 62. '/' and '_' both decode to 63.
This means decoder seamlessly handles both
- * URL_SAFE and STANDARD base64. (The encoder, on the other hand, needs to
know ahead of time what to emit).
- * </p>
- * <p>
- * Thanks to "commons" project in ws.apache.org for this code.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
- */
- private static final byte[] STANDARD_DECODE_TABLE = {
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
00-0f
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
10-1f
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, //
20-2f + /
- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, //
30-3f 0-9
- -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, //
40-4f A-O
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, //
50-5f P-Z
- -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, //
60-6f a-o
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 //
70-7a p-z
- };
-
- private static final byte[] URL_SAFE_DECODE_TABLE = {
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, // 00-0f
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, // 10-1f
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1,
-1, // 20-2f -
- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1,
-1, // 30-3f 0-9
- -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, // 40-4f A-O
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
63, // 50-5f P-Z _
- -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, // 60-6f a-o
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
// 70-7a p-z
- };
-
- /*
- * Base64 uses 6-bit fields.
- */
- /** Mask used to extract 6 bits, used when encoding */
- private static final int MASK_6BITS = 0x3f;
- /** Mask used to extract 4 bits, used when decoding final trailing
character. */
- private static final int MASK_4BITS = 0xf;
- /** Mask used to extract 2 bits, used when decoding final trailing
character. */
- private static final int MASK_2BITS = 0x3;
-
- // The static final fields above are used for the original static byte[]
methods on Base64.
- // The private member fields below are used with the new streaming
approach, which requires
- // some state be preserved between calls of encode() and decode().
-
- public static byte[] decodeBase64(
- final byte[] base64Data, final int off, final int len) {
- return new Base64().decode(base64Data, off, len);
- }
-
- /**
- * Decodes a Base64 String into octets.
- * <p>
- * <b>Note:</b> this method seamlessly handles data encoded in URL-safe or
normal mode.
- * </p>
- *
- * @param base64String
- * String containing Base64 data
- * @return Array containing decoded data.
- * @since 1.4
- */
- public static byte[] decodeBase64(final String base64String) {
- return new Base64().decode(base64String);
- }
-
- public static byte[] decodeBase64URLSafe(final String base64String) {
- return new Base64(true).decode(base64String);
- }
-
- // Implementation of integer encoding used for crypto
- /**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
- *
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
- */
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked) {
- return encodeBase64(binaryData, isChunked, false);
- }
-
- /**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
- *
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
- * @param urlSafe
- * if {@code true} this encoder will emit - and _ instead of
the usual + and / characters.
- * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than {@link Integer#MAX_VALUE}
- * @since 1.4
- */
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked, final boolean urlSafe) {
- return encodeBase64(binaryData, isChunked, urlSafe, Integer.MAX_VALUE);
- }
-
- /**
- * Encodes binary data using the base64 algorithm, optionally chunking the
output into 76 character blocks.
- *
- * @param binaryData
- * Array containing binary data to encode.
- * @param isChunked
- * if {@code true} this encoder will chunk the base64 output
into 76 character blocks
- * @param urlSafe
- * if {@code true} this encoder will emit - and _ instead of
the usual + and / characters.
- * <b>Note: no padding is added when encoding using the
URL-safe alphabet.</b>
- * @param maxResultSize
- * The maximum result size to accept.
- * @return Base64-encoded data.
- * @throws IllegalArgumentException
- * Thrown when the input array needs an output array bigger
than maxResultSize
- * @since 1.4
- */
- public static byte[] encodeBase64(final byte[] binaryData, final boolean
isChunked,
- final boolean urlSafe, final int
maxResultSize) {
- if (binaryData == null || binaryData.length == 0) {
- return binaryData;
- }
-
- // Create this so can use the super-class method
- // Also ensures that the same roundings are performed by the ctor and
the code
- final Base64 b64 = isChunked ? new Base64(urlSafe) : new Base64(0,
CHUNK_SEPARATOR, urlSafe);
- final long len = b64.getEncodedLength(binaryData);
- if (len > maxResultSize) {
- throw new IllegalArgumentException(sm.getString(
- "base64.inputTooLarge", Long.valueOf(len),
Integer.valueOf(maxResultSize)));
- }
-
- return b64.encode(binaryData);
- }
-
- /**
- * Encodes binary data using the base64 algorithm but does not chunk the
output.
- *
- * NOTE: We changed the behavior of this method from multi-line chunking
(commons-codec-1.4) to
- * single-line non-chunking (commons-codec-1.5).
- *
- * @param binaryData
- * binary data to encode
- * @return String containing Base64 characters.
- * @since 1.4 (NOTE: 1.4 chunked the output, whereas 1.5 does not).
- */
- public static String encodeBase64String(final byte[] binaryData) {
- return StringUtils.newStringUsAscii(encodeBase64(binaryData, false));
- }
-
- /**
- * Encodes binary data using a URL-safe variation of the base64 algorithm
but does not chunk the output. The
- * url-safe variation emits - and _ instead of + and / characters.
- * <b>Note: no padding is added.</b>
- * @param binaryData
- * binary data to encode
- * @return String containing Base64 characters
- * @since 1.4
- */
- public static String encodeBase64URLSafeString(final byte[] binaryData) {
- return StringUtils.newStringUsAscii(encodeBase64(binaryData, false,
true));
- }
-
- /**
- * Validates whether decoding the final trailing character is possible in
the context
- * of the set of possible base 64 values.
- * <p>
- * The character is valid if the lower bits within the provided mask are
zero. This
- * is used to test the final trailing base-64 digit is zero in the bits
that will be discarded.
- * </p>
- *
- * @param emptyBitsMask The mask of the lower bits that should be empty
- * @param context the context to be used
- *
- * @throws IllegalArgumentException if the bits being checked contain any
non-zero value
- */
- private static void validateCharacter(final int emptyBitsMask, final
Context context) {
- if ((context.ibitWorkArea & emptyBitsMask) != 0) {
- throw new IllegalArgumentException(
- "Last encoded character (before the paddings if any) is a
valid " +
- "base 64 alphabet but not a possible value. " +
- "Expected the discarded bits to be zero.");
- }
- }
-
-
- public static boolean isInAlphabet(char c) {
- // Fast for valid data. May be slow for invalid data.
- try {
- return STANDARD_DECODE_TABLE[c] != -1;
- } catch (ArrayIndexOutOfBoundsException ex) {
- return false;
- }
- }
-
- /**
- * Encode table to use: either STANDARD or URL_SAFE. Note: the
DECODE_TABLE above remains static because it is able
- * to decode both STANDARD and URL_SAFE streams, but the encodeTable must
be a member variable so we can switch
- * between the two modes.
- */
- private final byte[] encodeTable;
-
- /** Only one decode table currently; keep for consistency with Base32
code. */
- private final byte[] decodeTable;
-
- /**
- * Line separator for encoding. Not used when decoding. Only used if
lineLength > 0.
- */
- private final byte[] lineSeparator;
-
- /**
- * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
- * {@code decodeSize = 3 + lineSeparator.length;}
- */
- private final int decodeSize;
-
- /**
- * Convenience variable to help us determine when our buffer is going to
run out of room and needs resizing.
- * {@code encodeSize = 4 + lineSeparator.length;}
- */
- private final int encodeSize;
-
- /**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length is 0 (no chunking), and the encoding
table is STANDARD_ENCODE_TABLE.
- * </p>
- *
- * <p>
- * When decoding all variants are supported.
- * </p>
- */
- public Base64() {
- this(0);
- }
-
- /**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
the given URL-safe mode.
- * <p>
- * When encoding the line length is 76, the line separator is CRLF, and
the encoding table is STANDARD_ENCODE_TABLE.
- * </p>
- *
- * <p>
- * When decoding all variants are supported.
- * </p>
- *
- * @param urlSafe
- * if {@code true}, URL-safe encoding is used. In most cases
this should be set to
- * {@code false}.
- * @since 1.4
- */
- public Base64(final boolean urlSafe) {
- this(MIME_CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
- }
-
- /**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length is given in the constructor, the line
separator is CRLF, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
- *
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to the nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
- * @since 1.4
- */
- public Base64(final int lineLength) {
- this(lineLength, CHUNK_SEPARATOR);
- }
-
- /**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length and line separator are given in the
constructor, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
- *
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to the nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
- * @param lineSeparator
- * Each line of encoded data will end with this sequence of
bytes.
- * @throws IllegalArgumentException
- * Thrown when the provided lineSeparator included some base64
characters.
- * @since 1.4
- */
- public Base64(final int lineLength, final byte[] lineSeparator) {
- this(lineLength, lineSeparator, false);
- }
-
- /**
- * Creates a Base64 codec used for decoding (all modes) and encoding in
URL-unsafe mode.
- * <p>
- * When encoding the line length and line separator are given in the
constructor, and the encoding table is
- * STANDARD_ENCODE_TABLE.
- * </p>
- * <p>
- * Line lengths that aren't multiples of 4 will still essentially end up
being multiples of 4 in the encoded data.
- * </p>
- * <p>
- * When decoding all variants are supported.
- * </p>
- *
- * @param lineLength
- * Each line of encoded data will be at most of the given
length (rounded down to the nearest multiple of
- * 4). If lineLength <= 0, then the output will not be
divided into lines (chunks). Ignored when
- * decoding.
- * @param lineSeparator
- * Each line of encoded data will end with this sequence of
bytes.
- * @param urlSafe
- * Instead of emitting '+' and '/' we emit '-' and '_'
respectively. urlSafe is only applied to encode
- * operations. Decoding seamlessly handles both modes.
- * <b>Note: no padding is added when using the URL-safe
alphabet.</b>
- * @throws IllegalArgumentException
- * Thrown when the {@code lineSeparator} contains Base64
characters.
- * @since 1.4
- */
- public Base64(final int lineLength, final byte[] lineSeparator, final
boolean urlSafe) {
- super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK,
- lineLength,
- lineSeparator == null ? 0 : lineSeparator.length);
- // Needs to be set early to avoid NPE during call to
containsAlphabetOrPad() below
- this.decodeTable = urlSafe ? URL_SAFE_DECODE_TABLE :
STANDARD_DECODE_TABLE;
- // TODO could be simplified if there is no requirement to reject
invalid line sep when length <=0
- // @see test case Base64Test.testConstructors()
- if (lineSeparator != null) {
- if (containsAlphabetOrPad(lineSeparator)) {
- final String sep = StringUtils.newStringUtf8(lineSeparator);
- throw new
IllegalArgumentException(sm.getString("base64.lineSeparator", sep));
- }
- if (lineLength > 0){ // null line-sep forces no chunking rather
than throwing IAE
- this.encodeSize = BYTES_PER_ENCODED_BLOCK +
lineSeparator.length;
- this.lineSeparator = lineSeparator.clone();
- } else {
- this.encodeSize = BYTES_PER_ENCODED_BLOCK;
- this.lineSeparator = null;
- }
- } else {
- this.encodeSize = BYTES_PER_ENCODED_BLOCK;
- this.lineSeparator = null;
- }
- this.decodeSize = this.encodeSize - 1;
- this.encodeTable = urlSafe ? URL_SAFE_ENCODE_TABLE :
STANDARD_ENCODE_TABLE;
- }
-
- // Implementation of the Encoder Interface
-
- /**
- * <p>
- * Decodes all of the provided data, starting at inPos, for inAvail bytes.
Should be called at least twice: once
- * with the data to decode, and once with inAvail set to "-1" to alert
decoder that EOF has been reached. The "-1"
- * call is not necessary when decoding, but it doesn't hurt, either.
- * </p>
- * <p>
- * Ignores all non-base64 characters. This is how chunked (e.g. 76
character) data is handled, since CR and LF are
- * silently ignored, but has implications for other bytes, too. This
method subscribes to the garbage-in,
- * garbage-out philosophy: it will not check the provided data for
validity.
- * </p>
- * <p>
- * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
- *
- * @param input
- * byte[] array of ASCII data to base64 decode.
- * @param inPos
- * Position to start reading data from.
- * @param inAvail
- * Amount of bytes available from input for decoding.
- * @param context
- * the context to be used
- */
- @Override
- void decode(final byte[] input, int inPos, final int inAvail, final
Context context) {
- if (context.eof) {
- return;
- }
- if (inAvail < 0) {
- context.eof = true;
- }
- for (int i = 0; i < inAvail; i++) {
- final byte[] buffer = ensureBufferSize(decodeSize, context);
- final byte b = input[inPos++];
- if (b == pad) {
- // We're done.
- context.eof = true;
- break;
- }
- if (b >= 0 && b < decodeTable.length) {
- final int result = decodeTable[b];
- if (result >= 0) {
- context.modulus = (context.modulus+1) %
BYTES_PER_ENCODED_BLOCK;
- context.ibitWorkArea = (context.ibitWorkArea <<
BITS_PER_ENCODED_BYTE) + result;
- if (context.modulus == 0) {
- buffer[context.pos++] = (byte) (context.ibitWorkArea
>> 16 & MASK_8BITS);
- buffer[context.pos++] = (byte) (context.ibitWorkArea
>> 8 & MASK_8BITS);
- buffer[context.pos++] = (byte) (context.ibitWorkArea &
MASK_8BITS);
- }
- }
- }
- }
-
- // Two forms of EOF as far as base64 decoder is concerned: actual
- // EOF (-1) and first time '=' character is encountered in stream.
- // This approach makes the '=' padding characters completely optional.
- if (context.eof && context.modulus != 0) {
- final byte[] buffer = ensureBufferSize(decodeSize, context);
-
- // We have some spare bits remaining
- // Output all whole multiples of 8 bits and ignore the rest
- switch (context.modulus) {
-// case 0 : // impossible, as excluded above
-// case 1 : // 6 bits - invalid - use default below
- case 2 : // 12 bits = 8 + 4
- validateCharacter(MASK_4BITS, context);
- context.ibitWorkArea = context.ibitWorkArea >> 4; // dump
the extra 4 bits
- buffer[context.pos++] = (byte) (context.ibitWorkArea &
MASK_8BITS);
- break;
- case 3 : // 18 bits = 8 + 8 + 2
- validateCharacter(MASK_2BITS, context);
- context.ibitWorkArea = context.ibitWorkArea >> 2; // dump
2 bits
- buffer[context.pos++] = (byte) (context.ibitWorkArea >> 8
& MASK_8BITS);
- buffer[context.pos++] = (byte) (context.ibitWorkArea &
MASK_8BITS);
- break;
- default:
- throw new IllegalStateException(sm.getString(
- "base64.impossibleModulus",
Integer.valueOf(context.modulus)));
- }
- }
- }
-
- /**
- * <p>
- * Encodes all of the provided data, starting at inPos, for inAvail bytes.
Must be called at least twice: once with
- * the data to encode, and once with inAvail set to "-1" to alert encoder
that EOF has been reached, to flush last
- * remaining bytes (if not multiple of 3).
- * </p>
- * <p><b>Note: no padding is added when encoding using the URL-safe
alphabet.</b></p>
- * <p>
- * Thanks to "commons" project in ws.apache.org for the bitwise
operations, and general approach.
- * https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
- * </p>
- *
- * @param in
- * byte[] array of binary data to base64 encode.
- * @param inPos
- * Position to start reading data from.
- * @param inAvail
- * Amount of bytes available from input for encoding.
- * @param context
- * the context to be used
- */
- @Override
- void encode(final byte[] in, int inPos, final int inAvail, final Context
context) {
- if (context.eof) {
- return;
- }
- // inAvail < 0 is how we're informed of EOF in the underlying data
we're
- // encoding.
- if (inAvail < 0) {
- context.eof = true;
- if (0 == context.modulus && lineLength == 0) {
- return; // no leftovers to process and not using chunking
- }
- final byte[] buffer = ensureBufferSize(encodeSize, context);
- final int savedPos = context.pos;
- switch (context.modulus) { // 0-2
- case 0 : // nothing to do here
- break;
- case 1 : // 8 bits = 6 + 2
- // top 6 bits:
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 2 & MASK_6BITS];
- // remaining 2:
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
<< 4 & MASK_6BITS];
- // URL-SAFE skips the padding to further reduce size.
- if (encodeTable == STANDARD_ENCODE_TABLE) {
- buffer[context.pos++] = pad;
- buffer[context.pos++] = pad;
- }
- break;
-
- case 2 : // 16 bits = 6 + 6 + 4
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 10 & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 4 & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
<< 2 & MASK_6BITS];
- // URL-SAFE skips the padding to further reduce size.
- if (encodeTable == STANDARD_ENCODE_TABLE) {
- buffer[context.pos++] = pad;
- }
- break;
- default:
- throw new IllegalStateException(sm.getString(
- "base64.impossibleModulus",
Integer.valueOf(context.modulus)));
- }
- context.currentLinePos += context.pos - savedPos; // keep track of
current line position
- // if currentPos == 0 we are at the start of a line, so don't add
CRLF
- if (lineLength > 0 && context.currentLinePos > 0) {
- System.arraycopy(lineSeparator, 0, buffer, context.pos,
lineSeparator.length);
- context.pos += lineSeparator.length;
- }
- } else {
- for (int i = 0; i < inAvail; i++) {
- final byte[] buffer = ensureBufferSize(encodeSize, context);
- context.modulus = (context.modulus+1) %
BYTES_PER_UNENCODED_BLOCK;
- int b = in[inPos++];
- if (b < 0) {
- b += 256;
- }
- context.ibitWorkArea = (context.ibitWorkArea << 8) + b; //
BITS_PER_BYTE
- if (0 == context.modulus) { // 3 bytes = 24 bits = 4 * 6 bits
to extract
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 18 & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 12 & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea
>> 6 & MASK_6BITS];
- buffer[context.pos++] = encodeTable[context.ibitWorkArea &
MASK_6BITS];
- context.currentLinePos += BYTES_PER_ENCODED_BLOCK;
- if (lineLength > 0 && lineLength <=
context.currentLinePos) {
- System.arraycopy(lineSeparator, 0, buffer,
context.pos, lineSeparator.length);
- context.pos += lineSeparator.length;
- context.currentLinePos = 0;
- }
- }
- }
- }
- }
-
- /**
- * Returns whether or not the {@code octet} is in the Base64 alphabet.
- *
- * @param octet
- * The value to test
- * @return {@code true} if the value is defined in the Base64 alphabet
{@code false} otherwise.
- */
- @Override
- protected boolean isInAlphabet(final byte octet) {
- return octet >= 0 && octet < decodeTable.length && decodeTable[octet]
!= -1;
- }
-
- /**
- * Returns our current encode mode. True if we're URL-SAFE, false
otherwise.
- *
- * @return true if we're in URL-SAFE mode, false otherwise.
- * @since 1.4
- */
- public boolean isUrlSafe() {
- return this.encodeTable == URL_SAFE_ENCODE_TABLE;
- }
-}
diff --git a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
b/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
deleted file mode 100644
index 7492773fe0..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * 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.tomcat.util.codec.binary;
-
-import java.util.Arrays;
-
-import org.apache.tomcat.util.buf.HexUtils;
-import org.apache.tomcat.util.res.StringManager;
-
-/**
- * Abstract superclass for Base-N encoders and decoders.
- *
- * <p>
- * This class is thread-safe.
- * </p>
- */
-public abstract class BaseNCodec {
-
- protected static final StringManager sm =
StringManager.getManager(BaseNCodec.class);
-
- /**
- * Holds thread context so classes can be thread-safe.
- *
- * This class is not itself thread-safe; each thread must allocate its own
copy.
- *
- * @since 1.7
- */
- static class Context {
-
- /**
- * Placeholder for the bytes we're dealing with for our based logic.
- * Bitwise operations store and extract the encoding or decoding from
this variable.
- */
- int ibitWorkArea;
-
- /**
- * Buffer for streaming.
- */
- byte[] buffer;
-
- /**
- * Position where next character should be written in the buffer.
- */
- int pos;
-
- /**
- * Position where next character should be read from the buffer.
- */
- int readPos;
-
- /**
- * Boolean flag to indicate the EOF has been reached. Once EOF has
been reached, this object becomes useless,
- * and must be thrown away.
- */
- boolean eof;
-
- /**
- * Variable tracks how many characters have been written to the
current line. Only used when encoding. We use
- * it to make sure each encoded line never goes beyond lineLength (if
lineLength > 0).
- */
- int currentLinePos;
-
- /**
- * Writes to the buffer only occur after every 3/5 reads when
encoding, and every 4/8 reads when decoding. This
- * variable helps track that.
- */
- int modulus;
-
- /**
- * Returns a String useful for debugging (especially within a
debugger.)
- *
- * @return a String useful for debugging.
- */
- @SuppressWarnings("boxing") // OK to ignore boxing here
- @Override
- public String toString() {
- return String.format("%s[buffer=%s, currentLinePos=%s, eof=%s,
ibitWorkArea=%s, " +
- "modulus=%s, pos=%s, readPos=%s]",
this.getClass().getSimpleName(), HexUtils.toHexString(buffer),
- currentLinePos, eof, ibitWorkArea, modulus, pos, readPos);
- }
- }
-
- /**
- * EOF
- *
- * @since 1.7
- */
- static final int EOF = -1;
-
- /**
- * MIME chunk size per RFC 2045 section 6.8.
- *
- * <p>
- * The {@value} character limit does not count the trailing CRLF, but
counts all other characters, including any
- * equal signs.
- * </p>
- *
- * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045 section
6.8</a>
- */
- public static final int MIME_CHUNK_SIZE = 76;
-
- private static final int DEFAULT_BUFFER_RESIZE_FACTOR = 2;
-
- /**
- * Defines the default buffer size - currently {@value}
- * - must be large enough for at least one encoded block+separator
- */
- private static final int DEFAULT_BUFFER_SIZE = 128;
-
- /**
- * The maximum size buffer to allocate.
- *
- * <p>This is set to the same size used in the JDK {@link
java.util.ArrayList}:</p>
- * <blockquote>
- * Some VMs reserve some header words in an array.
- * Attempts to allocate larger arrays may result in
- * OutOfMemoryError: Requested array size exceeds VM limit.
- * </blockquote>
- */
- private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;
-
- /** Mask used to extract 8 bits, used in decoding bytes */
- protected static final int MASK_8BITS = 0xff;
-
- /**
- * Byte used to pad output.
- */
- protected static final byte PAD_DEFAULT = '='; // Allow static access to
default
-
- /**
- * Chunk separator per RFC 2045 section 2.1.
- *
- * @see <a href="http://www.ietf.org/rfc/rfc2045.txt";>RFC 2045 section
2.1</a>
- */
- static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
-
- /**
- * Create a positive capacity at least as large the minimum required
capacity.
- * If the minimum capacity is negative then this throws an
OutOfMemoryError as no array
- * can be allocated.
- *
- * @param minCapacity the minimum capacity
- * @return the capacity
- * @throws OutOfMemoryError if the {@code minCapacity} is negative
- */
- private static int createPositiveCapacity(final int minCapacity) {
- if (minCapacity < 0) {
- // overflow
- throw new OutOfMemoryError(sm.getString("base64.outOfMemory",
Long.valueOf(minCapacity & 0xffffffffL)));
- }
- // This is called when we require buffer expansion to a very big array.
- // Use the conservative maximum buffer size if possible, otherwise the
biggest required.
- //
- // Note: In this situation JDK 1.8 java.util.ArrayList returns
Integer.MAX_VALUE.
- // This excludes some VMs that can exceed MAX_BUFFER_SIZE but not
allocate a full
- // Integer.MAX_VALUE length array.
- // The result is that we may have to allocate an array of this size
more than once if
- // the capacity must be expanded again.
- return Math.max(minCapacity, MAX_BUFFER_SIZE);
- }
-
- /**
- * Increases our buffer by the {@link #DEFAULT_BUFFER_RESIZE_FACTOR}.
- * @param context the context to be used
- * @param minCapacity the minimum required capacity
- * @return the resized byte[] buffer
- * @throws OutOfMemoryError if the {@code minCapacity} is negative
- */
- private static byte[] resizeBuffer(final Context context, final int
minCapacity) {
- // Overflow-conscious code treats the min and new capacity as unsigned.
- final int oldCapacity = context.buffer.length;
- int newCapacity = oldCapacity * DEFAULT_BUFFER_RESIZE_FACTOR;
- if (Integer.compareUnsigned(newCapacity, minCapacity) < 0) {
- newCapacity = minCapacity;
- }
- if (Integer.compareUnsigned(newCapacity, MAX_BUFFER_SIZE) > 0) {
- newCapacity = createPositiveCapacity(minCapacity);
- }
-
- final byte[] b = Arrays.copyOf(context.buffer, newCapacity);
- context.buffer = b;
- return b;
- }
-
- /** Pad byte. Instance variable just in case it needs to vary later. */
- protected final byte pad;
-
- /** Number of bytes in each full block of unencoded data, e.g. 4 for
Base64 and 5 for Base32 */
- private final int unencodedBlockSize;
-
- /** Number of bytes in each full block of encoded data, e.g. 3 for Base64
and 8 for Base32 */
- private final int encodedBlockSize;
-
- /**
- * Chunksize for encoding. Not used when decoding.
- * A value of zero or less implies no chunking of the encoded data.
- * Rounded down to the nearest multiple of encodedBlockSize.
- */
- protected final int lineLength;
-
- /**
- * Size of chunk separator. Not used unless {@link #lineLength} > 0.
- */
- private final int chunkSeparatorLength;
-
- /**
- * Note {@code lineLength} is rounded down to the nearest multiple of the
encoded block size.
- * If {@code chunkSeparatorLength} is zero, then chunking is disabled.
- *
- * @param unencodedBlockSize the size of an unencoded block (e.g. Base64 =
3)
- * @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
- * @param lineLength if > 0, use chunking with a length {@code
lineLength}
- * @param chunkSeparatorLength the chunk separator length, if relevant
- */
- protected BaseNCodec(final int unencodedBlockSize, final int
encodedBlockSize,
- final int lineLength, final int chunkSeparatorLength)
{
- this(unencodedBlockSize, encodedBlockSize, lineLength,
chunkSeparatorLength, PAD_DEFAULT);
- }
-
- /**
- * Note {@code lineLength} is rounded down to the nearest multiple of the
encoded block size.
- * If {@code chunkSeparatorLength} is zero, then chunking is disabled.
- *
- * @param unencodedBlockSize the size of an unencoded block (e.g. Base64 =
3)
- * @param encodedBlockSize the size of an encoded block (e.g. Base64 = 4)
- * @param lineLength if > 0, use chunking with a length {@code
lineLength}
- * @param chunkSeparatorLength the chunk separator length, if relevant
- * @param pad byte used as padding byte.
- */
- protected BaseNCodec(final int unencodedBlockSize, final int
encodedBlockSize,
- final int lineLength, final int chunkSeparatorLength,
final byte pad) {
- this.unencodedBlockSize = unencodedBlockSize;
- this.encodedBlockSize = encodedBlockSize;
- final boolean useChunking = lineLength > 0 && chunkSeparatorLength > 0;
- this.lineLength = useChunking ? lineLength / encodedBlockSize *
encodedBlockSize : 0;
- this.chunkSeparatorLength = chunkSeparatorLength;
- this.pad = pad;
- }
-
- /**
- * Returns the amount of buffered data available for reading.
- *
- * @param context the context to be used
- * @return The amount of buffered data available for reading.
- */
- int available(final Context context) { // package protected for access
from I/O streams
- return hasData(context) ? context.pos - context.readPos : 0;
- }
-
- /**
- * Tests a given byte array to see if it contains any characters within
the alphabet or PAD.
- *
- * Intended for use in checking line-ending arrays
- *
- * @param arrayOctet
- * byte array to test
- * @return {@code true} if any byte is a valid character in the alphabet
or PAD; {@code false} otherwise
- */
- protected boolean containsAlphabetOrPad(final byte[] arrayOctet) {
- if (arrayOctet == null) {
- return false;
- }
- for (final byte element : arrayOctet) {
- if (pad == element || isInAlphabet(element)) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Decodes a byte[] containing characters in the Base-N alphabet.
- *
- * @param pArray
- * A byte array containing Base-N character data
- * @return a byte array containing binary data
- */
- public byte[] decode(final byte[] pArray) {
- return decode(pArray, 0, pArray.length);
- }
-
- public byte[] decode(final byte[] pArray, final int off, final int len) {
- if (pArray == null || len == 0) {
- return new byte[0];
- }
- final Context context = new Context();
- decode(pArray, off, len, context);
- decode(pArray, off, EOF, context); // Notify decoder of EOF.
- final byte[] result = new byte[context.pos];
- readResults(result, 0, result.length, context);
- return result;
- }
-
- // package protected for access from I/O streams
- abstract void decode(byte[] pArray, int i, int length, Context context);
-
- /**
- * Decodes a String containing characters in the Base-N alphabet.
- *
- * @param pArray
- * A String containing Base-N character data
- * @return a byte array containing binary data
- */
- public byte[] decode(final String pArray) {
- return decode(StringUtils.getBytesUtf8(pArray));
- }
-
- /**
- * Encodes a byte[] containing binary data, into a byte[] containing
characters in the alphabet.
- *
- * @param pArray
- * a byte array containing binary data
- * @return A byte array containing only the base N alphabetic character
data
- */
- public byte[] encode(final byte[] pArray) {
- if (pArray == null || pArray.length == 0) {
- return pArray;
- }
- return encode(pArray, 0, pArray.length);
- }
-
- /**
- * Encodes a byte[] containing binary data, into a byte[] containing
- * characters in the alphabet.
- *
- * @param pArray
- * a byte array containing binary data
- * @param offset
- * initial offset of the subarray.
- * @param length
- * length of the subarray.
- * @return A byte array containing only the base N alphabetic character
data
- * @since 1.11
- */
- public byte[] encode(final byte[] pArray, final int offset, final int
length) {
- if (pArray == null || pArray.length == 0) {
- return pArray;
- }
- final Context context = new Context();
- encode(pArray, offset, length, context);
- encode(pArray, offset, EOF, context); // Notify encoder of EOF.
- final byte[] buf = new byte[context.pos - context.readPos];
- readResults(buf, 0, buf.length, context);
- return buf;
- }
-
- // package protected for access from I/O streams
- abstract void encode(byte[] pArray, int i, int length, Context context);
-
- /**
- * Encodes a byte[] containing binary data, into a String containing
characters in the appropriate alphabet.
- * Uses UTF8 encoding.
- *
- * @param pArray a byte array containing binary data
- * @return String containing only character data in the appropriate
alphabet.
- * @since 1.5
- */
- public String encodeAsString(final byte[] pArray){
- return StringUtils.newStringUtf8(encode(pArray));
- }
-
- /**
- * Ensure that the buffer has room for {@code size} bytes
- *
- * @param size minimum spare space required
- * @param context the context to be used
- * @return the buffer
- */
- protected byte[] ensureBufferSize(final int size, final Context context){
- if (context.buffer == null) {
- context.buffer = new byte[Math.max(size, getDefaultBufferSize())];
- context.pos = 0;
- context.readPos = 0;
-
- // Overflow-conscious:
- // x + y > z == x + y - z > 0
- } else if (context.pos + size - context.buffer.length > 0) {
- return resizeBuffer(context, context.pos + size);
- }
- return context.buffer;
- }
-
- /**
- * Gets the default buffer size. Can be overridden.
- *
- * @return the default buffer size.
- */
- protected int getDefaultBufferSize() {
- return DEFAULT_BUFFER_SIZE;
- }
-
- /**
- * Calculates the amount of space needed to encode the supplied array.
- *
- * @param pArray byte[] array which will later be encoded
- *
- * @return amount of space needed to encode the supplied array.
- * Returns a long since a max-len array will require > Integer.MAX_VALUE
- */
- public long getEncodedLength(final byte[] pArray) {
- // Calculate non-chunked size - rounded up to allow for padding
- // cast to long is needed to avoid possibility of overflow
- long len = (pArray.length + unencodedBlockSize-1) /
unencodedBlockSize * (long) encodedBlockSize;
- if (lineLength > 0) { // We're using chunking
- // Round up to nearest multiple
- len += (len + lineLength-1) / lineLength * chunkSeparatorLength;
- }
- return len;
- }
-
- /**
- * Returns true if this object has buffered data for reading.
- *
- * @param context the context to be used
- * @return true if there is data still available for reading.
- */
- boolean hasData(final Context context) { // package protected for access
from I/O streams
- return context.pos > context.readPos;
- }
-
- /**
- * Returns whether or not the {@code octet} is in the current alphabet.
- * Does not allow whitespace or pad.
- *
- * @param value The value to test
- *
- * @return {@code true} if the value is defined in the current alphabet,
{@code false} otherwise.
- */
- protected abstract boolean isInAlphabet(byte value);
-
- /**
- * Extracts buffered data into the provided byte[] array, starting at
position bPos, up to a maximum of bAvail
- * bytes. Returns how many bytes were actually extracted.
- * <p>
- * Package private for access from I/O streams.
- * </p>
- *
- * @param b
- * byte[] array to extract the buffered data into.
- * @param bPos
- * position in byte[] array to start extraction at.
- * @param bAvail
- * amount of bytes we're allowed to extract. We may extract
fewer (if fewer are available).
- * @param context
- * the context to be used
- * @return The number of bytes successfully extracted into the provided
byte[] array.
- */
- int readResults(final byte[] b, final int bPos, final int bAvail, final
Context context) {
- if (hasData(context)) {
- final int len = Math.min(available(context), bAvail);
- System.arraycopy(context.buffer, context.readPos, b, bPos, len);
- context.readPos += len;
- if (!hasData(context)) {
- // All data read.
- // Reset position markers but do not set buffer to null to
allow its reuse.
- // hasData(context) will still return false, and this method
will return 0 until
- // more data is available, or -1 if EOF.
- context.pos = context.readPos = 0;
- }
- return len;
- }
- return context.eof ? EOF : 0;
- }
-}
diff --git a/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
deleted file mode 100644
index 6b17260a15..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/LocalStrings.properties
+++ /dev/null
@@ -1,21 +0,0 @@
-# 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.
-
-base64.impossibleModulus=Impossible modulus [{0}]
-base64.inputTooLarge=Input array too large, the output array would be bigger
[{0}] than the specified maximum size of [{1}]
-base64.lineSeparator=Line separator must not contain base64 characters [{0}]
-base64.nullEncodeParameter=Cannot encode integer with null parameter
-
-base64.outOfMemory=Unable to allocate array size [{0}]
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
deleted file mode 100644
index 5ae85e1f32..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/LocalStrings_fr.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-base64.impossibleModulus=Modulo [{0}] invalide
-base64.inputTooLarge=Le tableau en entrée est trop grand, la taille du tableau
de sortie [{0}] serait plus grande que la taille maximale autorisée [{1}]
-base64.lineSeparator=Le séparateur de ligne ne doit pas contenir des
caractères base64 [{0}]
-base64.nullEncodeParameter=Impossible d'encoder unentier en utilisant un
paramètre null
-base64.outOfMemory=Impossible d''allouer un tableau de taille [{0}]
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
deleted file mode 100644
index 342dcfcf0d..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ja.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-base64.impossibleModulus=計算できない剰余 [{0}] です。
-base64.inputTooLarge=入力配列が大きすぎます。出力配列は [{1}] の指定された最大サイズよりも大きくなります [{0}]
-base64.lineSeparator=行区切り記号にはbase64文字を使用できません[{0}]
-base64.nullEncodeParameter=null 値を整数に符号化できませんでした。
-base64.outOfMemory=配列サイズ [{0}] を割り当てることができません
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
deleted file mode 100644
index 7bdc2bbca6..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/LocalStrings_ko.properties
+++ /dev/null
@@ -1,19 +0,0 @@
-# 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.
-
-base64.impossibleModulus=불가능한 계수 [{0}]
-base64.inputTooLarge=입력 배열이 너무 큽니다. 출력 배열의 크기 [{0}]이(가), 지정된 최대 크기 [{1}] 보다 큰
값입니다.
-base64.lineSeparator=행 구분문자 [{0}]은(는) Base64 문자들을 포함해서는 안됩니다.
-base64.nullEncodeParameter=정수를 위한 파라미터가 널이라서 인코딩할 수 없습니다.
diff --git
a/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
b/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
deleted file mode 100644
index 0624dec940..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/LocalStrings_zh_CN.properties
+++ /dev/null
@@ -1,19 +0,0 @@
-# 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.
-
-base64.impossibleModulus=不可能的模[{0}]
-base64.inputTooLarge=输入数组太大，输出数组将比指定的最大大小[{1}]大[{0}]
-base64.lineSeparator=行分隔符不能包含base64个字符[{0}]
-base64.nullEncodeParameter=不能用空参数编码整数
diff --git a/java/org/apache/tomcat/util/codec/binary/StringUtils.java
b/java/org/apache/tomcat/util/codec/binary/StringUtils.java
deleted file mode 100644
index ab050f3509..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/StringUtils.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * 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.tomcat.util.codec.binary;
-
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-
-/**
- * Converts String to and from bytes using the encodings required by the Java
specification. These encodings are
- * specified in <a
href="http://download.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html";>
- * Standard charsets</a>.
- *
- * <p>This class is immutable and thread-safe.</p>
- *
- * @see Charset
- * @see StandardCharsets
- * @since 1.4
- */
-public class StringUtils {
-
- /**
- * Calls {@link String#getBytes(Charset)}
- *
- * @param string
- * The string to encode (if null, return null).
- * @param charset
- * The {@link Charset} to encode the {@code String}
- * @return the encoded bytes
- */
- private static byte[] getBytes(final String string, final Charset charset)
{
- return string == null ? null : string.getBytes(charset);
- }
-
- /**
- * Encodes the given string into a sequence of bytes using the UTF-8
charset, storing the result into a new byte
- * array.
- *
- * @param string
- * the String to encode, may be {@code null}
- * @return encoded bytes, or {@code null} if the input string was {@code
null}
- * @throws NullPointerException
- * Thrown if {@link StandardCharsets#UTF_8} is not
initialized, which should never happen
- * since it is required by the Java platform specification.
- * @since As of 1.7, throws {@link NullPointerException} instead of
UnsupportedEncodingException
- * @see Charset
- */
- public static byte[] getBytesUtf8(final String string) {
- return getBytes(string, StandardCharsets.UTF_8);
- }
-
- /**
- * Constructs a new {@code String} by decoding the specified array of
bytes using the given charset.
- *
- * @param bytes
- * The bytes to be decoded into characters
- * @param charset
- * The {@link Charset} to encode the {@code String}; not {@code
null}
- * @return A new {@code String} decoded from the specified array of bytes
using the given charset,
- * or {@code null} if the input byte array was {@code null}.
- * @throws NullPointerException
- * Thrown if charset is {@code null}
- */
- private static String newString(final byte[] bytes, final Charset charset)
{
- return bytes == null ? null : new String(bytes, charset);
- }
-
- /**
- * Constructs a new {@code String} by decoding the specified array of
bytes using the US-ASCII charset.
- *
- * @param bytes
- * The bytes to be decoded into characters
- * @return A new {@code String} decoded from the specified array of bytes
using the US-ASCII charset,
- * or {@code null} if the input byte array was {@code null}.
- * @throws NullPointerException
- * Thrown if {@link StandardCharsets#US_ASCII} is not
initialized, which should never happen
- * since it is required by the Java platform specification.
- * @since As of 1.7, throws {@link NullPointerException} instead of
UnsupportedEncodingException
- */
- public static String newStringUsAscii(final byte[] bytes) {
- return newString(bytes, StandardCharsets.US_ASCII);
- }
-
- /**
- * Constructs a new {@code String} by decoding the specified array of
bytes using the UTF-8 charset.
- *
- * @param bytes
- * The bytes to be decoded into characters
- * @return A new {@code String} decoded from the specified array of bytes
using the UTF-8 charset,
- * or {@code null} if the input byte array was {@code null}.
- * @throws NullPointerException
- * Thrown if {@link StandardCharsets#UTF_8} is not
initialized, which should never happen since it is
- * required by the Java platform specification.
- * @since As of 1.7, throws {@link NullPointerException} instead of
UnsupportedEncodingException
- */
- public static String newStringUtf8(final byte[] bytes) {
- return newString(bytes, StandardCharsets.UTF_8);
- }
-
- private StringUtils() {
- // empty
- }
-}
\ No newline at end of file
diff --git a/java/org/apache/tomcat/util/codec/binary/package-info.java
b/java/org/apache/tomcat/util/codec/binary/package-info.java
deleted file mode 100644
index 605aeded44..0000000000
--- a/java/org/apache/tomcat/util/codec/binary/package-info.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Base64 String encoding and decoding.
- */
-package org.apache.tomcat.util.codec.binary;
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index 797b5a0a52..0cf84d9b86 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -136,7 +136,8 @@
<changelog>
<update>
Switch to using the Base64 encoder and decoder provided by the JRE
- rather than the version provided by Commons Codec. (markt)
+ rather than the version provided by Commons Codec. This removes the
+ internal fork of Commons Codec. (markt)
</update>
</changelog>
</subsection>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org
