You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2025/05/22 13:20:14 UTC
(tomcat) branch 9.0.x updated (df5b0497f1 -> 9616c234e7)
This is an automated email from the ASF dual-hosted git repository.
markt pushed a change to branch 9.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
from df5b0497f1 Code clean-up - formatting. No functional change.
new 3668595ef6 Protect decode table formatting
new 9616c234e7 Code clean-up - formatting. No functional change.
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../apache/tomcat/util/codec/binary/Base64.java | 265 ++++++++++-----------
.../tomcat/util/codec/binary/BaseNCodec.java | 169 +++++++------
.../tomcat/util/codec/binary/StringUtils.java | 74 +++---
.../tomcat/util/codec/binary/package-info.java | 4 +-
4 files changed, 244 insertions(+), 268 deletions(-)
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org
(tomcat) 01/02: Protect decode table formatting
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 9.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 3668595ef60728f04f6ad0d73ac1c835f2e21ed7
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Thu May 22 14:15:19 2025 +0100
Protect decode table formatting
---
java/org/apache/tomcat/util/codec/binary/Base64.java | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/java/org/apache/tomcat/util/codec/binary/Base64.java b/java/org/apache/tomcat/util/codec/binary/Base64.java
index 5f6fdbd7a5..f992d67e3d 100644
--- a/java/org/apache/tomcat/util/codec/binary/Base64.java
+++ b/java/org/apache/tomcat/util/codec/binary/Base64.java
@@ -103,6 +103,7 @@ public class Base64 extends BaseNCodec {
* https://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
* </p>
*/
+ // @formatter:off
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
@@ -125,7 +126,8 @@ public class Base64 extends BaseNCodec {
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
- };
+ };
+ // @formatter:on
/*
* Base64 uses 6-bit fields.
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org
(tomcat) 02/02: Code clean-up - formatting. No functional change.
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 9.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit 9616c234e7f4dd3daad0800863291c636ba2ee49
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Thu May 22 14:20:07 2025 +0100
Code clean-up - formatting. No functional change.
---
.../apache/tomcat/util/codec/binary/Base64.java | 261 ++++++++++-----------
.../tomcat/util/codec/binary/BaseNCodec.java | 169 +++++++------
.../tomcat/util/codec/binary/StringUtils.java | 74 +++---
.../tomcat/util/codec/binary/package-info.java | 4 +-
4 files changed, 241 insertions(+), 267 deletions(-)
diff --git a/java/org/apache/tomcat/util/codec/binary/Base64.java b/java/org/apache/tomcat/util/codec/binary/Base64.java
index f992d67e3d..2ffa36564e 100644
--- a/java/org/apache/tomcat/util/codec/binary/Base64.java
+++ b/java/org/apache/tomcat/util/codec/binary/Base64.java
@@ -18,7 +18,6 @@ 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.
@@ -36,15 +35,15 @@ package org.apache.tomcat.util.codec.binary;
* 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).
+ * 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
*
* @deprecated Unused. This class will be removed in Tomcat 11 onwards.
@@ -53,8 +52,7 @@ package org.apache.tomcat.util.codec.binary;
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,
+ * 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;
@@ -69,30 +67,23 @@ public class Base64 extends BaseNCodec {
* 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', '+', '/'
- };
+ 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.
+ * 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', '-', '_'
- };
+ 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
+ * 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
@@ -143,8 +134,7 @@ public class Base64 extends BaseNCodec {
// 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) {
+ public static byte[] decodeBase64(final byte[] base64Data, final int off, final int len) {
return new Base64().decode(base64Data, off, len);
}
@@ -154,9 +144,10 @@ public class Base64 extends BaseNCodec {
* <b>Note:</b> this method seamlessly handles data encoded in URL-safe or normal mode.
* </p>
*
- * @param base64String
- * String containing Base64 data
+ * @param base64String String containing Base64 data
+ *
* @return Array containing decoded data.
+ *
* @since 1.4
*/
public static byte[] decodeBase64(final String base64String) {
@@ -171,13 +162,13 @@ public class Base64 extends BaseNCodec {
/**
* 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 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}
+ *
+ * @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);
@@ -186,16 +177,16 @@ public class Base64 extends BaseNCodec {
/**
* 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 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}
+ *
+ * @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) {
@@ -205,22 +196,20 @@ public class Base64 extends BaseNCodec {
/**
* 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.
+ * @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
+ *
+ * @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) {
+ public static byte[] encodeBase64(final byte[] binaryData, final boolean isChunked, final boolean urlSafe,
+ final int maxResultSize) {
if (binaryData == null || binaryData.length == 0) {
return binaryData;
}
@@ -230,23 +219,22 @@ public class Base64 extends BaseNCodec {
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)));
+ 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.
+ * 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).
*
- * 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
*
- * @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).
+ *
+ * @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));
@@ -254,11 +242,12 @@ public class Base64 extends BaseNCodec {
/**
* 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
+ * 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) {
@@ -266,24 +255,22 @@ public class Base64 extends BaseNCodec {
}
/**
- * Validates whether decoding the final trailing character is possible in the context
- * of the set of possible base 64 values.
+ * 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.
+ * 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
+ * @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.");
+ 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.");
}
}
@@ -329,7 +316,6 @@ public class Base64 extends BaseNCodec {
* <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>
@@ -343,14 +329,12 @@ public class Base64 extends BaseNCodec {
* <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}.
+ * @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) {
@@ -370,10 +354,10 @@ public class Base64 extends BaseNCodec {
* 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 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) {
@@ -393,14 +377,13 @@ public class Base64 extends BaseNCodec {
* 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.
+ * @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) {
@@ -420,23 +403,20 @@ public class Base64 extends BaseNCodec {
* 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.
+ * @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,
+ 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;
@@ -447,7 +427,7 @@ public class Base64 extends BaseNCodec {
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
+ 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 {
@@ -480,14 +460,10 @@ public class Base64 extends BaseNCodec {
* 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
+ * @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) {
@@ -508,7 +484,7 @@ public class Base64 extends BaseNCodec {
if (b >= 0 && b < decodeTable.length) {
final int result = decodeTable[b];
if (result >= 0) {
- context.modulus = (context.modulus+1) % BYTES_PER_ENCODED_BLOCK;
+ 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);
@@ -528,22 +504,22 @@ public class Base64 extends BaseNCodec {
// 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
+ // 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
+ 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)));
+ throw new IllegalStateException(
+ sm.getString("base64.impossibleModulus", Integer.valueOf(context.modulus)));
}
}
}
@@ -554,20 +530,18 @@ public class Base64 extends BaseNCodec {
* 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>
+ * <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
+ * @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) {
@@ -584,9 +558,9 @@ public class Base64 extends BaseNCodec {
final byte[] buffer = ensureBufferSize(encodeSize, context);
final int savedPos = context.pos;
switch (context.modulus) { // 0-2
- case 0 : // nothing to do here
+ case 0: // nothing to do here
break;
- case 1 : // 8 bits = 6 + 2
+ case 1: // 8 bits = 6 + 2
// top 6 bits:
buffer[context.pos++] = encodeTable[context.ibitWorkArea >> 2 & MASK_6BITS];
// remaining 2:
@@ -598,7 +572,7 @@ public class Base64 extends BaseNCodec {
}
break;
- case 2 : // 16 bits = 6 + 6 + 4
+ 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];
@@ -608,8 +582,8 @@ public class Base64 extends BaseNCodec {
}
break;
default:
- throw new IllegalStateException(sm.getString(
- "base64.impossibleModulus", Integer.valueOf(context.modulus)));
+ 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
@@ -620,12 +594,12 @@ public class Base64 extends BaseNCodec {
} else {
for (int i = 0; i < inAvail; i++) {
final byte[] buffer = ensureBufferSize(encodeSize, context);
- context.modulus = (context.modulus+1) % BYTES_PER_UNENCODED_BLOCK;
+ 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
+ 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];
@@ -645,8 +619,8 @@ public class Base64 extends BaseNCodec {
/**
* Returns whether or not the {@code octet} is in the Base64 alphabet.
*
- * @param octet
- * The value to test
+ * @param octet The value to test
+ *
* @return {@code true} if the value is defined in the Base64 alphabet {@code false} otherwise.
*/
@Override
@@ -658,6 +632,7 @@ public class Base64 extends BaseNCodec {
* 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() {
diff --git a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java b/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
index 2eaa78e940..b09e42c4d0 100644
--- a/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
+++ b/java/org/apache/tomcat/util/codec/binary/BaseNCodec.java
@@ -23,7 +23,6 @@ import org.apache.tomcat.util.res.StringManager;
/**
* Abstract superclass for Base-N encoders and decoders.
- *
* <p>
* This class is thread-safe.
* </p>
@@ -36,17 +35,16 @@ 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.
+ * 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.
+ * 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;
@@ -72,8 +70,8 @@ public abstract class BaseNCodec {
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).
+ * 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;
@@ -91,9 +89,10 @@ public abstract class BaseNCodec {
@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);
+ 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);
}
}
@@ -105,8 +104,7 @@ public abstract class BaseNCodec {
static final int EOF = -1;
/**
- * MIME chunk size per RFC 2045 section 6.8.
- *
+ * 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.
@@ -119,20 +117,18 @@ public abstract class BaseNCodec {
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
+ * 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>
+ * <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;
@@ -149,15 +145,16 @@ public abstract class BaseNCodec {
*
* @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
*/
- static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
+ 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.
+ * 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) {
@@ -178,9 +175,12 @@ public abstract class BaseNCodec {
/**
* Increases our buffer by the {@link #DEFAULT_BUFFER_RESIZE_FACTOR}.
- * @param context the context to be used
+ *
+ * @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) {
@@ -209,8 +209,7 @@ public abstract class BaseNCodec {
private final int encodedBlockSize;
/**
- * Chunksize for encoding. Not used when decoding.
- * A value of zero or less implies no chunking of the encoded data.
+ * 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;
@@ -221,31 +220,31 @@ public abstract class BaseNCodec {
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.
+ * 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 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) {
+ 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.
+ * 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 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.
+ * @param pad byte used as padding byte.
*/
- protected BaseNCodec(final int unencodedBlockSize, final int encodedBlockSize,
- final int lineLength, final int chunkSeparatorLength, final byte pad) {
+ 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;
@@ -258,19 +257,19 @@ public abstract class BaseNCodec {
* 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
+ 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.
+ * 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
*
- * Intended for use in checking line-ending arrays
+ * @param arrayOctet byte array to test
*
- * @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) {
@@ -288,8 +287,8 @@ public abstract class BaseNCodec {
/**
* Decodes a byte[] containing characters in the Base-N alphabet.
*
- * @param pArray
- * A byte array containing Base-N character data
+ * @param pArray A byte array containing Base-N character data
+ *
* @return a byte array containing binary data
*/
public byte[] decode(final byte[] pArray) {
@@ -314,8 +313,8 @@ public abstract class BaseNCodec {
/**
* Decodes a String containing characters in the Base-N alphabet.
*
- * @param pArray
- * A String containing Base-N character data
+ * @param pArray A String containing Base-N character data
+ *
* @return a byte array containing binary data
*/
public byte[] decode(final String pArray) {
@@ -325,8 +324,8 @@ public abstract class BaseNCodec {
/**
* Encodes a byte[] containing binary data, into a byte[] containing characters in the alphabet.
*
- * @param pArray
- * a byte array containing binary data
+ * @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) {
@@ -337,16 +336,14 @@ public abstract class BaseNCodec {
}
/**
- * 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.
+ * 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) {
@@ -365,32 +362,35 @@ public abstract class BaseNCodec {
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.
+ * 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){
+ */
+ 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 size minimum spare space required
* @param context the context to be used
+ *
* @return the buffer
*/
- protected byte[] ensureBufferSize(final int size, final Context context){
+ 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
+ // x + y > z == x + y - z > 0
} else if (context.pos + size - context.buffer.length > 0) {
return resizeBuffer(context, context.pos + size);
}
@@ -411,16 +411,16 @@ public abstract class BaseNCodec {
*
* @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
+ * @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;
+ 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;
+ len += (len + lineLength - 1) / lineLength * chunkSeparatorLength;
}
return len;
}
@@ -429,15 +429,15 @@ public abstract class BaseNCodec {
* 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
+ 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.
+ * Returns whether or not the {@code octet} is in the current alphabet. Does not allow whitespace or pad.
*
* @param value The value to test
*
@@ -452,14 +452,11 @@ public abstract class BaseNCodec {
* 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
+ * @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) {
diff --git a/java/org/apache/tomcat/util/codec/binary/StringUtils.java b/java/org/apache/tomcat/util/codec/binary/StringUtils.java
index cbc97cead6..8943366b50 100644
--- a/java/org/apache/tomcat/util/codec/binary/StringUtils.java
+++ b/java/org/apache/tomcat/util/codec/binary/StringUtils.java
@@ -21,13 +21,15 @@ 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="https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html">
- * Standard charsets</a>.
- *
- * <p>This class is immutable and thread-safe.</p>
+ * specified in <a href="https://docs.oracle.com/javase/8/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
*
* @deprecated Unused. This class will be removed in Tomcat 11 onwards.
@@ -38,10 +40,9 @@ 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}
+ * @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) {
@@ -52,13 +53,15 @@ public class StringUtils {
* 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}
+ * @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.
+ *
+ * @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) {
@@ -68,14 +71,13 @@ public class StringUtils {
/**
* 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}
+ * @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);
@@ -84,13 +86,14 @@ public class StringUtils {
/**
* 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.
+ * @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) {
@@ -100,13 +103,14 @@ public class StringUtils {
/**
* 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.
+ * @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) {
diff --git a/java/org/apache/tomcat/util/codec/binary/package-info.java b/java/org/apache/tomcat/util/codec/binary/package-info.java
index c41bd15a4e..f3560dd017 100644
--- a/java/org/apache/tomcat/util/codec/binary/package-info.java
+++ b/java/org/apache/tomcat/util/codec/binary/package-info.java
@@ -16,8 +16,6 @@
*/
/**
- * Base64 String encoding and decoding.
- *
- * Unused. This package will be removed in Tomcat 11 onwards.
+ * Base64 String encoding and decoding. Unused. This package will be removed in Tomcat 11 onwards.
*/
package org.apache.tomcat.util.codec.binary;
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org