stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
J. Duke 2017-07-05 21:41:36 +02:00
commit 834091a774
245 changed files with 12667 additions and 8352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.hgignore
View File

@ -1,5 +1,6 @@
^build/
^dist/
^.idea/
nbproject/private/
^webrev
^.hgtip

1
.hgtags-top-repo
View File

@ -360,3 +360,4 @@ f900d5afd9c83a0df8f36161c27c5e4c86a66f4c jdk-9+111
09617ce980b99d49abfd54dacfed353c47e2a115 jdk-9+115
6743a8e0cab7b5f6f4a0575f6664892f0ab740af jdk-9+116
e882bcdbdac436523f3d5681611d3118a3804ea7 jdk-9+117
047f95de8f918d8ff5e8cd2636a2abb5c3c8adb8 jdk-9+118

14
common/autoconf/flags.m4
View File

@ -768,7 +768,7 @@ AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],
$2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
;;
esac
TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: 6, IF_AT_LEAST: FLAGS_SETUP_GCC6_COMPILER_FLAGS)
TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: 6, PREFIX: $2, IF_AT_LEAST: FLAGS_SETUP_GCC6_COMPILER_FLAGS)
elif test "x$TOOLCHAIN_TYPE" = xclang; then
$2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"
@ -964,7 +964,7 @@ AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],
-Wunused-value -Woverloaded-virtual"
if test "x$TOOLCHAIN_TYPE" = xgcc; then
TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: [4.8],
TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: [4.8], PREFIX: $2,
IF_AT_LEAST: [
# These flags either do not work or give spurious warnings prior to gcc 4.8.
$2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-format-zero-length -Wtype-limits -Wuninitialized"
@ -1411,9 +1411,15 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC],
DISABLE_WARNING_PREFIX=
fi
CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
# Repeate the check for the BUILD_CC
# Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset
# CFLAGS since any target specific flags will likely not work with the
# build compiler
CC_OLD="$CC"
CXX_OLD="$CXX"
CC="$BUILD_CC"
CXX="$BUILD_CXX"
CFLAGS_OLD="$CFLAGS"
CFLAGS=""
FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [-Wno-this-is-a-warning-that-do-not-exist],
IF_TRUE: [BUILD_CC_CAN_DISABLE_WARNINGS=true],
IF_FALSE: [BUILD_CC_CAN_DISABLE_WARNINGS=false]
@ -1424,6 +1430,8 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC],
BUILD_CC_DISABLE_WARNING_PREFIX=
fi
CC="$CC_OLD"
CXX="$CXX_OLD"
CFLAGS="$CFLAGS_OLD"
;;
clang)
DISABLE_WARNING_PREFIX="-Wno-"

354
common/autoconf/generated-configure.sh
View File

@ -4900,6 +4900,8 @@ TOOLCHAIN_MINIMUM_VERSION_xlc=""
# Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
# Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
# $1 - optional variable prefix for compiler and version variables (BUILD_)
# $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
# Check if the configured compiler (C and C++) is of a specific version or
@ -4909,6 +4911,7 @@ TOOLCHAIN_MINIMUM_VERSION_xlc=""
# VERSION: The version string to check against the found version
# IF_AT_LEAST: block to run if the compiler is at least this version (>=)
# IF_OLDER_THAN: block to run if the compiler is older than this version (<)
# PREFIX: Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
@ -5073,7 +5076,7 @@ VS_SDK_PLATFORM_NAME_2013=
#CUSTOM_AUTOCONF_INCLUDE
# Do not change or remove the following line, it is needed for consistency checks:
DATE_WHEN_GENERATED=1462806878
DATE_WHEN_GENERATED=1462970869
###############################################################################
#
@ -34795,19 +34798,19 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
$as_echo "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
$as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
fi
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
if [[ "$CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
if [[ "[$]CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
$as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
fi
if [[ "$CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
if [[ "[$]CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&5
$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
fi
@ -34850,6 +34853,13 @@ $as_echo "$as_me: WARNING: C compiler version number has a part larger than 9999
@ -34897,6 +34907,8 @@ $as_echo "$as_me: WARNING: You are using $TOOLCHAIN_TYPE older than $TOOLCHAIN_M
fi
#
@ -46475,6 +46487,268 @@ $as_echo "$as_me: Rewriting BUILD_STRIP to \"$new_complete\"" >&6;}
BUILD_LDCXX="$BUILD_CXX"
PATH="$OLDPATH"
COMPILER=$BUILD_CC
COMPILER_NAME=BuildC
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
# cc -V output typically looks like
# cc: Sun C 5.12 Linux_i386 2011/11/16
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
# Check that this is likely to be the Solaris Studio cc.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
if test $? -ne 0; then
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Remove usage instructions (if present), and
# collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *[Uu]sage:.*//'`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
# xlc -qversion output typically looks like
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
# Version: 11.01.0000.0015
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
# Check that this is likely to be the IBM XL C compiler.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
if test $? -ne 0; then
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
# There is no specific version flag, but all output starts with a version string.
# First line typically looks something like:
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
# Check that this is likely to be Microsoft CL.EXE.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
# gcc --version output typically looks like
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
# Copyright (C) 2013 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
# Check that this is likely to be GCC.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Remove Copyright and legalese from version string, and
# collapse into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *Copyright .*//'`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xclang; then
# clang --version output typically looks like
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
# clang version 3.3 (tags/RELEASE_33/final)
# or
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
# Target: x86_64-pc-linux-gnu
# Thread model: posix
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
# Check that this is likely to be clang
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
else
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
fi
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
BUILD_CC_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
BUILD_CC_VERSION_STRING="$COMPILER_VERSION_STRING"
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
COMPILER=$BUILD_CXX
COMPILER_NAME=BuildC++
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
# cc -V output typically looks like
# cc: Sun C 5.12 Linux_i386 2011/11/16
COMPILER_VERSION_OUTPUT=`$COMPILER -V 2>&1`
# Check that this is likely to be the Solaris Studio cc.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
if test $? -ne 0; then
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Remove usage instructions (if present), and
# collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *[Uu]sage:.*//'`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e "s/^.*[ ,\t]$COMPILER_NAME[ ,\t]\([1-9]\.[0-9][0-9]*\).*/\1/"`
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
# xlc -qversion output typically looks like
# IBM XL C/C++ for AIX, V11.1 (5724-X13)
# Version: 11.01.0000.0015
COMPILER_VERSION_OUTPUT=`$COMPILER -qversion 2>&1`
# Check that this is likely to be the IBM XL C compiler.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
if test $? -ne 0; then
ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.*, V\([1-9][0-9.]*\).*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
# There is no specific version flag, but all output starts with a version string.
# First line typically looks something like:
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
# Check that this is likely to be Microsoft CL.EXE.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.*ersion.\([1-9][0-9.]*\) .*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
# gcc --version output typically looks like
# gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
# Copyright (C) 2013 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
# Check that this is likely to be GCC.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Remove Copyright and legalese from version string, and
# collapse into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *Copyright .*//'`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.* \([1-9]\.[0-9.]*\)[^0-9.].*$/\1/'`
elif test "x$TOOLCHAIN_TYPE" = xclang; then
# clang --version output typically looks like
# Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)
# clang version 3.3 (tags/RELEASE_33/final)
# or
# Debian clang version 3.2-7ubuntu1 (tags/RELEASE_32/final) (based on LLVM 3.2)
# Target: x86_64-pc-linux-gnu
# Thread model: posix
COMPILER_VERSION_OUTPUT=`$COMPILER --version 2>&1`
# Check that this is likely to be clang
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
if test $? -ne 0; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
fi
# Collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT`
COMPILER_VERSION_NUMBER=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/^.* version \([1-9][0-9.]*\).*$/\1/'`
else
as_fn_error $? "Unknown toolchain type $TOOLCHAIN_TYPE." "$LINENO" 5
fi
# This sets CC_VERSION_NUMBER or CXX_VERSION_NUMBER. (This comment is a grep marker)
BUILD_CXX_VERSION_NUMBER="$COMPILER_VERSION_NUMBER"
# This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
BUILD_CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
{ $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
if test "x$BUILD_CC_VERSION_NUMBER" != "x$BUILD_CXX_VERSION_NUMBER"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&5
$as_echo "$as_me: WARNING: C and C++ compiler have different version numbers, $BUILD_CC_VERSION_NUMBER vs $BUILD_CXX_VERSION_NUMBER." >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
fi
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
$as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
fi
if [[ "[$]BUILD_CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&5
$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $BUILD_CC_VERSION_NUMBER. Comparisons might be wrong." >&2;}
fi
OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$BUILD_CC_VERSION_NUMBER"`
else
# If we are not cross compiling, use the normal target compilers for
# building the build platform executables.
@ -49122,6 +49396,18 @@ $as_echo "$supports" >&6; }
@ -49711,6 +49997,8 @@ $as_echo "$supports" >&6; }
elif test "x$TOOLCHAIN_TYPE" = xclang; then
JVM_CFLAGS="$JVM_CFLAGS -D_GNU_SOURCE"
@ -49935,6 +50223,18 @@ $as_echo "$supports" >&6; }
@ -49987,6 +50287,8 @@ $as_echo "$supports" >&6; }
fi
if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
# Non-zero builds have stricter warnings
@ -50440,6 +50742,18 @@ $as_echo "$supports" >&6; }
@ -50469,7 +50783,7 @@ $as_echo "$supports" >&6; }
# Version comparison method inspired by http://stackoverflow.com/a/24067243
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
:
else
@ -50488,6 +50802,8 @@ $as_echo "$supports" >&6; }
elif test "x$TOOLCHAIN_TYPE" = xclang; then
OPENJDK_BUILD_JVM_CFLAGS="$OPENJDK_BUILD_JVM_CFLAGS -D_GNU_SOURCE"
@ -50712,6 +51028,18 @@ $as_echo "$supports" >&6; }
@ -50741,7 +51069,7 @@ $as_echo "$supports" >&6; }
# Version comparison method inspired by http://stackoverflow.com/a/24067243
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$REFERENCE_VERSION"`
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
if test $OPENJDK_BUILD_COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
:
# These flags either do not work or give spurious warnings prior to gcc 4.8.
@ -50764,6 +51092,8 @@ $as_echo "$supports" >&6; }
fi
if ! [[ " $JVM_VARIANTS " =~ " zero " ]] && ! [[ " $JVM_VARIANTS " =~ " zeroshark " ]] ; then
# Non-zero builds have stricter warnings
@ -51918,9 +52248,15 @@ $as_echo "$supports" >&6; }
DISABLE_WARNING_PREFIX=
fi
CFLAGS_WARNINGS_ARE_ERRORS="-Werror"
# Repeate the check for the BUILD_CC
# Repeate the check for the BUILD_CC and BUILD_CXX. Need to also reset
# CFLAGS since any target specific flags will likely not work with the
# build compiler
CC_OLD="$CC"
CXX_OLD="$CXX"
CC="$BUILD_CC"
CXX="$BUILD_CXX"
CFLAGS_OLD="$CFLAGS"
CFLAGS=""
@ -52198,6 +52534,8 @@ $as_echo "$supports" >&6; }
BUILD_CC_DISABLE_WARNING_PREFIX=
fi
CC="$CC_OLD"
CXX="$CXX_OLD"
CFLAGS="$CFLAGS_OLD"
;;
clang)
DISABLE_WARNING_PREFIX="-Wno-"

25
common/autoconf/toolchain.m4
View File

@ -59,23 +59,25 @@ TOOLCHAIN_MINIMUM_VERSION_xlc=""
# Prepare the system so that TOOLCHAIN_CHECK_COMPILER_VERSION can be called.
# Must have CC_VERSION_NUMBER and CXX_VERSION_NUMBER.
# $1 - optional variable prefix for compiler and version variables (BUILD_)
# $2 - optional variable prefix for comparable variable (OPENJDK_BUILD_)
AC_DEFUN([TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS],
[
if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
AC_MSG_WARN([C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER.])
if test "x[$]$1CC_VERSION_NUMBER" != "x[$]$1CXX_VERSION_NUMBER"; then
AC_MSG_WARN([C and C++ compiler have different version numbers, [$]$1CC_VERSION_NUMBER vs [$]$1CXX_VERSION_NUMBER.])
AC_MSG_WARN([This typically indicates a broken setup, and is not supported])
fi
# We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
if [ [[ "$CC_VERSION_NUMBER" =~ (.*\.){3} ]] ]; then
AC_MSG_WARN([C compiler version number has more than three parts (X.Y.Z): $CC_VERSION_NUMBER. Comparisons might be wrong.])
if [ [[ "[$]$1CC_VERSION_NUMBER" =~ (.*\.){3} ]] ]; then
AC_MSG_WARN([C compiler version number has more than three parts (X.Y.Z): [$]$1CC_VERSION_NUMBER. Comparisons might be wrong.])
fi
if [ [[ "$CC_VERSION_NUMBER" =~ [0-9]{6} ]] ]; then
AC_MSG_WARN([C compiler version number has a part larger than 99999: $CC_VERSION_NUMBER. Comparisons might be wrong.])
if [ [[ "[$]$1CC_VERSION_NUMBER" =~ [0-9]{6} ]] ]; then
AC_MSG_WARN([C compiler version number has a part larger than 99999: [$]$1CC_VERSION_NUMBER. Comparisons might be wrong.])
fi
COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", [$]1, [$]2, [$]3) }' <<< "$CC_VERSION_NUMBER"`
$2COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", [$]1, [$]2, [$]3) }' <<< "[$]$1CC_VERSION_NUMBER"`
])
# Check if the configured compiler (C and C++) is of a specific version or
@ -85,8 +87,9 @@ AC_DEFUN([TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS],
# VERSION: The version string to check against the found version
# IF_AT_LEAST: block to run if the compiler is at least this version (>=)
# IF_OLDER_THAN: block to run if the compiler is older than this version (<)
# PREFIX: Optional variable prefix for compiler to compare version for (OPENJDK_BUILD_)
BASIC_DEFUN_NAMED([TOOLCHAIN_CHECK_COMPILER_VERSION],
[*VERSION IF_AT_LEAST IF_OLDER_THAN], [$@],
[*VERSION PREFIX IF_AT_LEAST IF_OLDER_THAN], [$@],
[
# Need to assign to a variable since m4 is blocked from modifying parts in [].
REFERENCE_VERSION=ARG_VERSION
@ -102,7 +105,7 @@ BASIC_DEFUN_NAMED([TOOLCHAIN_CHECK_COMPILER_VERSION],
# Version comparison method inspired by http://stackoverflow.com/a/24067243
COMPARABLE_REFERENCE_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", [$]1, [$]2, [$]3) }' <<< "$REFERENCE_VERSION"`
if test $COMPARABLE_ACTUAL_VERSION -ge $COMPARABLE_REFERENCE_VERSION ; then
if test [$]ARG_PREFIX[COMPARABLE_ACTUAL_VERSION] -ge $COMPARABLE_REFERENCE_VERSION ; then
:
ARG_IF_AT_LEAST
else
@ -808,6 +811,10 @@ AC_DEFUN_ONCE([TOOLCHAIN_SETUP_BUILD_COMPILERS],
BUILD_LDCXX="$BUILD_CXX"
PATH="$OLDPATH"
TOOLCHAIN_EXTRACT_COMPILER_VERSION(BUILD_CC, [BuildC])
TOOLCHAIN_EXTRACT_COMPILER_VERSION(BUILD_CXX, [BuildC++])
TOOLCHAIN_PREPARE_FOR_VERSION_COMPARISONS([BUILD_], [OPENJDK_BUILD_])
else
# If we are not cross compiling, use the normal target compilers for
# building the build platform executables.

199
common/bin/idea.sh Normal file
View File

@ -0,0 +1,199 @@
#!/bin/sh
#
# Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#
# Shell script for generating an IDEA project from a given list of modules
usage() {
echo "usage: $0 [-h|--help] [-v|--verbose] [-o|--output <path>] [modules]+"
exit 1
}
SCRIPT_DIR=`dirname $0`
PWD=`pwd`
cd $SCRIPT_DIR; SCRIPT_DIR=`pwd`
cd ../../; TOP=`pwd`; cd $PWD
IDEA_OUTPUT=$TOP/.idea
VERBOSE="false"
while [ $# -gt 0 ]
do
case $1 in
-h | --help )
usage
;;
-v | --vebose )
VERBOSE="true"
;;
-o | --output )
IDEA_OUTPUT=$2
shift
;;
-*) # bad option
usage
;;
* ) # non option
break
;;
esac
shift
done
mkdir $IDEA_OUTPUT || exit 1
cd $IDEA_OUTPUT; IDEA_OUTPUT=`pwd`
IDEA_MAKE="$TOP/make/idea"
IDEA_TEMPLATE="$IDEA_MAKE/template"
IML_TEMPLATE="$IDEA_TEMPLATE/jdk.iml"
ANT_TEMPLATE="$IDEA_TEMPLATE/ant.xml"
IDEA_IML="$IDEA_OUTPUT/jdk.iml"
IDEA_ANT="$IDEA_OUTPUT/ant.xml"
if [ "$VERBOSE" = "true" ] ; then
echo "output dir: $IDEA_OUTPUT"
echo "idea template dir: $IDEA_TEMPLATE"
fi
if [ ! -f "$IML_TEMPLATE" ] ; then
echo "FATAL: cannot find $IML_TEMPLATE" >&2; exit 1
fi
if [ ! -f "$ANT_TEMPLATE" ] ; then
echo "FATAL: cannot find $ANT_TEMPLATE" >&2; exit 1
fi
cp -r "$IDEA_TEMPLATE"/* "$IDEA_OUTPUT"
cd $TOP ; make -f "$IDEA_MAKE/idea.gmk" -I make/common idea MAKEOVERRIDES= OUT=$IDEA_OUTPUT/env.cfg MODULES="$*" || exit 1
cd $SCRIPT_DIR
. $IDEA_OUTPUT/env.cfg
# Expect MODULE_ROOTS, MODULE_NAMES, BOOT_JDK & SPEC to be set
if [ "x$MODULE_ROOTS" = "x" ] ; then
echo "FATAL: MODULE_ROOTS is empty" >&2; exit 1
fi
if [ "x$MODULE_NAMES" = "x" ] ; then
echo "FATAL: MODULE_NAMES is empty" >&2; exit 1
fi
if [ "x$BOOT_JDK" = "x" ] ; then
echo "FATAL: BOOT_JDK is empty" >&2; exit 1
fi
if [ "x$SPEC" = "x" ] ; then
echo "FATAL: SPEC is empty" >&2; exit 1
fi
SOURCE_FOLDER=" <sourceFolder url=\"file://\$MODULE_DIR\$/####\" isTestSource=\"false\" />"
SOURCE_FOLDERS_DONE="false"
addSourceFolder() {
root=$@
relativePath="`echo "$root" | sed -e s@"$TOP/\(.*$\)"@"\1"@`"
folder="`echo "$SOURCE_FOLDER" | sed -e s@"\(.*/\)####\(.*\)"@"\1$relativePath\2"@`"
printf "%s\n" "$folder" >> $IDEA_IML
}
### Generate project iml
RELATIVE_BUILD_DIR="`dirname $SPEC | sed -e s@"$TOP/\(.*$\)"@"\1"@`"
rm -f $IDEA_IML
while IFS= read -r line
do
if echo "$line" | egrep "^ .* <sourceFolder.*####" > /dev/null ; then
if [ "$SOURCE_FOLDERS_DONE" = "false" ] ; then
SOURCE_FOLDERS_DONE="true"
for root in $MODULE_ROOTS; do
addSourceFolder $root
done
fi
elif echo "$line" | egrep "^ .* <excludeFolder.*####" > /dev/null ; then
ul="`echo "$line" | sed -e s@"\(.*/\)####\(.*\)"@"\1$RELATIVE_BUILD_DIR\2"@`"
printf "%s\n" "$ul" >> $IDEA_IML
else
printf "%s\n" "$line" >> $IDEA_IML
fi
done < "$IML_TEMPLATE"
MODULE_NAME=" <property name=\"module.name\" value=\"####\" />"
addModuleName() {
mn="`echo "$MODULE_NAME" | sed -e s@"\(.*\)####\(.*\)"@"\1$MODULE_NAMES\2"@`"
printf "%s\n" "$mn" >> $IDEA_ANT
}
BUILD_DIR=" <property name=\"build.target.dir\" value=\"####\" />"
addBuildDir() {
DIR=`dirname $SPEC`
mn="`echo "$BUILD_DIR" | sed -e s@"\(.*\)####\(.*\)"@"\1$DIR\2"@`"
printf "%s\n" "$mn" >> $IDEA_ANT
}
### Generate ant.xml
rm -f $IDEA_ANT
while IFS= read -r line
do
if echo "$line" | egrep "^ .* <property name=\"module.name\"" > /dev/null ; then
addModuleName
elif echo "$line" | egrep "^ .* <property name=\"build.target.dir\"" > /dev/null ; then
addBuildDir
else
printf "%s\n" "$line" >> $IDEA_ANT
fi
done < "$ANT_TEMPLATE"
### Compile the custom Logger
CLASSES=$IDEA_OUTPUT/classes
if [ "x$ANT_HOME" = "x" ] ; then
# try some common locations, before giving up
if [ -f "/usr/share/ant/lib/ant.jar" ] ; then
ANT_HOME="/usr/share/ant"
elif [ -f "/usr/local/Cellar/ant/1.9.4/libexec/lib/ant.jar" ] ; then
ANT_HOME="/usr/local/Cellar/ant/1.9.4/libexec"
else
echo "FATAL: cannot find ant. Try setting ANT_HOME." >&2; exit 1
fi
fi
CP=$ANT_HOME/lib/ant.jar
rm -rf $CLASSES; mkdir $CLASSES
if [ "x$CYGPATH" = "x" ] ; then ## CYGPATH may be set in env.cfg
JAVAC_SOURCE_FILE=$IDEA_OUTPUT/src/idea/JdkIdeaAntLogger.java
JAVAC_CLASSES=$CLASSES
JAVAC_CP=$CP
else
JAVAC_SOURCE_FILE=`cygpath -am $IDEA_OUTPUT/src/idea/JdkIdeaAntLogger.java`
JAVAC_CLASSES=`cygpath -am $CLASSES`
JAVAC_CP=`cygpath -am $CP`
fi
$BOOT_JDK/bin/javac -d $JAVAC_CLASSES -cp $JAVAC_CP $JAVAC_SOURCE_FILE

2
common/bin/jib.sh
View File

@ -89,7 +89,7 @@ install_jib() {
fi
if command -v curl > /dev/null; then
getcmd="curl -s"
getcmd="curl -s -L --retry 3 --retry-delay 5"
elif command -v wget > /dev/null; then
getcmd="wget --quiet -O -"
else

1
hotspot/.hgtags
View File

@ -520,3 +520,4 @@ b64432bae5271735fd53300b2005b713e98ef411 jdk-9+114
88dd08d7be0fe7fb9f1914b1628f0aae9bf56e25 jdk-9+115
61a214186dae6811dd989e9165e42f7dbf02acde jdk-9+116
88170d3642905b9e6cac03e8efcc976885a7e6da jdk-9+117
9b1075cac08dc836ec32e7b368415cbe3aceaf8c jdk-9+118

6
hotspot/src/share/vm/prims/jvm.cpp
View File

@ -3387,14 +3387,14 @@ bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessF
return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
}
// Return the first non-null class loader up the execution stack, or null
// if only code from the null class loader is on the stack.
// Return the first user-defined class loader up the execution stack, or null
// if only code from the bootstrap or platform class loader is on the stack.
JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
oop loader = vfst.method()->method_holder()->class_loader();
if (loader != NULL) {
if (loader != NULL && !SystemDictionary::is_platform_class_loader(loader)) {
return JNIHandles::make_local(env, loader);
}
}

33
hotspot/test/Makefile
View File

@ -120,24 +120,33 @@ endif
TEST_ROOT := $(shell pwd)
# Root of all test results
ifdef ALT_OUTPUTDIR
ABS_BUILD_ROOT = $(ALT_OUTPUTDIR)
ifdef TEST_OUTPUT_DIR
$(shell $(MKDIR) -p $(TEST_OUTPUT_DIR)/jtreg)
ABS_TEST_OUTPUT_DIR := \
$(shell $(CD) $(TEST_OUTPUT_DIR)/jtreg && $(PWD))
else
ABS_BUILD_ROOT = $(TEST_ROOT)/../build/$(PLATFORM)-$(ARCH)
ifdef ALT_OUTPUTDIR
ABS_OUTPUTDIR = $(shell $(CD) $(ALT_OUTPUTDIR) && $(PWD))
else
ABS_OUTPUTDIR = $(shell $(CD) $(TEST_ROOT)/.. && $(PWD))
endif
ABS_PLATFORM_BUILD_ROOT = $(ABS_OUTPUTDIR)
ABS_TEST_OUTPUT_DIR := $(ABS_PLATFORM_BUILD_ROOT)/testoutput/$(UNIQUE_DIR)
endif
ABS_TEST_OUTPUT_DIR = $(ABS_BUILD_ROOT)/testoutput/$(UNIQUE_DIR)
# Expect JPRT to set PRODUCT_HOME (the product or jdk in this case to test)
ifndef PRODUCT_HOME
# Try to use j2sdk-image if it exists
ABS_JDK_IMAGE = $(ABS_BUILD_ROOT)/j2sdk-image
PRODUCT_HOME := \
$(shell \
if [ -d $(ABS_JDK_IMAGE) ] ; then \
$(ECHO) "$(ABS_JDK_IMAGE)"; \
else \
$(ECHO) "$(ABS_BUILD_ROOT)" ; \
# Try to use images/jdk if it exists
ABS_JDK_IMAGE = $(ABS_PLATFORM_BUILD_ROOT)/images/jdk
PRODUCT_HOME := \
$(shell \
if [ -d $(ABS_JDK_IMAGE) ] ; then \
$(ECHO) "$(ABS_JDK_IMAGE)"; \
else \
$(ECHO) "$(ABS_PLATFORM_BUILD_ROOT)"; \
fi)
PRODUCT_HOME := $(PRODUCT_HOME)
endif
# Expect JPRT to set JAVA_ARGS (e.g. -server etc.)

1
jdk/.hgtags
View File

@ -360,3 +360,4 @@ bb8379287f3736f38c52b2d1418784e2592461d1 jdk-9+114
35225b837d66582037eeadeb471c13235dfd793d jdk-9+115
baeb5edb38939cdb78ae0ac6f4fd368465cbf188 jdk-9+116
4da0f73ce03aaf245b92cc040cc0ab0e3fa54dc2 jdk-9+117
e1eba5cfa5cc8c66d524396a05323dc93568730a jdk-9+118

4
jdk/make/Tools.gmk
View File

@ -37,10 +37,6 @@ BUILD_TOOLS_JDK := $(call SetupJavaCompilationCompileTarget, \
################################################################################
# Add a checksum ("jsum") to the end of a text file. Prevents trivial tampering with class lists.
TOOL_ADDJSUM = $(JAVA_SMALL) -cp $(BUILDTOOLS_OUTPUTDIR)/jdk_tools_classes \
build.tools.addjsum.AddJsum
ifeq ($(BOOT_JDK_MODULAR), true)
COMPILEFONTCONFIG_ADD_EXPORTS := -XaddExports:java.desktop/sun.awt=ALL-UNNAMED
endif

8
jdk/make/launcher/Launcher-java.base.gmk
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -25,11 +25,11 @@
include LauncherCommon.gmk
JAVA_RC_FLAGS += -i $(JDK_TOPDIR)/src/java.base/windows/native/common
JAVA_RC_FLAGS += -I $(JDK_TOPDIR)/src/java.base/windows/native/common
ifdef OPENJDK
JAVA_RC_FLAGS += -i "$(JDK_TOPDIR)/src/java.base/windows/native/launcher/icons"
JAVA_RC_FLAGS += -I $(JDK_TOPDIR)/src/java.base/windows/native/launcher/icons
else
JAVA_RC_FLAGS += -i "$(JDK_TOPDIR)/src/closed/java.base/windows/native/launcher/icons"
JAVA_RC_FLAGS += -I $(JDK_TOPDIR)/src/closed/java.base/windows/native/launcher/icons
endif
################################################################################

4
jdk/make/lib/Awt2dLibraries.gmk
View File

@ -224,9 +224,9 @@ ifeq ($(OPENJDK_TARGET_OS), windows)
endif
ifdef OPENJDK
LIBAWT_RC_FLAGS := -i "$(JDK_TOPDIR)/src/java.base/windows/native/launcher/icons"
LIBAWT_RC_FLAGS := -I $(JDK_TOPDIR)/src/java.base/windows/native/launcher/icons
else
LIBAWT_RC_FLAGS := -i "$(JDK_TOPDIR)/src/closed/java.base/windows/native/launcher/icons"
LIBAWT_RC_FLAGS := -I $(JDK_TOPDIR)/src/closed/java.base/windows/native/launcher/icons
endif
LIBAWT_VERSIONINFO_RESOURCE := $(JDK_TOPDIR)/src/java.desktop/windows/native/libawt/windows/awt.rc
endif

41
jdk/make/mapfiles/libj2ucrypto/mapfile-vers
View File

@ -1,5 +1,5 @@
#
# Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -30,28 +30,35 @@ SUNWprivate_1.1 {
JNI_OnLoad;
Java_com_oracle_security_ucrypto_UcryptoProvider_loadLibraries;
Java_com_oracle_security_ucrypto_UcryptoProvider_getMechList;
Java_com_oracle_security_ucrypto_NativeDigest_nativeInit;
Java_com_oracle_security_ucrypto_NativeDigestMD_nativeInit;
Java_com_oracle_security_ucrypto_NativeDigestMD_nativeUpdate;
Java_com_oracle_security_ucrypto_NativeDigestMD_nativeDigest;
Java_com_oracle_security_ucrypto_NativeDigestMD_nativeClone;
Java_com_oracle_security_ucrypto_NativeDigestMD_nativeFree;
Java_com_oracle_security_ucrypto_NativeDigest_nativeInit;
Java_com_oracle_security_ucrypto_NativeDigest_nativeUpdate;
Java_com_oracle_security_ucrypto_NativeDigest_nativeDigest;
Java_com_oracle_security_ucrypto_NativeDigest_nativeClone;
Java_com_oracle_security_ucrypto_NativeDigest_nativeFree;
Java_com_oracle_security_ucrypto_NativeCipher_nativeInit;
Java_com_oracle_security_ucrypto_NativeCipher_nativeUpdate;
Java_com_oracle_security_ucrypto_NativeCipher_nativeFinal;
Java_com_oracle_security_ucrypto_NativeCipher_nativeInit;
Java_com_oracle_security_ucrypto_NativeCipher_nativeUpdate;
Java_com_oracle_security_ucrypto_NativeCipher_nativeFinal;
Java_com_oracle_security_ucrypto_NativeKey_nativeFree;
Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit;
Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit;
Java_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeInit;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal;
Java_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeInit;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI;
Java_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal;
Java_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic;
JavaCritical_com_oracle_security_ucrypto_NativeDigestMD_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeDigestMD_nativeUpdate;
JavaCritical_com_oracle_security_ucrypto_NativeDigestMD_nativeDigest;
JavaCritical_com_oracle_security_ucrypto_NativeDigestMD_nativeClone;
JavaCritical_com_oracle_security_ucrypto_NativeDigestMD_nativeFree;
JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeUpdate;
JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeDigest;
JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeClone;
JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeFree;
JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeUpdate;
@ -60,10 +67,10 @@ SUNWprivate_1.1 {
JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeInit;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI;
JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal;
JavaCritical_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic;
local:

2
jdk/make/mapfiles/libjava/mapfile-vers
View File

@ -262,7 +262,7 @@ SUNWprivate_1.1 {
Java_jdk_internal_reflect_Reflection_getCallerClass__;
Java_jdk_internal_reflect_Reflection_getCallerClass__I;
Java_jdk_internal_reflect_Reflection_getClassAccessFlags;
Java_jdk_internal_misc_VM_latestUserDefinedLoader;
Java_jdk_internal_misc_VM_latestUserDefinedLoader0;
Java_jdk_internal_misc_VM_getuid;
Java_jdk_internal_misc_VM_geteuid;
Java_jdk_internal_misc_VM_getgid;

62
jdk/make/non-build-utils/src/build/tools/makeclasslist/makeClasslist.js
View File

@ -1,62 +0,0 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* This tool is used to help create the class list for class data sharing.
*
* The classlist is produced internally by first running a select number of
* startup benchmarks with the -XX:DumpLoadedClassList=<file> option, then
* running this tool in the following fashion to produce a complete classlist:
*
* jjs -scripting makeClasslist.js -- list1 list2 list3 > classlist.platform
*
* The lists should be listed in roughly smallest to largest order based on
* application size.
*
* After generating the classlist it's necessary to add a checksum (using
* AddJsum.java) before checking it into the workspace as the corresponding
* platform-specific classlist, such as make/data/classlist/classlist.linux
*/
"use strict";
var classlist = [];
var seenClasses = {};
for (var a in $ARG) {
var arg = $ARG[a];
var classes = readFully(arg).replace(/[\r\n]+/g, "\n").split("\n");
for (var c in classes) {
var clazz = classes[c];
if (clazz !== "" && seenClasses[clazz] === undefined) {
seenClasses[clazz] = clazz;
classlist.push(clazz);
}
}
}
for (c in classlist) {
print(classlist[c]);
}

95
jdk/make/src/classes/build/tools/addjsum/AddJsum.java
View File

@ -1,95 +0,0 @@
/*
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package build.tools.addjsum;
import java.io.*;
import java.util.regex.*;
/** Adds a checksum ("jsum") to the end of a text file. The algorithm
used is known to the JVM and prevents trivial tampering with the
class list used for class data sharing.
*/
public class AddJsum {
private static final long JSUM_SEED = 0xCAFEBABEBABECAFEL;
public static void main(String[] args) throws Exception {
if (args.length != 2) {
System.err.println("Usage: java AddJsum [input file name] [output file name]");
System.exit(1);
}
try {
File inFile = new File(args[0]);
File outFile = new File(args[1]);
BufferedReader reader = new BufferedReader(new FileReader(inFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(outFile));
Pattern p = Pattern.compile("# [0-9A-Fa-f]*");
long computedJsum = JSUM_SEED;
String line = null;
while ((line = reader.readLine()) != null) {
if (line.length() > 0 && line.charAt(0) == '#') {
Matcher m = p.matcher(line);
if (!m.matches()) {
writer.write(line);
writer.newLine();
}
} else {
computedJsum = jsum(computedJsum, line);
writer.write(line);
writer.newLine();
}
}
String hex = Long.toHexString(computedJsum);
int diff = 16 - hex.length();
for (int i = 0; i < diff; i++) {
hex = "0" + hex;
}
writer.write("# " + hex);
writer.newLine();
reader.close();
writer.close();
} catch (IOException e) {
System.err.println("Error reading or writing file");
throw(e);
}
}
private static long jsum(long start, String str) {
long h = start;
int len = str.length();
for (int i = 0; i < len; i++) {
char c = str.charAt(i);
if (c <= ' ') {
/* Skip spaces and control characters */
continue;
}
h = 31 * h + c;
}
return h;
}
}

36
jdk/src/java.base/share/classes/java/io/ObjectInputStream.java
View File

@ -603,12 +603,12 @@ public class ObjectInputStream
* Class.forName(desc.getName(), false, loader)
* </pre>
* where <code>loader</code> is determined as follows: if there is a
* method on the current thread's stack whose declaring class was
* defined by a user-defined class loader (and was not a generated to
* implement reflective invocations), then <code>loader</code> is class
* loader corresponding to the closest such method to the currently
* executing frame; otherwise, <code>loader</code> is
* <code>null</code>. If this call results in a
* method on the current thread's stack whose declaring class is not a
* <a href="../lang/ClassLoader.html#builtinLoaders">
* <em>platform class</em></a>, then <code>loader</code> is
* the class loader of such class; otherwise, <code>loader</code>
* is the {@linkplain ClassLoader#getPlatformClassLoader()
* platform class loader}. If this call results in a
* <code>ClassNotFoundException</code> and the name of the passed
* <code>ObjectStreamClass</code> instance is the Java language keyword
* for a primitive type or void, then the <code>Class</code> object
@ -666,12 +666,15 @@ public class ObjectInputStream
* <pre>
* Class.forName(i, false, loader)
* </pre>
* where <code>loader</code> is that of the first non-<code>null</code>
* class loader up the execution stack, or <code>null</code> if no
* non-<code>null</code> class loaders are on the stack (the same class
* loader choice used by the <code>resolveClass</code> method). Unless any
* of the resolved interfaces are non-public, this same value of
* <code>loader</code> is also the class loader passed to
* where <code>loader</code> is determined as follows: if there is a
* method on the current thread's stack whose declaring class is not a
* <a href="../lang/ClassLoader.html#builtinLoaders">
* <em>platform class</em></a>, then <code>loader</code> is
* the class loader of such class; otherwise, <code>loader</code>
* is the {@linkplain ClassLoader#getPlatformClassLoader()
* platform class loader}.
* Unless any of the resolved interfaces are non-public, this same value
* of <code>loader</code> is also the class loader passed to
* <code>Proxy.getProxyClass</code>; if non-public interfaces are present,
* their class loader is passed instead (if more than one non-public
* interface class loader is encountered, an
@ -2154,10 +2157,11 @@ public class ObjectInputStream
int ndoubles);
/**
* Returns the first non-null class loader (not counting class loaders of
* generated reflection implementation classes) up the execution stack, or
* null if only code from the null class loader is on the stack. This
* method is also called via reflection by the following RMI-IIOP class:
* Returns the first non-null and non-platform class loader
* (not counting class loaders of generated reflection implementation classes)
* up the execution stack, or null if only code from the bootstrap and
* platform class loader is on the stack.
* This method is also called via reflection by the following RMI-IIOP class:
*
* com.sun.corba.se.internal.util.JDKClassLoader
*

19
jdk/src/java.base/share/classes/java/lang/Integer.java
View File

@ -1221,13 +1221,13 @@ public final class Integer extends Number implements Comparable<Integer> {
}
/**
* Returns a hash code for a {@code int} value; compatible with
* Returns a hash code for an {@code int} value; compatible with
* {@code Integer.hashCode()}.
*
* @param value the value to hash
* @since 1.8
*
* @return a hash code value for a {@code int} value.
* @return a hash code value for an {@code int} value.
*/
public static int hashCode(int value) {
return value;
@ -1596,7 +1596,7 @@ public final class Integer extends Number implements Comparable<Integer> {
@Native public static final int SIZE = 32;
/**
* The number of bytes used to represent a {@code int} value in two's
* The number of bytes used to represent an {@code int} value in two's
* complement binary form.
*
* @since 1.8
@ -1790,9 +1790,8 @@ public final class Integer extends Number implements Comparable<Integer> {
i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
i = (i << 24) | ((i & 0xff00) << 8) |
((i >>> 8) & 0xff00) | (i >>> 24);
return i;
return reverseBytes(i);
}
/**
@ -1820,10 +1819,10 @@ public final class Integer extends Number implements Comparable<Integer> {
*/
@HotSpotIntrinsicCandidate
public static int reverseBytes(int i) {
return ((i >>> 24) ) |
((i >> 8) & 0xFF00) |
((i << 8) & 0xFF0000) |
((i << 24));
return (i << 24) |
((i & 0xff00) << 8) |
((i >>> 8) & 0xff00) |
(i >>> 24);
}
/**

6
jdk/src/java.base/share/classes/java/lang/Long.java
View File

@ -1952,10 +1952,8 @@ public final class Long extends Number implements Comparable<Long> {
i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
i = (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
return i;
return reverseBytes(i);
}
/**

3
jdk/src/java.base/share/classes/java/lang/SecurityManager.java
View File

@ -1627,8 +1627,7 @@ class SecurityManager {
* @deprecated This method relies on the caller being at a stack depth
* of 4 which is error-prone and cannot be enforced by the runtime.
* Users of this method should instead invoke {@link #checkPermission}
* directly. This method will be changed in a future release
* to check the permission {@code java.security.AllPermission}.
* directly.
* This method is subject to removal in a future version of Java SE.
*
* @see java.lang.reflect.Member

2
jdk/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java
View File

@ -318,7 +318,7 @@ public class ModuleDescriptor
/**
* Tests this module export for equality with the given object.
*
* <p> If the given object is not a {@code Exports} then this method
* <p> If the given object is not an {@code Exports} then this method
* returns {@code false}. Two module exports objects are equal if the
* package names are equal and the set of target module names is equal.
* </p>

2
jdk/src/java.base/share/classes/java/lang/reflect/Field.java
View File

@ -903,7 +903,7 @@ class Field extends AccessibleObject implements Member {
* Sets the value of a field as an {@code int} on the specified object.
* This method is equivalent to
* {@code set(obj, iObj)},
* where {@code iObj} is a {@code Integer} object and
* where {@code iObj} is an {@code Integer} object and
* {@code iObj.intValue() == i}.
*
* @param obj the object whose field should be modified

4
jdk/src/java.base/share/classes/java/lang/reflect/InaccessibleObjectException.java
View File

@ -36,13 +36,13 @@ public class InaccessibleObjectException extends RuntimeException {
private static final long serialVersionUID = 4158786093378140901L;
/**
* Constructs a {@code InaccessibleObjectException} with no detail message.
* Constructs an {@code InaccessibleObjectException} with no detail message.
*/
public InaccessibleObjectException() {
}
/**
* Constructs a {@code InaccessibleObjectException} with the given detail
* Constructs an {@code InaccessibleObjectException} with the given detail
* message.
*
* @param msg

2
jdk/src/java.base/share/classes/java/math/BigInteger.java
View File

@ -4676,7 +4676,7 @@ public class BigInteger extends Number implements Comparable<BigInteger> {
*
* @return this {@code BigInteger} converted to an {@code int}.
* @throws ArithmeticException if the value of {@code this} will
* not exactly fit in a {@code int}.
* not exactly fit in an {@code int}.
* @see BigInteger#intValue
* @since 1.8
*/

2
jdk/src/java.base/share/classes/java/net/InetSocketAddress.java
View File

@ -246,7 +246,7 @@ public class InetSocketAddress
* the range of valid port values, or if the hostname
* parameter is {@code null}.
* @see #isUnresolved()
* @return a {@code InetSocketAddress} representing the unresolved
* @return an {@code InetSocketAddress} representing the unresolved
* socket address
* @since 1.5
*/

4
jdk/src/java.base/share/classes/java/net/URLDecoder.java
View File

@ -106,8 +106,8 @@ public class URLDecoder {
}
/**
* Decodes a {@code application/x-www-form-urlencoded} string using a specific
* encoding scheme.
* Decodes an {@code application/x-www-form-urlencoded} string using
* a specific encoding scheme.
* The supplied encoding is used to determine
* what characters are represented by any consecutive sequences of the
* form "<i>{@code %xy}</i>".

2
jdk/src/java.base/share/classes/java/net/URLEncoder.java
View File

@ -225,7 +225,7 @@ public class URLEncoder {
/*
* If this character represents the start of a Unicode
* surrogate pair, then pass in two characters. It's not
* clear what should be done if a bytes reserved in the
* clear what should be done if a byte reserved in the
* surrogate pairs range occurs outside of a legal
* surrogate pair. For now, just treat it as if it were
* any other character.

7
jdk/src/java.base/share/classes/java/security/DrbgParameters.java
View File

@ -196,10 +196,9 @@ import java.util.Objects;
* of the JDK reference implementation.
* <p>
* This implementation supports the Hash_DRBG and HMAC_DRBG mechanisms with
* DRBG algorithm SHA-1, SHA-224, SHA-512/224, SHA-256, SHA-512/256,
* SHA-384 and SHA-512, and CTR_DRBG (both using derivation function and
* not using derivation function) with DRBG algorithm 3KeyTDEA
* (also known as DESede in JCE), AES-128, AES-192 and AES-256.
* DRBG algorithm SHA-224, SHA-512/224, SHA-256, SHA-512/256, SHA-384 and
* SHA-512, and CTR_DRBG (both using derivation function and not using
* derivation function) with DRBG algorithm AES-128, AES-192 and AES-256.
* <p>
* The mechanism name and DRBG algorithm name are determined by the
* {@linkplain Security#getProperty(String) security property}

4
jdk/src/java.base/share/classes/java/security/InvalidAlgorithmParameterException.java
View File

@ -65,7 +65,7 @@ extends GeneralSecurityException {
}
/**
* Creates a {@code InvalidAlgorithmParameterException} with the
* Creates an {@code InvalidAlgorithmParameterException} with the
* specified detail message and cause.
*
* @param message the detail message (which is saved for later retrieval
@ -80,7 +80,7 @@ extends GeneralSecurityException {
}
/**
* Creates a {@code InvalidAlgorithmParameterException} with the
* Creates an {@code InvalidAlgorithmParameterException} with the
* specified cause and a detail message of
* {@code (cause==null ? null : cause.toString())}
* (which typically contains the class and detail message of

4
jdk/src/java.base/share/classes/java/security/InvalidKeyException.java
View File

@ -58,7 +58,7 @@ public class InvalidKeyException extends KeyException {
}
/**
* Creates a {@code InvalidKeyException} with the specified
* Creates an {@code InvalidKeyException} with the specified
* detail message and cause.
*
* @param message the detail message (which is saved for later retrieval
@ -73,7 +73,7 @@ public class InvalidKeyException extends KeyException {
}
/**
* Creates a {@code InvalidKeyException} with the specified cause
* Creates an {@code InvalidKeyException} with the specified cause
* and a detail message of {@code (cause==null ? null : cause.toString())}
* (which typically contains the class and detail message of
* {@code cause}).

13
jdk/src/java.base/share/classes/java/security/ProtectionDomain.java
View File

@ -139,12 +139,10 @@ public class ProtectionDomain {
*/
final Key key = new Key();
private static final Debug debug = Debug.getInstance("domain");
/**
* Creates a new ProtectionDomain with the given CodeSource and
* Permissions. If the permissions object is not null, then
* {@code setReadOnly())} will be called on the passed in
* {@code setReadOnly()} will be called on the passed in
* Permissions object. The only permissions granted to this domain
* are the ones specified; the current Policy will not be consulted.
*
@ -338,6 +336,13 @@ public class ProtectionDomain {
" "+pc+"\n";
}
/*
* holder class for the static field "debug" to delay its initialization
*/
private static class DebugHolder {
private static final Debug debug = Debug.getInstance("domain");
}
/**
* Return true (merge policy permissions) in the following cases:
*
@ -359,7 +364,7 @@ public class ProtectionDomain {
if (sm == null) {
return true;
} else {
if (debug != null) {
if (DebugHolder.debug != null) {
if (sm.getClass().getClassLoader() == null &&
Policy.getPolicyNoCheck().getClass().getClassLoader()
== null) {

2
jdk/src/java.base/share/classes/java/security/Provider.java
View File

@ -1809,7 +1809,7 @@ public abstract class Provider extends Properties {
}
/**
* Return whether this service has its Supported* properties for
* Return whether this service has its supported properties for
* keys defined. Parses the attributes if not yet initialized.
*/
private boolean hasKeyAttributes() {

15
jdk/src/java.base/share/classes/java/security/SecureClassLoader.java
View File

@ -62,8 +62,6 @@ public class SecureClassLoader extends ClassLoader {
private final Map<CodeSourceKey, ProtectionDomain> pdcache
= new ConcurrentHashMap<>(11);
private static final Debug debug = Debug.getInstance("scl");
static {
ClassLoader.registerAsParallelCapable();
}
@ -202,6 +200,13 @@ public class SecureClassLoader extends ClassLoader {
return new Permissions(); // ProtectionDomain defers the binding
}
/*
* holder class for the static field "debug" to delay its initialization
*/
private static class DebugHolder {
private static final Debug debug = Debug.getInstance("scl");
}
/*
* Returned cached ProtectionDomain for the specified CodeSource.
*/
@ -222,9 +227,9 @@ public class SecureClassLoader extends ClassLoader {
= SecureClassLoader.this.getPermissions(cs);
ProtectionDomain pd = new ProtectionDomain(
cs, perms, SecureClassLoader.this, null);
if (debug != null) {
debug.println(" getPermissions " + pd);
debug.println("");
if (DebugHolder.debug != null) {
DebugHolder.debug.println(" getPermissions " + pd);
DebugHolder.debug.println("");
}
return pd;
}

2
jdk/src/java.base/share/classes/java/security/Security.java
View File

@ -549,7 +549,7 @@ public final class Security {
/**
* Returns an array containing all installed providers that satisfy the
* specified* selection criteria, or null if no such providers have been
* specified selection criteria, or null if no such providers have been
* installed. The returned providers are ordered
* according to their
* {@linkplain #insertProviderAt(java.security.Provider, int)

4
jdk/src/java.base/share/classes/java/security/spec/InvalidKeySpecException.java
View File

@ -63,7 +63,7 @@ public class InvalidKeySpecException extends GeneralSecurityException {
}
/**
* Creates a {@code InvalidKeySpecException} with the specified
* Creates an {@code InvalidKeySpecException} with the specified
* detail message and cause.
*
* @param message the detail message (which is saved for later retrieval
@ -78,7 +78,7 @@ public class InvalidKeySpecException extends GeneralSecurityException {
}
/**
* Creates a {@code InvalidKeySpecException} with the specified cause
* Creates an {@code InvalidKeySpecException} with the specified cause
* and a detail message of {@code (cause==null ? null : cause.toString())}
* (which typically contains the class and detail message of
* {@code cause}).

2
jdk/src/java.base/share/classes/java/text/MessageFormat.java
View File

@ -1068,7 +1068,7 @@ public class MessageFormat extends Format {
* index information as described above.
* @return An <code>Object</code> array parsed from the string. In case of
* error, returns null.
* @throws NullPointerException if {@code source} or {@code pos} is null.
* @throws NullPointerException if {@code pos} is null.
*/
public Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);

18
jdk/src/java.base/share/classes/java/time/Instant.java
View File

@ -799,33 +799,33 @@ public final class Instant
* The supported fields behave as follows:
* <ul>
* <li>{@code NANOS} -
* Returns a {@code Instant} with the specified number of nanoseconds added.
* Returns an {@code Instant} with the specified number of nanoseconds added.
* This is equivalent to {@link #plusNanos(long)}.
* <li>{@code MICROS} -
* Returns a {@code Instant} with the specified number of microseconds added.
* Returns an {@code Instant} with the specified number of microseconds added.
* This is equivalent to {@link #plusNanos(long)} with the amount
* multiplied by 1,000.
* <li>{@code MILLIS} -
* Returns a {@code Instant} with the specified number of milliseconds added.
* Returns an {@code Instant} with the specified number of milliseconds added.
* This is equivalent to {@link #plusNanos(long)} with the amount
* multiplied by 1,000,000.
* <li>{@code SECONDS} -
* Returns a {@code Instant} with the specified number of seconds added.
* Returns an {@code Instant} with the specified number of seconds added.
* This is equivalent to {@link #plusSeconds(long)}.
* <li>{@code MINUTES} -
* Returns a {@code Instant} with the specified number of minutes added.
* Returns an {@code Instant} with the specified number of minutes added.
* This is equivalent to {@link #plusSeconds(long)} with the amount
* multiplied by 60.
* <li>{@code HOURS} -
* Returns a {@code Instant} with the specified number of hours added.
* Returns an {@code Instant} with the specified number of hours added.
* This is equivalent to {@link #plusSeconds(long)} with the amount
* multiplied by 3,600.
* <li>{@code HALF_DAYS} -
* Returns a {@code Instant} with the specified number of half-days added.
* Returns an {@code Instant} with the specified number of half-days added.
* This is equivalent to {@link #plusSeconds(long)} with the amount
* multiplied by 43,200 (12 hours).
* <li>{@code DAYS} -
* Returns a {@code Instant} with the specified number of days added.
* Returns an {@code Instant} with the specified number of days added.
* This is equivalent to {@link #plusSeconds(long)} with the amount
* multiplied by 86,400 (24 hours).
* </ul>
@ -958,7 +958,7 @@ public final class Instant
/**
* Returns a copy of this instant with the specified amount subtracted.
* <p>
* This returns a {@code Instant}, based on this one, with the amount
* This returns an {@code Instant}, based on this one, with the amount
* in terms of the unit subtracted. If it is not possible to subtract the amount,
* because the unit is not supported or for some other reason, an exception is thrown.
* <p>

2
jdk/src/java.base/share/classes/java/time/LocalDateTime.java
View File

@ -665,7 +665,7 @@ public final class LocalDateTime
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this date-time, except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY},
* {@code EPOCH_DAY} and {@code PROLEPTIC_MONTH} which are too large to fit in
* an {@code int} and throw a {@code UnsupportedTemporalTypeException}.
* an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method

2
jdk/src/java.base/share/classes/java/time/LocalTime.java
View File

@ -619,7 +619,7 @@ public final class LocalTime
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this time, except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY}
* which are too large to fit in an {@code int} and throw a {@code UnsupportedTemporalTypeException}.
* which are too large to fit in an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method

2
jdk/src/java.base/share/classes/java/time/OffsetDateTime.java
View File

@ -576,7 +576,7 @@ public final class OffsetDateTime
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this date-time, except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY},
* {@code EPOCH_DAY}, {@code PROLEPTIC_MONTH} and {@code INSTANT_SECONDS} which are too
* large to fit in an {@code int} and throw a {@code UnsupportedTemporalTypeException}.
* large to fit in an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method

2
jdk/src/java.base/share/classes/java/time/OffsetTime.java
View File

@ -481,7 +481,7 @@ public final class OffsetTime
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this time, except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY}
* which are too large to fit in an {@code int} and throw a {@code UnsupportedTemporalTypeException}.
* which are too large to fit in an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method

2
jdk/src/java.base/share/classes/java/time/ZonedDateTime.java
View File

@ -793,7 +793,7 @@ public final class ZonedDateTime
* The {@link #isSupported(TemporalField) supported fields} will return valid
* values based on this date-time, except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY},
* {@code EPOCH_DAY}, {@code PROLEPTIC_MONTH} and {@code INSTANT_SECONDS} which are too
* large to fit in an {@code int} and throw a {@code UnsupportedTemporalTypeException}.
* large to fit in an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method

15
jdk/src/java.base/share/classes/java/time/format/DateTimeFormatter.java
View File

@ -308,6 +308,7 @@ import java.util.Set;
* N nano-of-day number 1234000000
*
* V time-zone ID zone-id America/Los_Angeles; Z; -08:30
* v generic time-zone name zone-name Pacific Time; PT
* z time-zone name zone-name Pacific Standard Time; PST
* O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00
* X zone-offset 'Z' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15
@ -365,9 +366,17 @@ import java.util.Set;
* letters throws {@code IllegalArgumentException}.
* <p>
* <b>Zone names</b>: This outputs the display name of the time-zone ID. If the
* count of letters is one, two or three, then the short name is output. If the
* count of letters is four, then the full name is output. Five or more letters
* throws {@code IllegalArgumentException}.
* pattern letter is 'z' the output is the daylight savings aware zone name.
* If there is insufficient information to determine whether DST applies,
* the name ignoring daylight savings time will be used.
* If the count of letters is one, two or three, then the short name is output.
* If the count of letters is four, then the full name is output.
* Five or more letters throws {@code IllegalArgumentException}.
* <p>
* If the pattern letter is 'v' the output provides the zone name ignoring
* daylight savings time. If the count of letters is one, then the short name is output.
* If the count of letters is four, then the full name is output.
* Two, three and five or more letters throw {@code IllegalArgumentException}.
* <p>
* <b>Offset X and x</b>: This formats the offset based on the number of pattern
* letters. One letter outputs just the hour, such as '+01', unless the minute

120
jdk/src/java.base/share/classes/java/time/format/DateTimeFormatterBuilder.java
View File

@ -81,9 +81,11 @@ import java.time.DateTimeException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.Chronology;
import java.time.chrono.Era;
import java.time.chrono.IsoChronology;
@ -1157,10 +1159,11 @@ public final class DateTimeFormatterBuilder {
* result of {@link ZoneOffset#getId()}.
* If the zone is not an offset, the textual name will be looked up
* for the locale set in the {@link DateTimeFormatter}.
* If the temporal object being printed represents an instant, then the text
* will be the summer or winter time text as appropriate.
* If the temporal object being printed represents an instant, or if it is a
* local date-time that is not in a daylight saving gap or overlap then
* the text will be the summer or winter time text as appropriate.
* If the lookup for text does not find any suitable result, then the
* {@link ZoneId#getId() ID} will be printed instead.
* {@link ZoneId#getId() ID} will be printed.
* If the zone cannot be obtained then an exception is thrown unless the
* section of the formatter is optional.
* <p>
@ -1177,7 +1180,7 @@ public final class DateTimeFormatterBuilder {
* @return this, for chaining, not null
*/
public DateTimeFormatterBuilder appendZoneText(TextStyle textStyle) {
appendInternal(new ZoneTextPrinterParser(textStyle, null));
appendInternal(new ZoneTextPrinterParser(textStyle, null, false));
return this;
}
@ -1193,10 +1196,11 @@ public final class DateTimeFormatterBuilder {
* result of {@link ZoneOffset#getId()}.
* If the zone is not an offset, the textual name will be looked up
* for the locale set in the {@link DateTimeFormatter}.
* If the temporal object being printed represents an instant, then the text
* If the temporal object being printed represents an instant, or if it is a
* local date-time that is not in a daylight saving gap or overlap, then the text
* will be the summer or winter time text as appropriate.
* If the lookup for text does not find any suitable result, then the
* {@link ZoneId#getId() ID} will be printed instead.
* {@link ZoneId#getId() ID} will be printed.
* If the zone cannot be obtained then an exception is thrown unless the
* section of the formatter is optional.
* <p>
@ -1220,7 +1224,70 @@ public final class DateTimeFormatterBuilder {
public DateTimeFormatterBuilder appendZoneText(TextStyle textStyle,
Set<ZoneId> preferredZones) {
Objects.requireNonNull(preferredZones, "preferredZones");
appendInternal(new ZoneTextPrinterParser(textStyle, preferredZones));
appendInternal(new ZoneTextPrinterParser(textStyle, preferredZones, false));
return this;
}
//----------------------------------------------------------------------
/**
* Appends the generic time-zone name, such as 'Pacific Time', to the formatter.
* <p>
* This appends an instruction to format/parse the generic textual
* name of the zone to the builder. The generic name is the same throughout the whole
* year, ignoring any daylight saving changes. For example, 'Pacific Time' is the
* generic name, whereas 'Pacific Standard Time' and 'Pacific Daylight Time' are the
* specific names, see {@link #appendZoneText(TextStyle)}.
* <p>
* During formatting, the zone is obtained using a mechanism equivalent
* to querying the temporal with {@link TemporalQueries#zoneId()}.
* If the zone is a {@code ZoneOffset} it will be printed using the
* result of {@link ZoneOffset#getId()}.
* If the zone is not an offset, the textual name will be looked up
* for the locale set in the {@link DateTimeFormatter}.
* If the lookup for text does not find any suitable result, then the
* {@link ZoneId#getId() ID} will be printed.
* If the zone cannot be obtained then an exception is thrown unless the
* section of the formatter is optional.
* <p>
* During parsing, either the textual zone name, the zone ID or the offset
* is accepted. Many textual zone names are not unique, such as CST can be
* for both "Central Standard Time" and "China Standard Time". In this
* situation, the zone id will be determined by the region information from
* formatter's {@link DateTimeFormatter#getLocale() locale} and the standard
* zone id for that area, for example, America/New_York for the America Eastern zone.
* The {@link #appendGenericZoneText(TextStyle, Set)} may be used
* to specify a set of preferred {@link ZoneId} in this situation.
*
* @param textStyle the text style to use, not null
* @return this, for chaining, not null
*/
public DateTimeFormatterBuilder appendGenericZoneText(TextStyle textStyle) {
appendInternal(new ZoneTextPrinterParser(textStyle, null, true));
return this;
}
/**
* Appends the generic time-zone name, such as 'Pacific Time', to the formatter.
* <p>
* This appends an instruction to format/parse the generic textual
* name of the zone to the builder. The generic name is the same throughout the whole
* year, ignoring any daylight saving changes. For example, 'Pacific Time' is the
* generic name, whereas 'Pacific Standard Time' and 'Pacific Daylight Time' are the
* specific names, see {@link #appendZoneText(TextStyle)}.
* <p>
* This method also allows a set of preferred {@link ZoneId} to be
* specified for parsing. The matched preferred zone id will be used if the
* textural zone name being parsed is not unique.
* <p>
* See {@link #appendGenericZoneText(TextStyle)} for details about
* formatting and parsing.
*
* @param textStyle the text style to use, not null
* @param preferredZones the set of preferred zone ids, not null
* @return this, for chaining, not null
*/
public DateTimeFormatterBuilder appendGenericZoneText(TextStyle textStyle,
Set<ZoneId> preferredZones) {
appendInternal(new ZoneTextPrinterParser(textStyle, preferredZones, true));
return this;
}
@ -1416,6 +1483,7 @@ public final class DateTimeFormatterBuilder {
* N nano-of-day number 1234000000
*
* V time-zone ID zone-id America/Los_Angeles; Z; -08:30
* v generic time-zone name zone-name PT, Pacific Time
* z time-zone name zone-name Pacific Standard Time; PST
* O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00;
* X zone-offset 'Z' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15
@ -1537,6 +1605,8 @@ public final class DateTimeFormatterBuilder {
* Pattern Count Equivalent builder methods
* ------- ----- --------------------------
* VV 2 appendZoneId()
* v 1 appendGenericZoneText(TextStyle.SHORT)
* vvvv 4 appendGenericZoneText(TextStyle.FULL)
* z 1 appendZoneText(TextStyle.SHORT)
* zz 2 appendZoneText(TextStyle.SHORT)
* zzz 3 appendZoneText(TextStyle.SHORT)
@ -1643,6 +1713,14 @@ public final class DateTimeFormatterBuilder {
throw new IllegalArgumentException("Pattern letter count must be 2: " + cur);
}
appendZoneId();
} else if (cur == 'v') {
if (count == 1) {
appendGenericZoneText(TextStyle.SHORT);
} else if (count == 4) {
appendGenericZoneText(TextStyle.FULL);
} else {
throw new IllegalArgumentException("Wrong number of pattern letters: " + cur);
}
} else if (cur == 'Z') {
if (count < 4) {
appendOffset("+HHMM", "+0000");
@ -1894,6 +1972,8 @@ public final class DateTimeFormatterBuilder {
// 310 - z - time-zone names, matches LDML and SimpleDateFormat 1 to 4
// 310 - Z - matches SimpleDateFormat and LDML
// 310 - V - time-zone id, matches LDML
// 310 - v - general timezone names, not matching exactly with LDML because LDML specify to fall back
// to 'VVVV' if general-nonlocation unavailable but here it's not falling back because of lack of data
// 310 - p - prefix for padding
// 310 - X - matches LDML, almost matches SDF for 1, exact match 2&3, extended 4&5
// 310 - x - matches LDML
@ -1901,7 +1981,6 @@ public final class DateTimeFormatterBuilder {
// LDML - U - cycle year name, not supported by 310 yet
// LDML - l - deprecated
// LDML - j - not relevant
// LDML - v,V - extended time-zone names
}
//-----------------------------------------------------------------------
@ -3723,9 +3802,12 @@ public final class DateTimeFormatterBuilder {
/** The preferred zoneid map */
private Set<String> preferredZones;
ZoneTextPrinterParser(TextStyle textStyle, Set<ZoneId> preferredZones) {
/** Display in generic time-zone format. True in case of pattern letter 'v' */
private final boolean isGeneric;
ZoneTextPrinterParser(TextStyle textStyle, Set<ZoneId> preferredZones, boolean isGeneric) {
super(TemporalQueries.zone(), "ZoneText(" + textStyle + ")");
this.textStyle = Objects.requireNonNull(textStyle, "textStyle");
this.isGeneric = isGeneric;
if (preferredZones != null && preferredZones.size() != 0) {
this.preferredZones = new HashSet<>();
for (ZoneId id : preferredZones) {
@ -3788,11 +3870,21 @@ public final class DateTimeFormatterBuilder {
String zname = zone.getId();
if (!(zone instanceof ZoneOffset)) {
TemporalAccessor dt = context.getTemporal();
String name = getDisplayName(zname,
dt.isSupported(ChronoField.INSTANT_SECONDS)
? (zone.getRules().isDaylightSavings(Instant.from(dt)) ? DST : STD)
: GENERIC,
context.getLocale());
int type = GENERIC;
if (!isGeneric) {
if (dt.isSupported(ChronoField.INSTANT_SECONDS)) {
type = zone.getRules().isDaylightSavings(Instant.from(dt)) ? DST : STD;
} else if (dt.isSupported(ChronoField.EPOCH_DAY) &&
dt.isSupported(ChronoField.NANO_OF_DAY)) {
LocalDate date = LocalDate.ofEpochDay(dt.getLong(ChronoField.EPOCH_DAY));
LocalTime time = LocalTime.ofNanoOfDay(dt.getLong(ChronoField.NANO_OF_DAY));
LocalDateTime ldt = date.atTime(time);
if (zone.getRules().getTransition(ldt) == null) {
type = zone.getRules().isDaylightSavings(ldt.atZone(zone).toInstant()) ? DST : STD;
}
}
}
String name = getDisplayName(zname, type, context.getLocale());
if (name != null) {
zname = name;
}

14
jdk/src/java.base/share/classes/java/time/temporal/IsoFields.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -402,6 +402,12 @@ public final class IsoFields {
long moy = temporal.getLong(MONTH_OF_YEAR);
return ((moy + 2) / 3);
}
public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
if (isSupportedBy(temporal) == false) {
throw new UnsupportedTemporalTypeException("Unsupported field: QuarterOfYear");
}
return super.rangeRefinedBy(temporal);
}
@SuppressWarnings("unchecked")
@Override
public <R extends Temporal> R adjustInto(R temporal, long newValue) {
@ -529,6 +535,12 @@ public final class IsoFields {
}
return getWeekBasedYear(LocalDate.from(temporal));
}
public ValueRange rangeRefinedBy(TemporalAccessor temporal) {
if (isSupportedBy(temporal) == false) {
throw new UnsupportedTemporalTypeException("Unsupported field: WeekBasedYear");
}
return super.rangeRefinedBy(temporal);
}
@SuppressWarnings("unchecked")
@Override
public <R extends Temporal> R adjustInto(R temporal, long newValue) {

2
jdk/src/java.base/share/classes/java/time/zone/ZoneRules.java
View File

@ -614,7 +614,7 @@ public final class ZoneRules implements Serializable {
* One technique, using this method, would be:
* <pre>
* ZoneOffsetTransition trans = rules.getTransition(localDT);
* if (trans == null) {
* if (trans != null) {
* // Gap or Overlap: determine what to do from transition
* } else {
* // Normal case: only one valid offset

2
jdk/src/java.base/share/classes/java/util/Comparator.java
View File

@ -267,7 +267,7 @@ public interface Comparator<T> {
/**
* Returns a lexicographic-order comparator with a function that
* extracts a {@code int} sort key.
* extracts an {@code int} sort key.
*
* @implSpec This default implementation behaves as if {@code
* thenComparing(comparingInt(keyExtractor))}.

146
jdk/src/java.base/share/classes/java/util/DualPivotQuicksort.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -146,12 +146,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge
@ -598,12 +612,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge
@ -1086,12 +1114,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge
@ -1574,12 +1616,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge
@ -2158,12 +2214,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge
@ -2701,12 +2771,26 @@ final class DualPivotQuicksort {
}
}
// Check special cases
// Implementation note: variable "right" is increased by 1.
if (run[count] == right++) { // The last run contains one element
run[++count] = right;
} else if (count <= 1) { // The array is already sorted
// These invariants should hold true:
// run[0] = 0
// run[<last>] = right + 1; (terminator)
if (count == 0) {
// A single equal run
return;
} else if (count == 1 && run[count] > right) {
// Either a single ascending or a transformed descending run.
// Always check that a final run is a proper terminator, otherwise
// we have an unterminated trailing run, to handle downstream.
return;
}
right++;
if (run[count] < right) {
// Corner case: the final run is not a terminator. This may happen
// if a final run is an equals run, or there is a single-element run
// at the end. Fix up by adding a proper terminator at the end.
// Note that we terminate with (right + 1), incremented earlier.
run[++count] = right;
}
// Determine alternation base for merge

375
jdk/src/java.base/share/classes/java/util/regex/CharPredicates.java Normal file
View File

@ -0,0 +1,375 @@
/*
* Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.regex;
import java.util.HashMap;
import java.util.Locale;
import java.util.regex.Pattern.CharPredicate;
import java.util.regex.Pattern.BmpCharPredicate;
class CharPredicates {
static final CharPredicate ALPHABETIC = Character::isAlphabetic;
// \p{gc=Decimal_Number}
static final CharPredicate DIGIT = Character::isDigit;
static final CharPredicate LETTER = Character::isLetter;
static final CharPredicate IDEOGRAPHIC = Character::isIdeographic;
static final CharPredicate LOWERCASE = Character::isLowerCase;
static final CharPredicate UPPERCASE = Character::isUpperCase;
static final CharPredicate TITLECASE = Character::isTitleCase;
// \p{Whitespace}
static final CharPredicate WHITE_SPACE = ch ->
((((1 << Character.SPACE_SEPARATOR) |
(1 << Character.LINE_SEPARATOR) |
(1 << Character.PARAGRAPH_SEPARATOR)) >> Character.getType(ch)) & 1)
!= 0 || (ch >= 0x9 && ch <= 0xd) || (ch == 0x85);
// \p{gc=Control}
static final CharPredicate CONTROL = ch ->
Character.getType(ch) == Character.CONTROL;
// \p{gc=Punctuation}
static final CharPredicate PUNCTUATION = ch ->
((((1 << Character.CONNECTOR_PUNCTUATION) |
(1 << Character.DASH_PUNCTUATION) |
(1 << Character.START_PUNCTUATION) |
(1 << Character.END_PUNCTUATION) |
(1 << Character.OTHER_PUNCTUATION) |
(1 << Character.INITIAL_QUOTE_PUNCTUATION) |
(1 << Character.FINAL_QUOTE_PUNCTUATION)) >> Character.getType(ch)) & 1)
!= 0;
// \p{gc=Decimal_Number}
// \p{Hex_Digit} -> PropList.txt: Hex_Digit
static final CharPredicate HEX_DIGIT = DIGIT.union(
ch -> (ch >= 0x0030 && ch <= 0x0039) ||
(ch >= 0x0041 && ch <= 0x0046) ||
(ch >= 0x0061 && ch <= 0x0066) ||
(ch >= 0xFF10 && ch <= 0xFF19) ||
(ch >= 0xFF21 && ch <= 0xFF26) ||
(ch >= 0xFF41 && ch <= 0xFF46));
static final CharPredicate ASSIGNED = ch ->
Character.getType(ch) != Character.UNASSIGNED;
// PropList.txt:Noncharacter_Code_Point
static final CharPredicate NONCHARACTER_CODE_POINT = ch ->
(ch & 0xfffe) == 0xfffe || (ch >= 0xfdd0 && ch <= 0xfdef);
// \p{alpha}
// \p{digit}
static final CharPredicate ALNUM = ALPHABETIC.union(DIGIT);
// \p{Whitespace} --
// [\N{LF} \N{VT} \N{FF} \N{CR} \N{NEL} -> 0xa, 0xb, 0xc, 0xd, 0x85
// \p{gc=Line_Separator}
// \p{gc=Paragraph_Separator}]
static final CharPredicate BLANK = ch ->
Character.getType(ch) == Character.SPACE_SEPARATOR ||
ch == 0x9; // \N{HT}
// [^
// \p{space}
// \p{gc=Control}
// \p{gc=Surrogate}
// \p{gc=Unassigned}]
static final CharPredicate GRAPH = ch ->
((((1 << Character.SPACE_SEPARATOR) |
(1 << Character.LINE_SEPARATOR) |
(1 << Character.PARAGRAPH_SEPARATOR) |
(1 << Character.CONTROL) |
(1 << Character.SURROGATE) |
(1 << Character.UNASSIGNED)) >> Character.getType(ch)) & 1)
== 0;
// \p{graph}
// \p{blank}
// -- \p{cntrl}
static final CharPredicate PRINT = GRAPH.union(BLANK).and(CONTROL.negate());
// 200C..200D PropList.txt:Join_Control
static final CharPredicate JOIN_CONTROL = ch -> ch == 0x200C || ch == 0x200D;
// \p{alpha}
// \p{gc=Mark}
// \p{digit}
// \p{gc=Connector_Punctuation}
// \p{Join_Control} 200C..200D
static final CharPredicate WORD =
ALPHABETIC.union(ch -> ((((1 << Character.NON_SPACING_MARK) |
(1 << Character.ENCLOSING_MARK) |
(1 << Character.COMBINING_SPACING_MARK) |
(1 << Character.DECIMAL_DIGIT_NUMBER) |
(1 << Character.CONNECTOR_PUNCTUATION))
>> Character.getType(ch)) & 1) != 0,
JOIN_CONTROL);
/////////////////////////////////////////////////////////////////////////////
private static final HashMap<String, CharPredicate> posix = new HashMap<>(12);
private static final HashMap<String, CharPredicate> uprops = new HashMap<>(18);
private static void defPosix(String name, CharPredicate p) {
posix.put(name, p);
}
private static void defUProp(String name, CharPredicate p) {
uprops.put(name, p);
}
static {
defPosix("ALPHA", ALPHABETIC);
defPosix("LOWER", LOWERCASE);
defPosix("UPPER", UPPERCASE);
defPosix("SPACE", WHITE_SPACE);
defPosix("PUNCT", PUNCTUATION);
defPosix("XDIGIT",HEX_DIGIT);
defPosix("ALNUM", ALNUM);
defPosix("CNTRL", CONTROL);
defPosix("DIGIT", DIGIT);
defPosix("BLANK", BLANK);
defPosix("GRAPH", GRAPH);
defPosix("PRINT", PRINT);
defUProp("ALPHABETIC", ALPHABETIC);
defUProp("ASSIGNED", ASSIGNED);
defUProp("CONTROL", CONTROL);
defUProp("HEXDIGIT", HEX_DIGIT);
defUProp("IDEOGRAPHIC", IDEOGRAPHIC);
defUProp("JOINCONTROL", JOIN_CONTROL);
defUProp("LETTER", LETTER);
defUProp("LOWERCASE", LOWERCASE);
defUProp("NONCHARACTERCODEPOINT", NONCHARACTER_CODE_POINT);
defUProp("TITLECASE", TITLECASE);
defUProp("PUNCTUATION", PUNCTUATION);
defUProp("UPPERCASE", UPPERCASE);
defUProp("WHITESPACE", WHITE_SPACE);
defUProp("WORD", WORD);
defUProp("WHITE_SPACE", WHITE_SPACE);
defUProp("HEX_DIGIT", HEX_DIGIT);
defUProp("NONCHARACTER_CODE_POINT", NONCHARACTER_CODE_POINT);
defUProp("JOIN_CONTROL", JOIN_CONTROL);
}
public static CharPredicate forUnicodeProperty(String propName) {
propName = propName.toUpperCase(Locale.ROOT);
CharPredicate p = uprops.get(propName);
if (p != null)
return p;
return posix.get(propName);
}
public static CharPredicate forPOSIXName(String propName) {
return posix.get(propName.toUpperCase(Locale.ENGLISH));
}
/////////////////////////////////////////////////////////////////////////////
/**
* Returns a predicate matching all characters belong to a named
* UnicodeScript.
*/
static CharPredicate forUnicodeScript(String name) {
final Character.UnicodeScript script;
try {
script = Character.UnicodeScript.forName(name);
return ch -> script == Character.UnicodeScript.of(ch);
} catch (IllegalArgumentException iae) {}
return null;
}
/**
* Returns a predicate matching all characters in a UnicodeBlock.
*/
static CharPredicate forUnicodeBlock(String name) {
final Character.UnicodeBlock block;
try {
block = Character.UnicodeBlock.forName(name);
return ch -> block == Character.UnicodeBlock.of(ch);
} catch (IllegalArgumentException iae) {}
return null;
}
/////////////////////////////////////////////////////////////////////////////
// unicode categories, aliases, properties, java methods ...
private static final HashMap<String, CharPredicate> props = new HashMap<>(128);
/**
* Returns a predicate matching all characters in a named property.
*/
static CharPredicate forProperty(String name) {
return props.get(name);
}
private static void defProp(String name, CharPredicate p) {
props.put(name, p);
}
private static void defCategory(String name, final int typeMask) {
CharPredicate p = ch -> (typeMask & (1 << Character.getType(ch))) != 0;
props.put(name, p);
}
private static void defRange(String name, final int lower, final int upper) {
BmpCharPredicate p = ch -> lower <= ch && ch <= upper;
props.put(name, p);
}
private static void defCtype(String name, final int ctype) {
BmpCharPredicate p = ch -> ch < 128 && ASCII.isType(ch, ctype);
// PrintPattern.pmap.put(p, name);
props.put(name, p);
}
static {
// Unicode character property aliases, defined in
// http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt
defCategory("Cn", 1<<Character.UNASSIGNED);
defCategory("Lu", 1<<Character.UPPERCASE_LETTER);
defCategory("Ll", 1<<Character.LOWERCASE_LETTER);
defCategory("Lt", 1<<Character.TITLECASE_LETTER);
defCategory("Lm", 1<<Character.MODIFIER_LETTER);
defCategory("Lo", 1<<Character.OTHER_LETTER);
defCategory("Mn", 1<<Character.NON_SPACING_MARK);
defCategory("Me", 1<<Character.ENCLOSING_MARK);
defCategory("Mc", 1<<Character.COMBINING_SPACING_MARK);
defCategory("Nd", 1<<Character.DECIMAL_DIGIT_NUMBER);
defCategory("Nl", 1<<Character.LETTER_NUMBER);
defCategory("No", 1<<Character.OTHER_NUMBER);
defCategory("Zs", 1<<Character.SPACE_SEPARATOR);
defCategory("Zl", 1<<Character.LINE_SEPARATOR);
defCategory("Zp", 1<<Character.PARAGRAPH_SEPARATOR);
defCategory("Cc", 1<<Character.CONTROL);
defCategory("Cf", 1<<Character.FORMAT);
defCategory("Co", 1<<Character.PRIVATE_USE);
defCategory("Cs", 1<<Character.SURROGATE);
defCategory("Pd", 1<<Character.DASH_PUNCTUATION);
defCategory("Ps", 1<<Character.START_PUNCTUATION);
defCategory("Pe", 1<<Character.END_PUNCTUATION);
defCategory("Pc", 1<<Character.CONNECTOR_PUNCTUATION);
defCategory("Po", 1<<Character.OTHER_PUNCTUATION);
defCategory("Sm", 1<<Character.MATH_SYMBOL);
defCategory("Sc", 1<<Character.CURRENCY_SYMBOL);
defCategory("Sk", 1<<Character.MODIFIER_SYMBOL);
defCategory("So", 1<<Character.OTHER_SYMBOL);
defCategory("Pi", 1<<Character.INITIAL_QUOTE_PUNCTUATION);
defCategory("Pf", 1<<Character.FINAL_QUOTE_PUNCTUATION);
defCategory("L", ((1<<Character.UPPERCASE_LETTER) |
(1<<Character.LOWERCASE_LETTER) |
(1<<Character.TITLECASE_LETTER) |
(1<<Character.MODIFIER_LETTER) |
(1<<Character.OTHER_LETTER)));
defCategory("M", ((1<<Character.NON_SPACING_MARK) |
(1<<Character.ENCLOSING_MARK) |
(1<<Character.COMBINING_SPACING_MARK)));
defCategory("N", ((1<<Character.DECIMAL_DIGIT_NUMBER) |
(1<<Character.LETTER_NUMBER) |
(1<<Character.OTHER_NUMBER)));
defCategory("Z", ((1<<Character.SPACE_SEPARATOR) |
(1<<Character.LINE_SEPARATOR) |
(1<<Character.PARAGRAPH_SEPARATOR)));
defCategory("C", ((1<<Character.CONTROL) |
(1<<Character.FORMAT) |
(1<<Character.PRIVATE_USE) |
(1<<Character.SURROGATE))); // Other
defCategory("P", ((1<<Character.DASH_PUNCTUATION) |
(1<<Character.START_PUNCTUATION) |
(1<<Character.END_PUNCTUATION) |
(1<<Character.CONNECTOR_PUNCTUATION) |
(1<<Character.OTHER_PUNCTUATION) |
(1<<Character.INITIAL_QUOTE_PUNCTUATION) |
(1<<Character.FINAL_QUOTE_PUNCTUATION)));
defCategory("S", ((1<<Character.MATH_SYMBOL) |
(1<<Character.CURRENCY_SYMBOL) |
(1<<Character.MODIFIER_SYMBOL) |
(1<<Character.OTHER_SYMBOL)));
defCategory("LC", ((1<<Character.UPPERCASE_LETTER) |
(1<<Character.LOWERCASE_LETTER) |
(1<<Character.TITLECASE_LETTER)));
defCategory("LD", ((1<<Character.UPPERCASE_LETTER) |
(1<<Character.LOWERCASE_LETTER) |
(1<<Character.TITLECASE_LETTER) |
(1<<Character.MODIFIER_LETTER) |
(1<<Character.OTHER_LETTER) |
(1<<Character.DECIMAL_DIGIT_NUMBER)));
defRange("L1", 0x00, 0xFF); // Latin-1
props.put("all", ch -> true);
// Posix regular expression character classes, defined in
// http://www.unix.org/onlinepubs/009695399/basedefs/xbd_chap09.html
defRange("ASCII", 0x00, 0x7F); // ASCII
defCtype("Alnum", ASCII.ALNUM); // Alphanumeric characters
defCtype("Alpha", ASCII.ALPHA); // Alphabetic characters
defCtype("Blank", ASCII.BLANK); // Space and tab characters
defCtype("Cntrl", ASCII.CNTRL); // Control characters
defRange("Digit", '0', '9'); // Numeric characters
defCtype("Graph", ASCII.GRAPH); // printable and visible
defRange("Lower", 'a', 'z'); // Lower-case alphabetic
defRange("Print", 0x20, 0x7E); // Printable characters
defCtype("Punct", ASCII.PUNCT); // Punctuation characters
defCtype("Space", ASCII.SPACE); // Space characters
defRange("Upper", 'A', 'Z'); // Upper-case alphabetic
defCtype("XDigit",ASCII.XDIGIT); // hexadecimal digits
// Java character properties, defined by methods in Character.java
defProp("javaLowerCase", java.lang.Character::isLowerCase);
defProp("javaUpperCase", Character::isUpperCase);
defProp("javaAlphabetic", java.lang.Character::isAlphabetic);
defProp("javaIdeographic", java.lang.Character::isIdeographic);
defProp("javaTitleCase", java.lang.Character::isTitleCase);
defProp("javaDigit", java.lang.Character::isDigit);
defProp("javaDefined", java.lang.Character::isDefined);
defProp("javaLetter", java.lang.Character::isLetter);
defProp("javaLetterOrDigit", java.lang.Character::isLetterOrDigit);
defProp("javaJavaIdentifierStart", java.lang.Character::isJavaIdentifierStart);
defProp("javaJavaIdentifierPart", java.lang.Character::isJavaIdentifierPart);
defProp("javaUnicodeIdentifierStart", java.lang.Character::isUnicodeIdentifierStart);
defProp("javaUnicodeIdentifierPart", java.lang.Character::isUnicodeIdentifierPart);
defProp("javaIdentifierIgnorable", java.lang.Character::isIdentifierIgnorable);
defProp("javaSpaceChar", java.lang.Character::isSpaceChar);
defProp("javaWhitespace", java.lang.Character::isWhitespace);
defProp("javaISOControl", java.lang.Character::isISOControl);
defProp("javaMirrored", java.lang.Character::isMirrored);
}
/////////////////////////////////////////////////////////////////////////////
/**
* Posix ASCII variants, not in the lookup map
*/
static final BmpCharPredicate ASCII_DIGIT = ch -> ch < 128 && ASCII.isDigit(ch);
static final BmpCharPredicate ASCII_WORD = ch -> ch < 128 && ASCII.isWord(ch);
static final BmpCharPredicate ASCII_SPACE = ch -> ch < 128 && ASCII.isSpace(ch);
}

98
jdk/src/java.base/share/classes/java/util/regex/IntHashSet.java Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.regex;
import java.util.Arrays;
/**
* A lightweight hashset implementation for positive 'int'. Not safe for
* concurrent access.
*/
class IntHashSet {
private int[] entries;
private int[] hashes;
private int pos = 0;
public IntHashSet() {
this.entries = new int[16 << 1]; // initCapacity = 16;
this.hashes = new int[(16 / 2) | 1]; // odd -> fewer collisions
Arrays.fill(this.entries, -1);
Arrays.fill(this.hashes, -1);
}
public boolean contains(int i) {
int h = hashes[i % hashes.length];
while (h != -1) {
if (entries[h] == i)
return true;
h = entries[h + 1];
}
return false;
}
public void add(int i) {
int h0 = i % hashes.length;
int next = hashes[h0];
// if invoker guarantees contains(i) checked before add(i)
// the following check is not needed.
int next0 = next;
while (next0 != -1) {
if (entries[next0 ] == i)
return;
next0 = entries[next0 + 1];
}
hashes[h0] = pos;
entries[pos++] = i;
entries[pos++] = next;
if (pos == entries.length)
expand();
}
public void clear() {
Arrays.fill(this.entries, -1);
Arrays.fill(this.hashes, -1);
pos = 0;
}
private void expand() {
int[] old = entries;
int[] es = new int[old.length << 1];
int hlen = (old.length / 2) | 1;
int[] hs = new int[hlen];
Arrays.fill(es, -1);
Arrays.fill(hs, -1);
for (int n = 0; n < pos;) { // re-hashing
int i = old[n];
int hsh = i % hlen;
int next = hs[hsh];
hs[hsh] = n;
es[n++] = i;
es[n++] = next;
}
this.entries = es;
this.hashes = hs;
}
}

22
jdk/src/java.base/share/classes/java/util/regex/Matcher.java
View File

@ -177,6 +177,14 @@ public final class Matcher implements MatchResult {
*/
int[] locals;
/**
* Storage used by top greedy Loop node to store a specific hash set to
* keep the beginning index of the failed repetition match. The nodes
* themselves are stateless, so they rely on this field to hold state
* during a match.
*/
IntHashSet[] localsPos;
/**
* Boolean indicating whether or not more input could change
* the results of the last match.
@ -239,6 +247,7 @@ public final class Matcher implements MatchResult {
int parentGroupCount = Math.max(parent.capturingGroupCount, 10);
groups = new int[parentGroupCount * 2];
locals = new int[parent.localCount];
localsPos = new IntHashSet[parent.localTCNCount];
// Put fields into initial states
reset();
@ -375,6 +384,7 @@ public final class Matcher implements MatchResult {
groups[i] = -1;
for (int i = 0; i < locals.length; i++)
locals[i] = -1;
localsPos = new IntHashSet[parentPattern.localTCNCount];
modCount++;
return this;
}
@ -397,6 +407,10 @@ public final class Matcher implements MatchResult {
groups[i] = -1;
for(int i=0; i<locals.length; i++)
locals[i] = -1;
for (int i = 0; i < localsPos.length; i++) {
if (localsPos[i] != null)
localsPos[i].clear();
}
lastAppendPosition = 0;
from = 0;
to = getTextLength();
@ -1706,6 +1720,10 @@ public final class Matcher implements MatchResult {
this.oldLast = oldLast < 0 ? from : oldLast;
for (int i = 0; i < groups.length; i++)
groups[i] = -1;
for (int i = 0; i < localsPos.length; i++) {
if (localsPos[i] != null)
localsPos[i].clear();
}
acceptMode = NOANCHOR;
boolean result = parentPattern.root.match(this, from, text);
if (!result)
@ -1729,6 +1747,10 @@ public final class Matcher implements MatchResult {
this.oldLast = oldLast < 0 ? from : oldLast;
for (int i = 0; i < groups.length; i++)
groups[i] = -1;
for (int i = 0; i < localsPos.length; i++) {
if (localsPos[i] != null)
localsPos[i].clear();
}
acceptMode = anchor;
boolean result = parentPattern.matchRoot.match(this, from, text);
if (!result)

1582
jdk/src/java.base/share/classes/java/util/regex/Pattern.java
View File

File diff suppressed because it is too large Load Diff

220
jdk/src/java.base/share/classes/java/util/regex/PrintPattern.java Normal file
View File

@ -0,0 +1,220 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.regex;
import java.util.HashMap;
import java.util.regex.Pattern.CharPredicate;
import java.util.regex.CharPredicates;
import static java.util.regex.ASCII.*;
/**
* A utility class to print out the pattern node tree.
*/
class PrintPattern {
private static HashMap<Pattern.Node, Integer> ids = new HashMap<>();
private static void print(Pattern.Node node, String text, int depth) {
if (!ids.containsKey(node))
ids.put(node, ids.size());
print("%6d:%" + (depth==0? "": depth<<1) + "s<%s>", ids.get(node), "", text);
if (ids.containsKey(node.next))
print(" (=>%d)", ids.get(node.next));
print("%n");
}
private static void print(String s, int depth) {
print(" %" + (depth==0?"":depth<<1) + "s<%s>%n", "", s);
}
private static void print(String fmt, Object ... args) {
System.err.printf(fmt, args);
}
private static String toStringCPS(int[] cps) {
StringBuilder sb = new StringBuilder(cps.length);
for (int cp : cps)
sb.append(toStringCP(cp));
return sb.toString();
}
private static String toStringCP(int cp) {
return (isPrint(cp) ? "" + (char)cp
: "\\u" + Integer.toString(cp, 16));
}
private static String toStringRange(int min, int max) {
if (max == Pattern.MAX_REPS) {
if (min == 0)
return " * ";
else if (min == 1)
return " + ";
return "{" + min + ", max}";
}
return "{" + min + ", " + max + "}";
}
private static String toStringCtype(int type) {
switch(type) {
case UPPER: return "ASCII.UPPER";
case LOWER: return "ASCII.LOWER";
case DIGIT: return "ASCII.DIGIT";
case SPACE: return "ASCII.SPACE";
case PUNCT: return "ASCII.PUNCT";
case CNTRL: return "ASCII.CNTRL";
case BLANK: return "ASCII.BLANK";
case UNDER: return "ASCII.UNDER";
case ASCII: return "ASCII.ASCII";
case ALPHA: return "ASCII.ALPHA";
case ALNUM: return "ASCII.ALNUM";
case GRAPH: return "ASCII.GRAPH";
case WORD: return "ASCII.WORD";
case XDIGIT: return "ASCII.XDIGIT";
default: return "ASCII ?";
}
}
private static String toString(Pattern.Node node) {
String name = node.getClass().getName();
return name.substring(name.lastIndexOf('$') + 1);
}
static HashMap<CharPredicate, String> pmap;
static {
pmap = new HashMap<>();
pmap.put(Pattern.ALL, "All");
pmap.put(Pattern.DOT, "Dot");
pmap.put(Pattern.UNIXDOT, "UnixDot");
pmap.put(Pattern.VertWS, "VertWS");
pmap.put(Pattern.HorizWS, "HorizWS");
pmap.put(CharPredicates.ASCII_DIGIT, "ASCII.DIGIT");
pmap.put(CharPredicates.ASCII_WORD, "ASCII.WORD");
pmap.put(CharPredicates.ASCII_SPACE, "ASCII.SPACE");
}
static void walk(Pattern.Node node, int depth) {
depth++;
while(node != null) {
String name = toString(node);
String str;
if (node instanceof Pattern.Prolog) {
print(node, name, depth);
// print the loop here
Pattern.Loop loop = ((Pattern.Prolog)node).loop;
name = toString(loop);
str = name + " " + toStringRange(loop.cmin, loop.cmax);
print(loop, str, depth);
walk(loop.body, depth);
print("/" + name, depth);
node = loop;
} else if (node instanceof Pattern.Loop) {
return; // stop here, body.next -> loop
} else if (node instanceof Pattern.Curly) {
Pattern.Curly c = (Pattern.Curly)node;
str = "Curly " + c.type + " " + toStringRange(c.cmin, c.cmax);
print(node, str, depth);
walk(c.atom, depth);
print("/Curly", depth);
} else if (node instanceof Pattern.GroupCurly) {
Pattern.GroupCurly gc = (Pattern.GroupCurly)node;
str = "GroupCurly " + gc.groupIndex / 2 +
", " + gc.type + " " + toStringRange(gc.cmin, gc.cmax);
print(node, str, depth);
walk(gc.atom, depth);
print("/GroupCurly", depth);
} else if (node instanceof Pattern.GroupHead) {
Pattern.GroupHead head = (Pattern.GroupHead)node;
Pattern.GroupTail tail = head.tail;
print(head, "Group.head " + (tail.groupIndex / 2), depth);
walk(head.next, depth);
print(tail, "/Group.tail " + (tail.groupIndex / 2), depth);
node = tail;
} else if (node instanceof Pattern.GroupTail) {
return; // stopper
} else if (node instanceof Pattern.Ques) {
print(node, "Ques " + ((Pattern.Ques)node).type, depth);
walk(((Pattern.Ques)node).atom, depth);
print("/Ques", depth);
} else if (node instanceof Pattern.Branch) {
Pattern.Branch b = (Pattern.Branch)node;
print(b, name, depth);
int i = 0;
while (true) {
if (b.atoms[i] != null) {
walk(b.atoms[i], depth);
} else {
print(" (accepted)", depth);
}
if (++i == b.size)
break;
print("-branch.separator-", depth);
}
node = b.conn;
print(node, "/Branch", depth);
} else if (node instanceof Pattern.BranchConn) {
return;
} else if (node instanceof Pattern.CharProperty) {
str = pmap.get(((Pattern.CharProperty)node).predicate);
if (str == null)
str = toString(node);
else
str = "Single \"" + str + "\"";
print(node, str, depth);
} else if (node instanceof Pattern.SliceNode) {
str = name + " \"" +
toStringCPS(((Pattern.SliceNode)node).buffer) + "\"";
print(node, str, depth);
} else if (node instanceof Pattern.CharPropertyGreedy) {
Pattern.CharPropertyGreedy gcp = (Pattern.CharPropertyGreedy)node;
String pstr = pmap.get(gcp.predicate);
if (pstr == null)
pstr = gcp.predicate.toString();
else
pstr = "Single \"" + pstr + "\"";
str = name + " " + pstr + ((gcp.cmin == 0) ? "*" : "+");
print(node, str, depth);
} else if (node instanceof Pattern.BackRef) {
str = "GroupBackRef " + ((Pattern.BackRef)node).groupIndex / 2;
print(node, str, depth);
} else if (node instanceof Pattern.LastNode) {
print(node, "END", depth);
} else if (node == Pattern.accept) {
return;
} else {
print(node, name, depth);
}
node = node.next;
}
}
public static void main(String[] args) {
Pattern p = Pattern.compile(args[0]);
System.out.println(" Pattern: " + p);
walk(p.root, 0);
}
}

246
jdk/src/java.base/share/classes/java/util/regex/UnicodeProp.java
View File

@ -1,246 +0,0 @@
/*
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.regex;
import java.util.HashMap;
import java.util.Locale;
enum UnicodeProp {
ALPHABETIC {
public boolean is(int ch) {
return Character.isAlphabetic(ch);
}
},
LETTER {
public boolean is(int ch) {
return Character.isLetter(ch);
}
},
IDEOGRAPHIC {
public boolean is(int ch) {
return Character.isIdeographic(ch);
}
},
LOWERCASE {
public boolean is(int ch) {
return Character.isLowerCase(ch);
}
},
UPPERCASE {
public boolean is(int ch) {
return Character.isUpperCase(ch);
}
},
TITLECASE {
public boolean is(int ch) {
return Character.isTitleCase(ch);
}
},
WHITE_SPACE {
// \p{Whitespace}
public boolean is(int ch) {
return ((((1 << Character.SPACE_SEPARATOR) |
(1 << Character.LINE_SEPARATOR) |
(1 << Character.PARAGRAPH_SEPARATOR)) >> Character.getType(ch)) & 1)
!= 0 || (ch >= 0x9 && ch <= 0xd) || (ch == 0x85);
}
},
CONTROL {
// \p{gc=Control}
public boolean is(int ch) {
return Character.getType(ch) == Character.CONTROL;
}
},
PUNCTUATION {
// \p{gc=Punctuation}
public boolean is(int ch) {
return ((((1 << Character.CONNECTOR_PUNCTUATION) |
(1 << Character.DASH_PUNCTUATION) |
(1 << Character.START_PUNCTUATION) |
(1 << Character.END_PUNCTUATION) |
(1 << Character.OTHER_PUNCTUATION) |
(1 << Character.INITIAL_QUOTE_PUNCTUATION) |
(1 << Character.FINAL_QUOTE_PUNCTUATION)) >> Character.getType(ch)) & 1)
!= 0;
}
},
HEX_DIGIT {
// \p{gc=Decimal_Number}
// \p{Hex_Digit} -> PropList.txt: Hex_Digit
public boolean is(int ch) {
return DIGIT.is(ch) ||
(ch >= 0x0030 && ch <= 0x0039) ||
(ch >= 0x0041 && ch <= 0x0046) ||
(ch >= 0x0061 && ch <= 0x0066) ||
(ch >= 0xFF10 && ch <= 0xFF19) ||
(ch >= 0xFF21 && ch <= 0xFF26) ||
(ch >= 0xFF41 && ch <= 0xFF46);
}
},
ASSIGNED {
public boolean is(int ch) {
return Character.getType(ch) != Character.UNASSIGNED;
}
},
NONCHARACTER_CODE_POINT {
// PropList.txt:Noncharacter_Code_Point
public boolean is(int ch) {
return (ch & 0xfffe) == 0xfffe || (ch >= 0xfdd0 && ch <= 0xfdef);
}
},
DIGIT {
// \p{gc=Decimal_Number}
public boolean is(int ch) {
return Character.isDigit(ch);
}
},
ALNUM {
// \p{alpha}
// \p{digit}
public boolean is(int ch) {
return ALPHABETIC.is(ch) || DIGIT.is(ch);
}
},
BLANK {
// \p{Whitespace} --
// [\N{LF} \N{VT} \N{FF} \N{CR} \N{NEL} -> 0xa, 0xb, 0xc, 0xd, 0x85
// \p{gc=Line_Separator}
// \p{gc=Paragraph_Separator}]
public boolean is(int ch) {
return Character.getType(ch) == Character.SPACE_SEPARATOR ||
ch == 0x9; // \N{HT}
}
},
GRAPH {
// [^
// \p{space}
// \p{gc=Control}
// \p{gc=Surrogate}
// \p{gc=Unassigned}]
public boolean is(int ch) {
return ((((1 << Character.SPACE_SEPARATOR) |
(1 << Character.LINE_SEPARATOR) |
(1 << Character.PARAGRAPH_SEPARATOR) |
(1 << Character.CONTROL) |
(1 << Character.SURROGATE) |
(1 << Character.UNASSIGNED)) >> Character.getType(ch)) & 1)
== 0;
}
},
PRINT {
// \p{graph}
// \p{blank}
// -- \p{cntrl}
public boolean is(int ch) {
return (GRAPH.is(ch) || BLANK.is(ch)) && !CONTROL.is(ch);
}
},
WORD {
// \p{alpha}
// \p{gc=Mark}
// \p{digit}
// \p{gc=Connector_Punctuation}
// \p{Join_Control} 200C..200D
public boolean is(int ch) {
return ALPHABETIC.is(ch) ||
((((1 << Character.NON_SPACING_MARK) |
(1 << Character.ENCLOSING_MARK) |
(1 << Character.COMBINING_SPACING_MARK) |
(1 << Character.DECIMAL_DIGIT_NUMBER) |
(1 << Character.CONNECTOR_PUNCTUATION)) >> Character.getType(ch)) & 1)
!= 0 ||
JOIN_CONTROL.is(ch);
}
},
JOIN_CONTROL {
// 200C..200D PropList.txt:Join_Control
public boolean is(int ch) {
return (ch == 0x200C || ch == 0x200D);
}
};
private static final HashMap<String, String> posix = new HashMap<>();
private static final HashMap<String, String> aliases = new HashMap<>();
static {
posix.put("ALPHA", "ALPHABETIC");
posix.put("LOWER", "LOWERCASE");
posix.put("UPPER", "UPPERCASE");
posix.put("SPACE", "WHITE_SPACE");
posix.put("PUNCT", "PUNCTUATION");
posix.put("XDIGIT","HEX_DIGIT");
posix.put("ALNUM", "ALNUM");
posix.put("CNTRL", "CONTROL");
posix.put("DIGIT", "DIGIT");
posix.put("BLANK", "BLANK");
posix.put("GRAPH", "GRAPH");
posix.put("PRINT", "PRINT");
aliases.put("WHITESPACE", "WHITE_SPACE");
aliases.put("HEXDIGIT","HEX_DIGIT");
aliases.put("NONCHARACTERCODEPOINT", "NONCHARACTER_CODE_POINT");
aliases.put("JOINCONTROL", "JOIN_CONTROL");
}
public static UnicodeProp forName(String propName) {
propName = propName.toUpperCase(Locale.ENGLISH);
String alias = aliases.get(propName);
if (alias != null)
propName = alias;
try {
return valueOf (propName);
} catch (IllegalArgumentException x) {}
return null;
}
public static UnicodeProp forPOSIXName(String propName) {
propName = posix.get(propName.toUpperCase(Locale.ENGLISH));
if (propName == null)
return null;
return valueOf (propName);
}
public abstract boolean is(int ch);
}

2
jdk/src/java.base/share/classes/javax/security/auth/callback/UnsupportedCallbackException.java
View File

@ -40,7 +40,7 @@ public class UnsupportedCallbackException extends Exception {
private Callback callback;
/**
* Constructs a {@code UnsupportedCallbackException}
* Constructs an {@code UnsupportedCallbackException}
* with no detail message.
*
* @param callback the unrecognized {@code Callback}.

21
jdk/src/java.base/share/classes/jdk/internal/misc/VM.java
View File

@ -390,10 +390,25 @@ public class VM {
private static final int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
/*
* Returns the first non-null class loader up the execution stack,
* or null if only code from the null class loader is on the stack.
* Returns the first user-defined class loader up the execution stack,
* or the platform class loader if only code from the platform or
* bootstrap class loader is on the stack.
*/
public static native ClassLoader latestUserDefinedLoader();
public static ClassLoader latestUserDefinedLoader() {
ClassLoader loader = latestUserDefinedLoader0();
return loader != null ? loader : ClassLoader.getPlatformClassLoader();
}
/*
* Returns the first user-defined class loader up the execution stack,
* or null if only code from the platform or bootstrap class loader is
* on the stack. VM does not keep a reference of platform loader and so
* it returns null.
*
* This method should be replaced with StackWalker::walk and then we can
* remove the logic in the VM.
*/
private static native ClassLoader latestUserDefinedLoader0();
/**
* Returns {@code true} if we are in a set UID program.

2
jdk/src/java.base/share/classes/sun/net/ftp/FtpClient.java
View File

@ -784,7 +784,7 @@ public abstract class FtpClient implements java.io.Closeable {
*
* @param path the pathname of the directory to list or {@code null}
* for the current working directoty.
* @return a {@code Iterator} of files or {@code null} if the
* @return an {@code Iterator} of files or {@code null} if the
* command failed.
* @throws IOException if an error occurred during the transmission
* @see #setDirParser(FtpDirParser)

30
jdk/src/java.base/share/classes/sun/security/provider/AbstractDrbg.java
View File

@ -51,12 +51,9 @@ import static java.security.DrbgParameters.Capability.*;
* configuration is eagerly called to set up parameters, and instantiation
* is lazily called only when nextBytes or reseed is called.
* <p>
* Synchronized keyword should be added to all externally callable engine
* methods including {@link #engineReseed}, {@link #engineSetSeed}, and
* {@link #engineNextBytes} (but not {@link #engineGenerateSeed}).
* Internal methods like {@link #configure} and {@link #instantiateAlgorithm}
* are not synchronized. They will either be called in a constructor or
* in another synchronized method.
* SecureRandom methods like reseed and nextBytes are not thread-safe.
* An implementation is required to protect shared access to instantiate states
* (instantiated, nonce) and DRBG states (v, c, key, reseedCounter).
*/
public abstract class AbstractDrbg extends SecureRandomSpi {
@ -78,8 +75,10 @@ public abstract class AbstractDrbg extends SecureRandomSpi {
* Reseed counter of a DRBG instance. A mechanism should increment it
* after each random bits generation and reset it in reseed. A mechanism
* does <em>not</em> need to compare it to {@link #reseedInterval}.
*
* Volatile, will be used in a double checked locking.
*/
protected transient int reseedCounter = 0;
protected transient volatile int reseedCounter = 0;
// Mech features. If not same as below, must be redefined in constructor.
@ -268,10 +267,9 @@ public abstract class AbstractDrbg extends SecureRandomSpi {
* {@code DEFAULT_STRENGTH} is 128) for HashDRBG:
* <pre>
* requested effective
* (SHA-1, -1) (SHA-1,128)
* (SHA-1, 112) (SHA-1,112)
* (SHA-1, 192) IAE
* (SHA-224, 256) IAE
* (SHA-256, -1) (SHA-256,128)
* (SHA-256, 112) (SHA-256,112)
* (SHA-256, 128) (SHA-256,128)
* (SHA-3, -1) IAE
* (null, -1) (SHA-256,128)
@ -383,9 +381,14 @@ public abstract class AbstractDrbg extends SecureRandomSpi {
instantiateIfNecessary(null);
// Step 7: Auto reseed
// Double checked locking, safe because reseedCounter is volatile
if (reseedCounter > reseedInterval || pr) {
reseedAlgorithm(getEntropyInput(pr), ai);
ai = null;
synchronized (this) {
if (reseedCounter > reseedInterval || pr) {
reseedAlgorithm(getEntropyInput(pr), ai);
ai = null;
}
}
}
// Step 8, 10: Generate_algorithm
@ -615,8 +618,7 @@ public abstract class AbstractDrbg extends SecureRandomSpi {
* @throws IllegalArgumentException if {@code params} is
* inappropriate for this SecureRandom.
*/
protected final synchronized void configure(
SecureRandomParameters params) {
protected final void configure(SecureRandomParameters params) {
if (debug != null) {
debug.println(this, "configure " + this + " with " + params);
}

6
jdk/src/java.base/share/classes/sun/security/provider/AbstractHashDrbg.java
View File

@ -39,8 +39,6 @@ public abstract class AbstractHashDrbg extends AbstractDrbg {
private static int alg2strength(String algorithm) {
switch (algorithm.toUpperCase(Locale.ROOT)) {
case "SHA-1":
return 128;
case "SHA-224":
case "SHA-512/224":
return 192;
@ -82,10 +80,6 @@ public abstract class AbstractHashDrbg extends AbstractDrbg {
this.securityStrength = tryStrength;
}
switch (algorithm.toUpperCase(Locale.ROOT)) {
case "SHA-1":
this.seedLen = 440 / 8;
this.outLen = 160 / 8;
break;
case "SHA-224":
case "SHA-512/224":
this.seedLen = 440 / 8;

96
jdk/src/java.base/share/classes/sun/security/provider/ByteArrayAccess.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -441,17 +441,89 @@ final class ByteArrayAccess {
(outOfs < 0) || ((out.length - outOfs) < len)) {
throw new ArrayIndexOutOfBoundsException();
}
len += outOfs;
while (outOfs < len) {
long i = in[inOfs++];
out[outOfs++] = (byte)(i >> 56);
out[outOfs++] = (byte)(i >> 48);
out[outOfs++] = (byte)(i >> 40);
out[outOfs++] = (byte)(i >> 32);
out[outOfs++] = (byte)(i >> 24);
out[outOfs++] = (byte)(i >> 16);
out[outOfs++] = (byte)(i >> 8);
out[outOfs++] = (byte)(i );
if (littleEndianUnaligned) {
outOfs += byteArrayOfs;
len += outOfs;
while (outOfs < len) {
unsafe.putLong(out, (long)outOfs, reverseBytes(in[inOfs++]));
outOfs += 8;
}
} else {
len += outOfs;
while (outOfs < len) {
long i = in[inOfs++];
out[outOfs++] = (byte)(i >> 56);
out[outOfs++] = (byte)(i >> 48);
out[outOfs++] = (byte)(i >> 40);
out[outOfs++] = (byte)(i >> 32);
out[outOfs++] = (byte)(i >> 24);
out[outOfs++] = (byte)(i >> 16);
out[outOfs++] = (byte)(i >> 8);
out[outOfs++] = (byte)(i );
}
}
}
/**
* byte[] to long[] conversion, little endian byte order
*/
static void b2lLittle(byte[] in, int inOfs, long[] out, int outOfs, int len) {
if ((inOfs < 0) || ((in.length - inOfs) < len) ||
((outOfs < 0) || (out.length - outOfs) < len/8)) {
throw new ArrayIndexOutOfBoundsException();
}
if (littleEndianUnaligned) {
inOfs += byteArrayOfs;
len += inOfs;
while (inOfs < len) {
out[outOfs++] = unsafe.getLong(in, (long)inOfs);
inOfs += 8;
}
} else {
len += inOfs;
while (inOfs < len) {
out[outOfs++] = ((in[inOfs ] & 0xffL)
| ((in[inOfs + 1] & 0xffL) << 8)
| ((in[inOfs + 2] & 0xffL) << 16)
| ((in[inOfs + 3] & 0xffL) << 24)
| ((in[inOfs + 4] & 0xffL) << 32)
| ((in[inOfs + 5] & 0xffL) << 40)
| ((in[inOfs + 6] & 0xffL) << 48)
| ((in[inOfs + 7] & 0xffL) << 56));
inOfs += 8;
}
}
}
/**
* long[] to byte[] conversion, little endian byte order
*/
static void l2bLittle(long[] in, int inOfs, byte[] out, int outOfs, int len) {
if ((inOfs < 0) || ((in.length - inOfs) < len/8) ||
(outOfs < 0) || ((out.length - outOfs) < len)) {
throw new ArrayIndexOutOfBoundsException();
}
if (littleEndianUnaligned) {
outOfs += byteArrayOfs;
len += outOfs;
while (outOfs < len) {
unsafe.putLong(out, (long)outOfs, in[inOfs++]);
outOfs += 8;
}
} else {
len += outOfs;
while (outOfs < len) {
long i = in[inOfs++];
out[outOfs++] = (byte)(i );
out[outOfs++] = (byte)(i >> 8);
out[outOfs++] = (byte)(i >> 16);
out[outOfs++] = (byte)(i >> 24);
out[outOfs++] = (byte)(i >> 32);
out[outOfs++] = (byte)(i >> 40);
out[outOfs++] = (byte)(i >> 48);
out[outOfs++] = (byte)(i >> 56);
}
}
}
}

63
jdk/src/java.base/share/classes/sun/security/provider/CtrDrbg.java
View File

@ -27,7 +27,6 @@ package sun.security.provider;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.security.*;
@ -68,11 +67,6 @@ public class CtrDrbg extends AbstractDrbg {
private static int alg2strength(String algorithm) {
switch (algorithm.toUpperCase(Locale.ROOT)) {
case "TDEA":
case "3KEYTDEA":
case "3 KEY TDEA":
case "DESEDE":
return 112;
case "AES-128":
return 128;
case "AES-192":
@ -120,16 +114,6 @@ public class CtrDrbg extends AbstractDrbg {
this.securityStrength = tryStrength;
}
switch (algorithm.toUpperCase(Locale.ROOT)) {
case "TDEA":
case "3KEYTDEA":
case "3 KEY TDEA":
case "DESEDE":
algorithm = "DESede";
this.keyAlg = "DESede";
this.cipherAlg = "DESede/ECB/NoPadding";
this.blockLen = 64 / 8;
this.keyLen = 168 / 8;
break;
case "AES-128":
case "AES-192":
case "AES-256":
@ -224,7 +208,7 @@ public class CtrDrbg extends AbstractDrbg {
// Step 2.1. Increment
addOne(v, ctrLen);
// Step 2.2. Block_Encrypt
cipher.init(Cipher.ENCRYPT_MODE, getKey(keyAlg, k));
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(k, keyAlg));
// Step 2.3. Encrypt into right position, no need to cat
cipher.doFinal(v, 0, blockLen, temp, i * blockLen);
}
@ -316,7 +300,7 @@ public class CtrDrbg extends AbstractDrbg {
for (int i = 0; i * blockLen < seedLen; i++) {
try {
cipher.init(Cipher.ENCRYPT_MODE, getKey(keyAlg, k));
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(k, keyAlg));
int tailLen = temp.length - blockLen*i;
if (tailLen > blockLen) {
tailLen = blockLen;
@ -340,7 +324,7 @@ public class CtrDrbg extends AbstractDrbg {
inputBlock[j] ^= chain[j];
}
try {
cipher.init(Cipher.ENCRYPT_MODE, getKey(keyAlg, k));
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(k, keyAlg));
chain = cipher.doFinal(inputBlock);
} catch (GeneralSecurityException e) {
throw new InternalError(e);
@ -350,7 +334,7 @@ public class CtrDrbg extends AbstractDrbg {
}
@Override
protected void reseedAlgorithm(
protected synchronized void reseedAlgorithm(
byte[] ei,
byte[] additionalInput) {
if (usedf) {
@ -456,7 +440,7 @@ public class CtrDrbg extends AbstractDrbg {
addOne(v, ctrLen);
try {
// Step 4.2. Encrypt
cipher.init(Cipher.ENCRYPT_MODE, getKey(keyAlg, k));
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(k, keyAlg));
byte[] out = cipher.doFinal(v);
// Step 4.3 and 5. Cat bytes and leftmost
@ -479,43 +463,6 @@ public class CtrDrbg extends AbstractDrbg {
// Step 8. Return
}
private static void des7to8(
byte[] key56, int off56, byte[] key64, int off64) {
key64[off64 + 0] = (byte)
(key56[off56 + 0] & 0xFE); // << 0
key64[off64 + 1] = (byte)
((key56[off56 + 0] << 7) | ((key56[off56 + 1] & 0xFF) >>> 1));
key64[off64 + 2] = (byte)
((key56[off56 + 1] << 6) | ((key56[off56 + 2] & 0xFF) >>> 2));
key64[off64 + 3] = (byte)
((key56[off56 + 2] << 5) | ((key56[off56 + 3] & 0xFF) >>> 3));
key64[off64 + 4] = (byte)
((key56[off56 + 3] << 4) | ((key56[off56 + 4] & 0xFF) >>> 4));
key64[off64 + 5] = (byte)
((key56[off56 + 4] << 3) | ((key56[off56 + 5] & 0xFF) >>> 5));
key64[off64 + 6] = (byte)
((key56[off56 + 5] << 2) | ((key56[off56 + 6] & 0xFF) >>> 6));
key64[off64 + 7] = (byte)
(key56[off56 + 6] << 1);
for (int i = 0; i < 8; i++) {
// if even # bits, make uneven, XOR with 1 (uneven & 1)
// for uneven # bits, make even, XOR with 0 (even & 1)
key64[off64 + i] ^= Integer.bitCount(key64[off64 + i] ^ 1) & 1;
}
}
private static SecretKey getKey(String keyAlg, byte[] k) {
if (keyAlg.equals("DESede")) {
byte[] k2 = new byte[24];
des7to8(k, 0, k2, 0);
des7to8(k, 7, k2, 8);
des7to8(k, 14, k2, 16);
k = k2;
}
return new SecretKeySpec(k, keyAlg);
}
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject ();

2
jdk/src/java.base/share/classes/sun/security/provider/HashDrbg.java
View File

@ -115,7 +115,7 @@ public class HashDrbg extends AbstractHashDrbg {
// This method is used by both instantiation and reseeding.
@Override
protected final void hashReseedInternal(byte[] input) {
protected final synchronized void hashReseedInternal(byte[] input) {
// 800-90Ar1 10.1.1.2: Instantiate Process.
// 800-90Ar1 10.1.1.3: Reseed Process.

2
jdk/src/java.base/share/classes/sun/security/provider/HmacDrbg.java
View File

@ -115,7 +115,7 @@ public class HmacDrbg extends AbstractHashDrbg {
// This method is used by both instantiation and reseeding.
@Override
protected final void hashReseedInternal(byte[] input) {
protected final synchronized void hashReseedInternal(byte[] input) {
// 800-90Ar1 10.1.2.3: Instantiate Process.
// 800-90Ar1 10.1.2.4: Reseed Process.

300
jdk/src/java.base/share/classes/sun/security/provider/SHA3.java Normal file
View File

@ -0,0 +1,300 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.security.provider;
import static sun.security.provider.ByteArrayAccess.*;
import java.nio.*;
import java.util.*;
import java.security.*;
/**
* This class implements the Secure Hash Algorithm SHA-3 developed by
* the National Institute of Standards and Technology along with the
* National Security Agency as defined in FIPS PUB 202.
*
* <p>It implements java.security.MessageDigestSpi, and can be used
* through Java Cryptography Architecture (JCA), as a pluggable
* MessageDigest implementation.
*
* @since 9
* @author Valerie Peng
*/
abstract class SHA3 extends DigestBase {
private static final int WIDTH = 200; // in bytes, e.g. 1600 bits
private static final int DM = 5; // dimension of lanes
private static final int NR = 24; // number of rounds
// precomputed round constants needed by the step mapping Iota
private static final long[] RC_CONSTANTS = {
0x01L, 0x8082L, 0x800000000000808aL,
0x8000000080008000L, 0x808bL, 0x80000001L,
0x8000000080008081L, 0x8000000000008009L, 0x8aL,
0x88L, 0x80008009L, 0x8000000aL,
0x8000808bL, 0x800000000000008bL, 0x8000000000008089L,
0x8000000000008003L, 0x8000000000008002L, 0x8000000000000080L,
0x800aL, 0x800000008000000aL, 0x8000000080008081L,
0x8000000000008080L, 0x80000001L, 0x8000000080008008L,
};
private byte[] state;
/**
* Creates a new SHA-3 object.
*/
SHA3(String name, int digestLength) {
super(name, digestLength, (WIDTH - (2 * digestLength)));
implReset();
}
/**
* Core compression function. Processes blockSize bytes at a time
* and updates the state of this object.
*/
void implCompress(byte[] b, int ofs) {
for (int i = 0; i < buffer.length; i++) {
state[i] ^= b[ofs++];
}
state = keccak(state);
}
/**
* Return the digest. Subclasses do not need to reset() themselves,
* DigestBase calls implReset() when necessary.
*/
void implDigest(byte[] out, int ofs) {
int numOfPadding =
setPaddingBytes(buffer, (int)(bytesProcessed % buffer.length));
if (numOfPadding < 1) {
throw new ProviderException("Incorrect pad size: " + numOfPadding);
}
for (int i = 0; i < buffer.length; i++) {
state[i] ^= buffer[i];
}
state = keccak(state);
System.arraycopy(state, 0, out, ofs, engineGetDigestLength());
}
/**
* Resets the internal state to start a new hash.
*/
void implReset() {
state = new byte[WIDTH];
}
/**
* Utility function for circular shift the specified long
* value to the left for n bits.
*/
private static long circularShiftLeft(long lane, int n) {
return ((lane << n) | (lane >>> (64 - n)));
}
/**
* Utility function for padding the specified data based on the
* pad10*1 algorithm (section 5.1) and the 2-bit suffix "01" required
* for SHA-3 hash (section 6.1).
*/
private static int setPaddingBytes(byte[] in, int len) {
if (len != in.length) {
// erase leftover values
Arrays.fill(in, len, in.length, (byte)0);
// directly store the padding bytes into the input
// as the specified buffer is allocated w/ size = rateR
in[len] |= (byte) 0x06;
in[in.length - 1] |= (byte) 0x80;
}
return (in.length - len);
}
/**
* Utility function for transforming the specified state from
* the byte array format into array of lanes as defined in
* section 3.1.2.
*/
private static long[][] bytes2Lanes(byte[] s) {
if (s.length != WIDTH) {
throw new ProviderException("Error: incorrect input size " +
s.length);
}
// The conversion traverses along x-axis before y-axis. So, y is the
// first dimension and x is the second dimension.
long[][] s2 = new long[DM][DM];
int sOfs = 0;
for (int y = 0; y < DM; y++, sOfs += 40) {
b2lLittle(s, sOfs, s2[y], 0, 40);
}
return s2;
}
/**
* Utility function for transforming the specified arrays of
* lanes into a byte array as defined in section 3.1.3.
*/
private static byte[] lanes2Bytes(long[][] m) {
byte[] s = new byte[WIDTH];
int sOfs = 0;
// The conversion traverses along x-axis before y-axis. So, y is the
// first dimension and x is the second dimension.
for (int y = 0; y < DM; y++, sOfs += 40) {
l2bLittle(m[y], 0, s, sOfs, 40);
}
return s;
}
/**
* Step mapping Theta as defined in section 3.2.1 .
*/
private static long[][] smTheta(long[][] a) {
long[] c = new long[DM];
for (int i = 0; i < DM; i++) {
c[i] = a[0][i]^a[1][i]^a[2][i]^a[3][i]^a[4][i];
}
long[] d = new long[DM];
for (int i = 0; i < DM; i++) {
long c1 = c[(i + 4) % DM];
// left shift and wrap the leftmost bit into the rightmost bit
long c2 = circularShiftLeft(c[(i + 1) % DM], 1);
d[i] = c1^c2;
}
for (int y = 0; y < DM; y++) {
for (int x = 0; x < DM; x++) {
a[y][x] ^= d[x];
}
}
return a;
}
/**
* Step mapping Rho as defined in section 3.2.2.
*/
private static long[][] smRho(long[][] a) {
long[][] a2 = new long[DM][DM];
a2[0][0] = a[0][0];
int xNext, yNext;
for (int t = 0, x = 1, y = 0; t <= 23; t++, x = xNext, y = yNext) {
int numberOfShift = ((t + 1)*(t + 2)/2) % 64;
a2[y][x] = circularShiftLeft(a[y][x], numberOfShift);
xNext = y;
yNext = (2 * x + 3 * y) % DM;
}
return a2;
}
/**
* Step mapping Pi as defined in section 3.2.3.
*/
private static long[][] smPi(long[][] a) {
long[][] a2 = new long[DM][DM];
for (int y = 0; y < DM; y++) {
for (int x = 0; x < DM; x++) {
a2[y][x] = a[x][(x + 3 * y) % DM];
}
}
return a2;
}
/**
* Step mapping Chi as defined in section 3.2.4.
*/
private static long[][] smChi(long[][] a) {
long[][] a2 = new long[DM][DM];
for (int y = 0; y < DM; y++) {
for (int x = 0; x < DM; x++) {
a2[y][x] = a[y][x] ^
((a[y][(x + 1) % DM] ^ 0xFFFFFFFFFFFFFFFFL) &
a[y][(x + 2) % DM]);
}
}
return a2;
}
/**
* Step mapping Iota as defined in section 3.2.5.
*
* @return the processed state array
* @param state the state array to be processed
*/
private static long[][] smIota(long[][] a, int rndIndex) {
a[0][0] ^= RC_CONSTANTS[rndIndex];
return a;
}
/**
* The function Keccak as defined in section 5.2 with
* rate r = 1600 and capacity c = (digest length x 2).
*/
private static byte[] keccak(byte[] state) {
long[][] lanes = bytes2Lanes(state);
for (int ir = 0; ir < NR; ir++) {
lanes = smIota(smChi(smPi(smRho(smTheta(lanes)))), ir);
}
return lanes2Bytes(lanes);
}
public Object clone() throws CloneNotSupportedException {
SHA3 copy = (SHA3) super.clone();
copy.state = copy.state.clone();
return copy;
}
/**
* SHA3-224 implementation class.
*/
public static final class SHA224 extends SHA3 {
public SHA224() {
super("SHA3-224", 28);
}
}
/**
* SHA3-256 implementation class.
*/
public static final class SHA256 extends SHA3 {
public SHA256() {
super("SHA3-256", 32);
}
}
/**
* SHAs-384 implementation class.
*/
public static final class SHA384 extends SHA3 {
public SHA384() {
super("SHA3-384", 48);
}
}
/**
* SHA3-512 implementation class.
*/
public static final class SHA512 extends SHA3 {
public SHA512() {
super("SHA3-512", 64);
}
}
}

1
jdk/src/java.base/share/classes/sun/security/provider/SecureRandom.java
View File

@ -156,6 +156,7 @@ implements java.io.Serializable {
}
}
state = digest.digest(seed);
remCount = 0;
}
private static void updateState(byte[] state, byte[] output) {

19
jdk/src/java.base/share/classes/sun/security/provider/SunEntries.java
View File

@ -211,6 +211,25 @@ final class SunEntries {
map.put("Alg.Alias.MessageDigest.OID.2.16.840.1.101.3.4.2.6",
"SHA-512/256");
map.put("MessageDigest.SHA3-224", "sun.security.provider.SHA3$SHA224");
map.put("Alg.Alias.MessageDigest.2.16.840.1.101.3.4.2.7", "SHA3-224");
map.put("Alg.Alias.MessageDigest.OID.2.16.840.1.101.3.4.2.7",
"SHA3-224");
map.put("MessageDigest.SHA3-256", "sun.security.provider.SHA3$SHA256");
map.put("Alg.Alias.MessageDigest.2.16.840.1.101.3.4.2.8", "SHA3-256");
map.put("Alg.Alias.MessageDigest.OID.2.16.840.1.101.3.4.2.8",
"SHA3-256");
map.put("MessageDigest.SHA3-384", "sun.security.provider.SHA3$SHA384");
map.put("Alg.Alias.MessageDigest.2.16.840.1.101.3.4.2.9", "SHA3-384");
map.put("Alg.Alias.MessageDigest.OID.2.16.840.1.101.3.4.2.9",
"SHA3-384");
map.put("MessageDigest.SHA3-512", "sun.security.provider.SHA3$SHA512");
map.put("Alg.Alias.MessageDigest.2.16.840.1.101.3.4.2.10", "SHA3-512");
map.put("Alg.Alias.MessageDigest.OID.2.16.840.1.101.3.4.2.10",
"SHA3-512");
/*
* Algorithm Parameter Generator engines
*/

8
jdk/src/java.base/share/classes/sun/security/provider/certpath/OCSPNonceExtension.java
View File

@ -51,7 +51,7 @@ public final class OCSPNonceExtension extends Extension {
private byte[] nonceData = null;
/**
* Create a {@code OCSPNonceExtension} by providing the nonce length.
* Create an {@code OCSPNonceExtension} by providing the nonce length.
* The criticality is set to false, and the OID for the extension will
* be the value defined by "id-pkix-ocsp-nonce" from RFC 6960.
*
@ -66,7 +66,7 @@ public final class OCSPNonceExtension extends Extension {
}
/**
* Create a {@code OCSPNonceExtension} by providing the nonce length and
* Create an {@code OCSPNonceExtension} by providing the nonce length and
* criticality setting. The OID for the extension will
* be the value defined by "id-pkix-ocsp-nonce" from RFC 6960.
*
@ -96,7 +96,7 @@ public final class OCSPNonceExtension extends Extension {
}
/**
* Create a {@code OCSPNonceExtension} by providing a nonce value.
* Create an {@code OCSPNonceExtension} by providing a nonce value.
* The criticality is set to false, and the OID for the extension will
* be the value defined by "id-pkix-ocsp-nonce" from RFC 6960.
*
@ -114,7 +114,7 @@ public final class OCSPNonceExtension extends Extension {
}
/**
* Create a {@code OCSPNonceExtension} by providing a nonce value and
* Create an {@code OCSPNonceExtension} by providing a nonce value and
* criticality setting. The OID for the extension will
* be the value defined by "id-pkix-ocsp-nonce" from RFC 6960.
*

4
jdk/src/java.base/share/classes/sun/security/ssl/HandshakeHash.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -108,7 +108,7 @@ final class HandshakeHash {
* a hash for the certificate verify message is required.
*/
HandshakeHash(boolean needCertificateVerify) {
clonesNeeded = needCertificateVerify ? 3 : 2;
clonesNeeded = needCertificateVerify ? 4 : 3;
}
void reserve(ByteBuffer input) {

2
jdk/src/java.base/share/classes/sun/security/ssl/SSLSocketInputRecord.java
View File

@ -123,7 +123,7 @@ final class SSLSocketInputRecord extends InputRecord implements SSLRecord {
*/
//
// Short header is using here. We reverse the code here
// in case it it used in the future.
// in case it is used in the future.
//
// int mask = (isShort ? 0x7F : 0x3F);
// len = ((byteZero & mask) << 8) +

91
jdk/src/java.base/share/classes/sun/security/x509/AlgorithmId.java
View File

@ -552,58 +552,61 @@ public class AlgorithmId implements Serializable, DerEncoder {
return AlgorithmId.sha512WithECDSA_oid;
}
// See if any of the installed providers supply a mapping from
// the given algorithm name to an OID string
String oidString;
if (!initOidTable) {
Provider[] provs = Security.getProviders();
for (int i=0; i<provs.length; i++) {
for (Enumeration<Object> enum_ = provs[i].keys();
enum_.hasMoreElements(); ) {
String alias = (String)enum_.nextElement();
String upperCaseAlias = alias.toUpperCase(Locale.ENGLISH);
int index;
if (upperCaseAlias.startsWith("ALG.ALIAS") &&
(index=upperCaseAlias.indexOf("OID.", 0)) != -1) {
index += "OID.".length();
if (index == alias.length()) {
// invalid alias entry
break;
}
if (oidTable == null) {
oidTable = new HashMap<>();
}
oidString = alias.substring(index);
String stdAlgName = provs[i].getProperty(alias);
if (stdAlgName != null) {
stdAlgName = stdAlgName.toUpperCase(Locale.ENGLISH);
}
if (stdAlgName != null &&
oidTable.get(stdAlgName) == null) {
oidTable.put(stdAlgName,
new ObjectIdentifier(oidString));
}
}
}
}
if (oidTable == null) {
oidTable = Collections.<String,ObjectIdentifier>emptyMap();
}
initOidTable = true;
}
return oidTable.get(name.toUpperCase(Locale.ENGLISH));
return oidTable().get(name.toUpperCase(Locale.ENGLISH));
}
private static ObjectIdentifier oid(int ... values) {
return ObjectIdentifier.newInternal(values);
}
private static boolean initOidTable = false;
private static Map<String,ObjectIdentifier> oidTable;
private static volatile Map<String,ObjectIdentifier> oidTable;
private static final Map<ObjectIdentifier,String> nameTable;
/** Returns the oidTable, lazily initializing it on first access. */
private static Map<String,ObjectIdentifier> oidTable()
throws IOException {
// Double checked locking; safe because oidTable is volatile
Map<String,ObjectIdentifier> tab;
if ((tab = oidTable) == null) {
synchronized (AlgorithmId.class) {
if ((tab = oidTable) == null)
oidTable = tab = computeOidTable();
}
}
return tab;
}
/** Collects the algorithm names from the installed providers. */
private static HashMap<String,ObjectIdentifier> computeOidTable()
throws IOException {
HashMap<String,ObjectIdentifier> tab = new HashMap<>();
for (Provider provider : Security.getProviders()) {
for (Object key : provider.keySet()) {
String alias = (String)key;
String upperCaseAlias = alias.toUpperCase(Locale.ENGLISH);
int index;
if (upperCaseAlias.startsWith("ALG.ALIAS") &&
(index=upperCaseAlias.indexOf("OID.", 0)) != -1) {
index += "OID.".length();
if (index == alias.length()) {
// invalid alias entry
break;
}
String oidString = alias.substring(index);
String stdAlgName = provider.getProperty(alias);
if (stdAlgName != null) {
stdAlgName = stdAlgName.toUpperCase(Locale.ENGLISH);
}
if (stdAlgName != null &&
tab.get(stdAlgName) == null) {
tab.put(stdAlgName, new ObjectIdentifier(oidString));
}
}
}
}
return tab;
}
/*****************************************************************/
/*

15
jdk/src/java.base/share/conf/security/java.security
View File

@ -206,16 +206,15 @@ securerandom.strongAlgorithms=NativePRNGBlocking:SUN,DRBG:SUN
# "Hash_DRBG" | "HMAC_DRBG" | "CTR_DRBG"
#
# // The DRBG algorithm name. The "SHA-***" names are for Hash_DRBG and
# // HMAC_DRBG, default "SHA-256". "3KeyTDEA" and "AES-***" names are for
# // CTR_DRBG, default "AES-128" when using the limited cryptographic
# // or "AES-256" when using the unlimited.
# // HMAC_DRBG, default "SHA-256". The "AES-***" names are for CTR_DRBG,
# // default "AES-128" when using the limited cryptographic or "AES-256"
# // when using the unlimited.
# algorithm_name:
# "SHA-1" | "SHA-224" | "SHA-512/224" | "SHA-256" |
# "SHA-224" | "SHA-512/224" | "SHA-256" |
# "SHA-512/256" | "SHA-384" | "SHA-512" |
# "3KeyTDEA" | "AES-128" | "AES-192" | "AES-256"
# "AES-128" | "AES-192" | "AES-256"
#
# // Security strength requested. Default "128", or "112"
# // if mech_name is CTR_DRBG and algorithm_name is "3KeyTDEA"
# // Security strength requested. Default "128"
# strength:
# "112" | "128" | "192" | "256"
#
@ -234,7 +233,7 @@ securerandom.strongAlgorithms=NativePRNGBlocking:SUN,DRBG:SUN
# "use_df" | "no_df"
#
# Examples,
# securerandom.drbg.config=Hash_DRBG,SHA-1,112,none
# securerandom.drbg.config=Hash_DRBG,SHA-224,112,none
# securerandom.drbg.config=CTR_DRBG,AES-256,192,pr_and_reseed,use_df
#
# The default value is an empty string, which is equivalent to

2
jdk/src/java.base/share/native/libjava/VM.c
View File

@ -36,7 +36,7 @@ static JNINativeMethod methods[] = {
};
JNIEXPORT jobject JNICALL
Java_jdk_internal_misc_VM_latestUserDefinedLoader(JNIEnv *env, jclass cls) {
Java_jdk_internal_misc_VM_latestUserDefinedLoader0(JNIEnv *env, jclass cls) {
return JVM_LatestUserDefinedLoader(env);
}

3
jdk/src/java.base/unix/classes/sun/security/provider/NativePRNG.java
View File

@ -469,7 +469,8 @@ public final class NativePRNG extends SecureRandomSpi {
try {
seedOut.write(seed);
} catch (IOException e) {
throw new ProviderException("setSeed() failed", e);
// Ignored. On Mac OS X, /dev/urandom can be opened
// for write, but actual write is not permitted.
}
}
getMixRandom().engineSetSeed(seed);

1100
jdk/src/java.base/unix/native/libnet/NetworkInterface.c
View File

File diff suppressed because it is too large Load Diff

159
jdk/src/java.httpclient/share/classes/java/net/http/CharsetToolkit.java
View File

@ -1,159 +0,0 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
*/
package java.net.http;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import static java.nio.charset.StandardCharsets.UTF_8;
// The purpose of this class is to separate charset-related tasks from the main
// WebSocket logic, simplifying where possible.
//
// * Coders hide the differences between coding and flushing stages on the
// API level
// * Verifier abstracts the way the verification is performed
// (spoiler: it's a decoding into a throw-away buffer)
//
// Coding methods throw exceptions instead of returning coding result denoting
// errors, since any kind of handling and recovery is not expected.
final class CharsetToolkit {
private CharsetToolkit() { }
static final class Verifier {
private final CharsetDecoder decoder = UTF_8.newDecoder();
// A buffer used to check validity of UTF-8 byte stream by decoding it.
// The contents of this buffer are never used.
// The size is arbitrary, though it should probably be chosen from the
// performance perspective since it affects the total number of calls to
// decoder.decode() and amount of work in each of these calls
private final CharBuffer blackHole = CharBuffer.allocate(1024);
void verify(ByteBuffer in, boolean endOfInput)
throws CharacterCodingException {
while (true) {
// Since decoder.flush() cannot produce an error, it's not
// helpful for verification. Therefore this step is skipped.
CoderResult r = decoder.decode(in, blackHole, endOfInput);
if (r.isOverflow()) {
blackHole.clear();
} else if (r.isUnderflow()) {
break;
} else if (r.isError()) {
r.throwException();
} else {
// Should not happen
throw new InternalError();
}
}
}
Verifier reset() {
decoder.reset();
return this;
}
}
static final class Encoder {
private final CharsetEncoder encoder = UTF_8.newEncoder();
private boolean coding = true;
CoderResult encode(CharBuffer in, ByteBuffer out, boolean endOfInput)
throws CharacterCodingException {
if (coding) {
CoderResult r = encoder.encode(in, out, endOfInput);
if (r.isOverflow()) {
return r;
} else if (r.isUnderflow()) {
if (endOfInput) {
coding = false;
} else {
return r;
}
} else if (r.isError()) {
r.throwException();
} else {
// Should not happen
throw new InternalError();
}
}
assert !coding;
return encoder.flush(out);
}
Encoder reset() {
coding = true;
encoder.reset();
return this;
}
}
static CharBuffer decode(ByteBuffer in) throws CharacterCodingException {
return UTF_8.newDecoder().decode(in);
}
static final class Decoder {
private final CharsetDecoder decoder = UTF_8.newDecoder();
private boolean coding = true; // Either coding or flushing
CoderResult decode(ByteBuffer in, CharBuffer out, boolean endOfInput)
throws CharacterCodingException {
if (coding) {
CoderResult r = decoder.decode(in, out, endOfInput);
if (r.isOverflow()) {
return r;
} else if (r.isUnderflow()) {
if (endOfInput) {
coding = false;
} else {
return r;
}
} else if (r.isError()) {
r.throwException();
} else {
// Should not happen
throw new InternalError();
}
}
assert !coding;
return decoder.flush(out);
}
Decoder reset() {
coding = true;
decoder.reset();
return this;
}
}
}

15
jdk/src/java.httpclient/share/classes/java/net/http/RawChannel.java
View File

@ -39,18 +39,22 @@ final class RawChannel implements ByteChannel, GatheringByteChannel {
private final HttpClientImpl client;
private final HttpConnection connection;
private volatile boolean closed;
private interface RawEvent {
/** must return the selector interest op flags OR'd. */
/**
* must return the selector interest op flags OR'd.
*/
int interestOps();
/** called when event occurs. */
/**
* called when event occurs.
*/
void handle();
}
interface NonBlockingEvent extends RawEvent { }
interface NonBlockingEvent extends RawEvent {
}
RawChannel(HttpClientImpl client, HttpConnection connection) {
this.client = client;
@ -127,12 +131,11 @@ final class RawChannel implements ByteChannel, GatheringByteChannel {
@Override
public boolean isOpen() {
return !closed;
return connection.isOpen();
}
@Override
public void close() throws IOException {
closed = true;
connection.close();
}

16
jdk/src/java.httpclient/share/classes/java/net/http/Stream.java
View File

@ -32,6 +32,9 @@ import java.nio.ByteBuffer;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.BiFunction;
import java.util.function.LongConsumer;
@ -409,13 +412,20 @@ class Stream extends ExchangeImpl {
@Override
HttpResponseImpl getResponse() throws IOException {
try {
return getResponseAsync(null).join();
} catch (Throwable e) {
if (request.timeval() > 0) {
return getResponseAsync(null).get(
request.timeval(), TimeUnit.MILLISECONDS);
} else {
return getResponseAsync(null).join();
}
} catch (TimeoutException e) {
throw new HttpTimeoutException("Response timed out");
} catch (InterruptedException | ExecutionException e) {
Throwable t = e.getCause();
if (t instanceof IOException) {
throw (IOException)t;
}
throw e;
throw new IOException(e);
}
}

390
jdk/src/java.httpclient/share/classes/java/net/http/WS.java Normal file
View File

@ -0,0 +1,390 @@
/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.io.IOException;
import java.net.ProtocolException;
import java.net.http.WSOpeningHandshake.Result;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import static java.lang.System.Logger.Level.ERROR;
import static java.lang.System.Logger.Level.WARNING;
import static java.net.http.WSUtils.logger;
import static java.util.Objects.requireNonNull;
/*
* A WebSocket client.
*
* Consists of two independent parts; a transmitter responsible for sending
* messages, and a receiver which notifies the listener of incoming messages.
*/
final class WS implements WebSocket {
private final String subprotocol;
private final RawChannel channel;
private final WSTransmitter transmitter;
private final WSReceiver receiver;
private final Listener listener;
private final Object stateLock = new Object();
private volatile State state = State.CONNECTED;
private final CompletableFuture<Void> whenClosed = new CompletableFuture<>();
static CompletableFuture<WebSocket> newInstanceAsync(WSBuilder b) {
CompletableFuture<Result> result = new WSOpeningHandshake(b).performAsync();
Listener listener = b.getListener();
Executor executor = b.getClient().executorService();
return result.thenApply(r -> {
WS ws = new WS(listener, r.subprotocol, r.channel, executor);
ws.start();
return ws;
});
}
private WS(Listener listener, String subprotocol, RawChannel channel,
Executor executor) {
this.listener = wrapListener(listener);
this.channel = channel;
this.subprotocol = subprotocol;
Consumer<Throwable> errorHandler = error -> {
if (error == null) {
throw new InternalError();
}
// If the channel is closed, we need to update the state, to denote
// there's no point in trying to continue using WebSocket
if (!channel.isOpen()) {
synchronized (stateLock) {
tryChangeState(State.ERROR);
}
}
};
transmitter = new WSTransmitter(executor, channel, errorHandler);
receiver = new WSReceiver(this.listener, this, executor, channel);
}
private void start() {
receiver.start();
}
@Override
public CompletableFuture<Void> sendText(ByteBuffer message, boolean isLast) {
throw new UnsupportedOperationException("Not implemented");
}
@Override
public CompletableFuture<Void> sendText(CharSequence message, boolean isLast) {
requireNonNull(message, "message");
synchronized (stateLock) {
checkState();
return transmitter.sendText(message, isLast);
}
}
@Override
public CompletableFuture<Void> sendText(Stream<? extends CharSequence> message) {
requireNonNull(message, "message");
synchronized (stateLock) {
checkState();
return transmitter.sendText(message);
}
}
@Override
public CompletableFuture<Void> sendBinary(ByteBuffer message, boolean isLast) {
requireNonNull(message, "message");
synchronized (stateLock) {
checkState();
return transmitter.sendBinary(message, isLast);
}
}
@Override
public CompletableFuture<Void> sendPing(ByteBuffer message) {
requireNonNull(message, "message");
synchronized (stateLock) {
checkState();
return transmitter.sendPing(message);
}
}
@Override
public CompletableFuture<Void> sendPong(ByteBuffer message) {
requireNonNull(message, "message");
synchronized (stateLock) {
checkState();
return transmitter.sendPong(message);
}
}
@Override
public CompletableFuture<Void> sendClose(CloseCode code, CharSequence reason) {
requireNonNull(code, "code");
requireNonNull(reason, "reason");
synchronized (stateLock) {
return doSendClose(() -> transmitter.sendClose(code, reason));
}
}
@Override
public CompletableFuture<Void> sendClose() {
synchronized (stateLock) {
return doSendClose(() -> transmitter.sendClose());
}
}
private CompletableFuture<Void> doSendClose(Supplier<CompletableFuture<Void>> s) {
checkState();
boolean closeChannel = false;
synchronized (stateLock) {
if (state == State.CLOSED_REMOTELY) {
closeChannel = tryChangeState(State.CLOSED);
} else {
tryChangeState(State.CLOSED_LOCALLY);
}
}
CompletableFuture<Void> sent = s.get();
if (closeChannel) {
sent.whenComplete((v, t) -> {
try {
channel.close();
} catch (IOException e) {
logger.log(ERROR, "Error transitioning to state " + State.CLOSED, e);
}
});
}
return sent;
}
@Override
public long request(long n) {
if (n < 0L) {
throw new IllegalArgumentException("The number must not be negative: " + n);
}
return receiver.request(n);
}
@Override
public String getSubprotocol() {
return subprotocol;
}
@Override
public boolean isClosed() {
return state.isTerminal();
}
@Override
public void abort() throws IOException {
synchronized (stateLock) {
tryChangeState(State.ABORTED);
}
channel.close();
}
@Override
public String toString() {
return super.toString() + "[" + state + "]";
}
private void checkState() {
if (state.isTerminal() || state == State.CLOSED_LOCALLY) {
throw new IllegalStateException("WebSocket is closed [" + state + "]");
}
}
/*
* Wraps the user's listener passed to the constructor into own listener to
* intercept transitions to terminal states (onClose and onError) and to act
* upon exceptions and values from the user's listener.
*/
private Listener wrapListener(Listener listener) {
return new Listener() {
// Listener's method MUST be invoked in a happen-before order
private final Object visibilityLock = new Object();
@Override
public void onOpen(WebSocket webSocket) {
synchronized (visibilityLock) {
listener.onOpen(webSocket);
}
}
@Override
public CompletionStage<?> onText(WebSocket webSocket, Text message,
MessagePart part) {
synchronized (visibilityLock) {
return listener.onText(webSocket, message, part);
}
}
@Override
public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer message,
MessagePart part) {
synchronized (visibilityLock) {
return listener.onBinary(webSocket, message, part);
}
}
@Override
public CompletionStage<?> onPing(WebSocket webSocket, ByteBuffer message) {
synchronized (visibilityLock) {
return listener.onPing(webSocket, message);
}
}
@Override
public CompletionStage<?> onPong(WebSocket webSocket, ByteBuffer message) {
synchronized (visibilityLock) {
return listener.onPong(webSocket, message);
}
}
@Override
public void onClose(WebSocket webSocket, Optional<CloseCode> code, String reason) {
synchronized (stateLock) {
if (state == State.CLOSED_REMOTELY || state.isTerminal()) {
throw new InternalError("Unexpected onClose in state " + state);
} else if (state == State.CLOSED_LOCALLY) {
try {
channel.close();
} catch (IOException e) {
logger.log(ERROR, "Error transitioning to state " + State.CLOSED, e);
}
tryChangeState(State.CLOSED);
} else if (state == State.CONNECTED) {
tryChangeState(State.CLOSED_REMOTELY);
}
}
synchronized (visibilityLock) {
listener.onClose(webSocket, code, reason);
}
}
@Override
public void onError(WebSocket webSocket, Throwable error) {
// An error doesn't necessarily mean the connection must be
// closed automatically
if (!channel.isOpen()) {
synchronized (stateLock) {
tryChangeState(State.ERROR);
}
} else if (error instanceof ProtocolException
&& error.getCause() instanceof WSProtocolException) {
WSProtocolException cause = (WSProtocolException) error.getCause();
logger.log(WARNING, "Failing connection {0}, reason: ''{1}''",
webSocket, cause.getMessage());
CloseCode cc = cause.getCloseCode();
transmitter.sendClose(cc, "").whenComplete((v, t) -> {
synchronized (stateLock) {
tryChangeState(State.ERROR);
}
try {
channel.close();
} catch (IOException e) {
logger.log(ERROR, e);
}
});
}
synchronized (visibilityLock) {
listener.onError(webSocket, error);
}
}
};
}
private boolean tryChangeState(State newState) {
assert Thread.holdsLock(stateLock);
if (state.isTerminal()) {
return false;
}
state = newState;
if (newState.isTerminal()) {
whenClosed.complete(null);
}
return true;
}
CompletionStage<Void> whenClosed() {
return whenClosed;
}
/*
* WebSocket connection internal state.
*/
private enum State {
/*
* Initial WebSocket state. The WebSocket is connected (i.e. remains in
* this state) unless proven otherwise. For example, by reading or
* writing operations on the channel.
*/
CONNECTED,
/*
* A Close message has been received by the client. No more messages
* will be received.
*/
CLOSED_REMOTELY,
/*
* A Close message has been sent by the client. No more messages can be
* sent.
*/
CLOSED_LOCALLY,
/*
* Close messages has been both sent and received (closing handshake)
* and TCP connection closed. Closed _cleanly_ in terms of RFC 6455.
*/
CLOSED,
/*
* The connection has been aborted by the client. Closed not _cleanly_
* in terms of RFC 6455.
*/
ABORTED,
/*
* The connection has been terminated due to a protocol or I/O error.
* Might happen during sending or receiving.
*/
ERROR;
/*
* Returns `true` if this state is terminal. If WebSocket has transited
* to such a state, if remains in it forever.
*/
boolean isTerminal() {
return this == CLOSED || this == ABORTED || this == ERROR;
}
}
}

175
jdk/src/java.httpclient/share/classes/java/net/http/WSBuilder.java Normal file
View File

@ -0,0 +1,175 @@
/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;
final class WSBuilder implements WebSocket.Builder {
private static final Set<String> FORBIDDEN_HEADERS =
new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
static {
List<String> headers = List.of("Connection", "Upgrade",
"Sec-WebSocket-Accept", "Sec-WebSocket-Extensions",
"Sec-WebSocket-Key", "Sec-WebSocket-Protocol",
"Sec-WebSocket-Version");
FORBIDDEN_HEADERS.addAll(headers);
}
private final URI uri;
private final HttpClient client;
private final LinkedHashMap<String, List<String>> headers = new LinkedHashMap<>();
private final WebSocket.Listener listener;
private Collection<String> subprotocols = Collections.emptyList();
private long timeout;
private TimeUnit timeUnit;
WSBuilder(URI uri, HttpClient client, WebSocket.Listener listener) {
checkURI(requireNonNull(uri, "uri"));
requireNonNull(client, "client");
requireNonNull(listener, "listener");
this.uri = uri;
this.listener = listener;
this.client = client;
}
@Override
public WebSocket.Builder header(String name, String value) {
requireNonNull(name, "name");
requireNonNull(value, "value");
if (FORBIDDEN_HEADERS.contains(name)) {
throw new IllegalArgumentException(
format("Header '%s' is used in the WebSocket Protocol", name));
}
List<String> values = headers.computeIfAbsent(name, n -> new LinkedList<>());
values.add(value);
return this;
}
@Override
public WebSocket.Builder subprotocols(String mostPreferred, String... lesserPreferred) {
requireNonNull(mostPreferred, "mostPreferred");
requireNonNull(lesserPreferred, "lesserPreferred");
this.subprotocols = checkSubprotocols(mostPreferred, lesserPreferred);
return this;
}
@Override
public WebSocket.Builder connectTimeout(long timeout, TimeUnit unit) {
if (timeout < 0) {
throw new IllegalArgumentException("Negative timeout: " + timeout);
}
requireNonNull(unit, "unit");
this.timeout = timeout;
this.timeUnit = unit;
return this;
}
@Override
public CompletableFuture<WebSocket> buildAsync() {
return WS.newInstanceAsync(this);
}
private static URI checkURI(URI uri) {
String s = uri.getScheme();
if (!("ws".equalsIgnoreCase(s) || "wss".equalsIgnoreCase(s))) {
throw new IllegalArgumentException
("URI scheme not ws or wss (RFC 6455 3.): " + s);
}
String fragment = uri.getFragment();
if (fragment != null) {
throw new IllegalArgumentException(format
("Fragment not allowed in a WebSocket URI (RFC 6455 3.): '%s'",
fragment));
}
return uri;
}
URI getUri() { return uri; }
HttpClient getClient() { return client; }
Map<String, List<String>> getHeaders() {
LinkedHashMap<String, List<String>> copy = new LinkedHashMap<>(headers.size());
headers.forEach((name, values) -> copy.put(name, new LinkedList<>(values)));
return copy;
}
WebSocket.Listener getListener() { return listener; }
Collection<String> getSubprotocols() {
return new ArrayList<>(subprotocols);
}
long getTimeout() { return timeout; }
TimeUnit getTimeUnit() { return timeUnit; }
private static Collection<String> checkSubprotocols(String mostPreferred,
String... lesserPreferred) {
checkSubprotocolSyntax(mostPreferred, "mostPreferred");
LinkedHashSet<String> sp = new LinkedHashSet<>(1 + lesserPreferred.length);
sp.add(mostPreferred);
for (int i = 0; i < lesserPreferred.length; i++) {
String p = lesserPreferred[i];
String location = format("lesserPreferred[%s]", i);
requireNonNull(p, location);
checkSubprotocolSyntax(p, location);
if (!sp.add(p)) {
throw new IllegalArgumentException(format(
"Duplicate subprotocols (RFC 6455 4.1.): '%s'", p));
}
}
return sp;
}
private static void checkSubprotocolSyntax(String subprotocol, String location) {
if (subprotocol.isEmpty()) {
throw new IllegalArgumentException
("Subprotocol name is empty (RFC 6455 4.1.): " + location);
}
if (!subprotocol.chars().allMatch(c -> 0x21 <= c && c <= 0x7e)) {
throw new IllegalArgumentException
("Subprotocol name contains illegal characters (RFC 6455 4.1.): "
+ location);
}
}
}

126
jdk/src/java.httpclient/share/classes/java/net/http/WSCharsetToolkit.java Normal file
View File

@ -0,0 +1,126 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
*/
package java.net.http;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import static java.lang.System.Logger.Level.WARNING;
import static java.net.http.WSUtils.EMPTY_BYTE_BUFFER;
import static java.net.http.WSUtils.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
/*
* A collection of tools for UTF-8 coding.
*/
final class WSCharsetToolkit {
private WSCharsetToolkit() { }
static final class Encoder {
private final CharsetEncoder encoder = UTF_8.newEncoder();
ByteBuffer encode(CharBuffer in) throws CharacterCodingException {
return encoder.encode(in);
}
// TODO:
// ByteBuffer[] encode(CharBuffer in) throws CharacterCodingException {
// return encoder.encode(in);
// }
}
static CharBuffer decode(ByteBuffer in) throws CharacterCodingException {
return UTF_8.newDecoder().decode(in);
}
static final class Decoder {
private final CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
{
decoder.onMalformedInput(CodingErrorAction.REPORT);
decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
}
private ByteBuffer leftovers = EMPTY_BYTE_BUFFER;
WSShared<CharBuffer> decode(WSShared<ByteBuffer> in, boolean endOfInput)
throws CharacterCodingException {
ByteBuffer b;
int rem = leftovers.remaining();
if (rem != 0) {
// TODO: We won't need this wasteful allocation & copying when
// JDK-8155222 has been resolved
b = ByteBuffer.allocate(rem + in.remaining());
b.put(leftovers).put(in.buffer()).flip();
} else {
b = in.buffer();
}
CharBuffer out = CharBuffer.allocate(b.remaining());
CoderResult r = decoder.decode(b, out, endOfInput);
if (r.isError()) {
r.throwException();
}
if (b.hasRemaining()) {
leftovers = ByteBuffer.allocate(b.remaining()).put(b).flip();
} else {
leftovers = EMPTY_BYTE_BUFFER;
}
// Since it's UTF-8, the assumption is leftovers.remaining() < 4
// (i.e. small). Otherwise a shared buffer should be used
if (!(leftovers.remaining() < 4)) {
logger.log(WARNING,
"The size of decoding leftovers is greater than expected: {0}",
leftovers.remaining());
}
b.position(b.limit()); // As if we always read to the end
in.dispose();
// Decoder promises that in the case of endOfInput == true:
// "...any remaining undecoded input will be treated as being
// malformed"
assert !(endOfInput && leftovers.hasRemaining()) : endOfInput + ", " + leftovers;
if (endOfInput) {
r = decoder.flush(out);
decoder.reset();
if (r.isOverflow()) {
// FIXME: for now I know flush() does nothing. But the
// implementation of UTF8 decoder might change. And if now
// flush() is a no-op, it is not guaranteed to remain so in
// the future
throw new InternalError("Not yet implemented");
}
}
out.flip();
return WSShared.wrap(out);
}
}
}

30
jdk/src/java.httpclient/share/classes/java/net/http/WSDisposable.java Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
interface WSDisposable {
void dispose();
}

67
jdk/src/java.httpclient/share/classes/java/net/http/WSDisposableText.java Normal file
View File

@ -0,0 +1,67 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
final class WSDisposableText implements WebSocket.Text, WSDisposable {
private final WSShared<CharBuffer> text;
WSDisposableText(WSShared<CharBuffer> text) {
this.text = text;
}
@Override
public int length() {
return text.buffer().length();
}
@Override
public char charAt(int index) {
return text.buffer().charAt(index);
}
@Override
public CharSequence subSequence(int start, int end) {
return text.buffer().subSequence(start, end);
}
@Override
public ByteBuffer asByteBuffer() {
throw new UnsupportedOperationException("To be removed from the API");
}
@Override
public String toString() {
return text.buffer().toString();
}
@Override
public void dispose() {
text.dispose();
}
}

486
jdk/src/java.httpclient/share/classes/java/net/http/WSFrame.java Normal file
View File

@ -0,0 +1,486 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.nio.ByteBuffer;
import static java.lang.String.format;
import static java.net.http.WSFrame.Opcode.ofCode;
import static java.net.http.WSUtils.dump;
/*
* A collection of utilities for reading, writing, and masking frames.
*/
final class WSFrame {
private WSFrame() { }
static final int MAX_HEADER_SIZE_BYTES = 2 + 8 + 4;
enum Opcode {
CONTINUATION (0x0),
TEXT (0x1),
BINARY (0x2),
NON_CONTROL_0x3(0x3),
NON_CONTROL_0x4(0x4),
NON_CONTROL_0x5(0x5),
NON_CONTROL_0x6(0x6),
NON_CONTROL_0x7(0x7),
CLOSE (0x8),
PING (0x9),
PONG (0xA),
CONTROL_0xB (0xB),
CONTROL_0xC (0xC),
CONTROL_0xD (0xD),
CONTROL_0xE (0xE),
CONTROL_0xF (0xF);
private static final Opcode[] opcodes;
static {
Opcode[] values = values();
opcodes = new Opcode[values.length];
for (Opcode c : values) {
assert opcodes[c.code] == null
: WSUtils.dump(c, c.code, opcodes[c.code]);
opcodes[c.code] = c;
}
}
private final byte code;
private final char shiftedCode;
private final String description;
Opcode(int code) {
this.code = (byte) code;
this.shiftedCode = (char) (code << 8);
this.description = format("%x (%s)", code, name());
}
boolean isControl() {
return (code & 0x8) != 0;
}
static Opcode ofCode(int code) {
return opcodes[code & 0xF];
}
@Override
public String toString() {
return description;
}
}
/*
* A utility to mask payload data.
*/
static final class Masker {
private final ByteBuffer acc = ByteBuffer.allocate(8);
private final int[] maskBytes = new int[4];
private int offset;
private long maskLong;
/*
* Sets up the mask.
*/
Masker mask(int value) {
acc.clear().putInt(value).putInt(value).flip();
for (int i = 0; i < maskBytes.length; i++) {
maskBytes[i] = acc.get(i);
}
offset = 0;
maskLong = acc.getLong(0);
return this;
}
/*
* Reads as many bytes as possible from the given input buffer, writing
* the resulting masked bytes to the given output buffer.
*
* src.remaining() <= dst.remaining() // TODO: do we need this restriction?
* 'src' and 'dst' can be the same ByteBuffer
*/
Masker applyMask(ByteBuffer src, ByteBuffer dst) {
if (src.remaining() > dst.remaining()) {
throw new IllegalArgumentException(dump(src, dst));
}
begin(src, dst);
loop(src, dst);
end(src, dst);
return this;
}
// Applying the remaining of the mask (strictly not more than 3 bytes)
// byte-wise
private void begin(ByteBuffer src, ByteBuffer dst) {
if (offset > 0) {
for (int i = src.position(), j = dst.position();
offset < 4 && i <= src.limit() - 1 && j <= dst.limit() - 1;
i++, j++, offset++) {
dst.put(j, (byte) (src.get(i) ^ maskBytes[offset]));
dst.position(j + 1);
src.position(i + 1);
}
offset &= 3;
}
}
private void loop(ByteBuffer src, ByteBuffer dst) {
int i = src.position();
int j = dst.position();
final int srcLim = src.limit() - 8;
final int dstLim = dst.limit() - 8;
for (; i <= srcLim && j <= dstLim; i += 8, j += 8) {
dst.putLong(j, (src.getLong(i) ^ maskLong));
}
if (i > src.limit()) {
src.position(i - 8);
} else {
src.position(i);
}
if (j > dst.limit()) {
dst.position(j - 8);
} else {
dst.position(j);
}
}
// Applying the mask to the remaining bytes byte-wise (don't make any
// assumptions on how many, hopefully not more than 7 for 64bit arch)
private void end(ByteBuffer src, ByteBuffer dst) {
for (int i = src.position(), j = dst.position();
i <= src.limit() - 1 && j <= dst.limit() - 1;
i++, j++, offset = (offset + 1) & 3) { // offset cycle through 0..3
dst.put(j, (byte) (src.get(i) ^ maskBytes[offset]));
src.position(i + 1);
dst.position(j + 1);
}
}
}
/*
* A builder of frame headers, capable of writing to a given buffer.
*
* The builder does not enforce any protocol-level rules, it simply writes
* a header structure to the buffer. The order of calls to intermediate
* methods is not significant.
*/
static final class HeaderBuilder {
private char firstChar;
private long payloadLen;
private int maskingKey;
private boolean mask;
HeaderBuilder fin(boolean value) {
if (value) {
firstChar |= 0b10000000_00000000;
} else {
firstChar &= ~0b10000000_00000000;
}
return this;
}
HeaderBuilder rsv1(boolean value) {
if (value) {
firstChar |= 0b01000000_00000000;
} else {
firstChar &= ~0b01000000_00000000;
}
return this;
}
HeaderBuilder rsv2(boolean value) {
if (value) {
firstChar |= 0b00100000_00000000;
} else {
firstChar &= ~0b00100000_00000000;
}
return this;
}
HeaderBuilder rsv3(boolean value) {
if (value) {
firstChar |= 0b00010000_00000000;
} else {
firstChar &= ~0b00010000_00000000;
}
return this;
}
HeaderBuilder opcode(Opcode value) {
firstChar = (char) ((firstChar & 0xF0FF) | value.shiftedCode);
return this;
}
HeaderBuilder payloadLen(long value) {
payloadLen = value;
firstChar &= 0b11111111_10000000; // Clear previous payload length leftovers
if (payloadLen < 126) {
firstChar |= payloadLen;
} else if (payloadLen < 65535) {
firstChar |= 126;
} else {
firstChar |= 127;
}
return this;
}
HeaderBuilder mask(int value) {
firstChar |= 0b00000000_10000000;
maskingKey = value;
mask = true;
return this;
}
HeaderBuilder noMask() {
firstChar &= ~0b00000000_10000000;
mask = false;
return this;
}
/*
* Writes the header to the given buffer.
*
* The buffer must have at least MAX_HEADER_SIZE_BYTES remaining. The
* buffer's position is incremented by the number of bytes written.
*/
void build(ByteBuffer buffer) {
buffer.putChar(firstChar);
if (payloadLen >= 126) {
if (payloadLen < 65535) {
buffer.putChar((char) payloadLen);
} else {
buffer.putLong(payloadLen);
}
}
if (mask) {
buffer.putInt(maskingKey);
}
}
}
/*
* A consumer of frame parts.
*
* Guaranteed to be called in the following order by the Frame.Reader:
*
* fin rsv1 rsv2 rsv3 opcode mask payloadLength maskingKey? payloadData+ endFrame
*/
interface Consumer {
void fin(boolean value);
void rsv1(boolean value);
void rsv2(boolean value);
void rsv3(boolean value);
void opcode(Opcode value);
void mask(boolean value);
void payloadLen(long value);
void maskingKey(int value);
/*
* Called when a part of the payload is ready to be consumed.
*
* Though may not yield a complete payload in a single invocation, i.e.
*
* data.remaining() < payloadLen
*
* the sum of `data.remaining()` passed to all invocations of this
* method will be equal to 'payloadLen', reported in
* `void payloadLen(long value)`
*
* No unmasking is done.
*/
void payloadData(WSShared<ByteBuffer> data, boolean isLast);
void endFrame(); // TODO: remove (payloadData(isLast=true)) should be enough
}
/*
* A Reader of Frames.
*
* No protocol-level rules are enforced, only frame structure.
*/
static final class Reader {
private static final int AWAITING_FIRST_BYTE = 1;
private static final int AWAITING_SECOND_BYTE = 2;
private static final int READING_16_LENGTH = 4;
private static final int READING_64_LENGTH = 8;
private static final int READING_MASK = 16;
private static final int READING_PAYLOAD = 32;
// A private buffer used to simplify multi-byte integers reading
private final ByteBuffer accumulator = ByteBuffer.allocate(8);
private int state = AWAITING_FIRST_BYTE;
private boolean mask;
private long payloadLength;
/*
* Reads at most one frame from the given buffer invoking the consumer's
* methods corresponding to the frame elements found.
*
* As much of the frame's payload, if any, is read. The buffers position
* is updated to reflect the number of bytes read.
*
* Throws WSProtocolException if the frame is malformed.
*/
void readFrame(WSShared<ByteBuffer> shared, Consumer consumer) {
ByteBuffer input = shared.buffer();
loop:
while (true) {
byte b;
switch (state) {
case AWAITING_FIRST_BYTE:
if (!input.hasRemaining()) {
break loop;
}
b = input.get();
consumer.fin( (b & 0b10000000) != 0);
consumer.rsv1((b & 0b01000000) != 0);
consumer.rsv2((b & 0b00100000) != 0);
consumer.rsv3((b & 0b00010000) != 0);
consumer.opcode(ofCode(b));
state = AWAITING_SECOND_BYTE;
continue loop;
case AWAITING_SECOND_BYTE:
if (!input.hasRemaining()) {
break loop;
}
b = input.get();
consumer.mask(mask = (b & 0b10000000) != 0);
byte p1 = (byte) (b & 0b01111111);
if (p1 < 126) {
assert p1 >= 0 : p1;
consumer.payloadLen(payloadLength = p1);
state = mask ? READING_MASK : READING_PAYLOAD;
} else if (p1 < 127) {
state = READING_16_LENGTH;
} else {
state = READING_64_LENGTH;
}
continue loop;
case READING_16_LENGTH:
if (!input.hasRemaining()) {
break loop;
}
b = input.get();
if (accumulator.put(b).position() < 2) {
continue loop;
}
payloadLength = accumulator.flip().getChar();
if (payloadLength < 126) {
throw notMinimalEncoding(payloadLength, 2);
}
consumer.payloadLen(payloadLength);
accumulator.clear();
state = mask ? READING_MASK : READING_PAYLOAD;
continue loop;
case READING_64_LENGTH:
if (!input.hasRemaining()) {
break loop;
}
b = input.get();
if (accumulator.put(b).position() < 8) {
continue loop;
}
payloadLength = accumulator.flip().getLong();
if (payloadLength < 0) {
throw negativePayload(payloadLength);
} else if (payloadLength < 65535) {
throw notMinimalEncoding(payloadLength, 8);
}
consumer.payloadLen(payloadLength);
accumulator.clear();
state = mask ? READING_MASK : READING_PAYLOAD;
continue loop;
case READING_MASK:
if (!input.hasRemaining()) {
break loop;
}
b = input.get();
if (accumulator.put(b).position() != 4) {
continue loop;
}
consumer.maskingKey(accumulator.flip().getInt());
accumulator.clear();
state = READING_PAYLOAD;
continue loop;
case READING_PAYLOAD:
// This state does not require any bytes to be available
// in the input buffer in order to proceed
boolean fullyRead;
int limit;
if (payloadLength <= input.remaining()) {
limit = input.position() + (int) payloadLength;
payloadLength = 0;
fullyRead = true;
} else {
limit = input.limit();
payloadLength -= input.remaining();
fullyRead = false;
}
// FIXME: consider a case where payloadLen != 0,
// but input.remaining() == 0
//
// There shouldn't be an invocation of payloadData with
// an empty buffer, as it would be an artifact of
// reading
consumer.payloadData(shared.share(input.position(), limit), fullyRead);
// Update the position manually, since reading the
// payload doesn't advance buffer's position
input.position(limit);
if (fullyRead) {
consumer.endFrame();
state = AWAITING_FIRST_BYTE;
}
break loop;
default:
throw new InternalError(String.valueOf(state));
}
}
}
private static WSProtocolException negativePayload(long payloadLength) {
return new WSProtocolException
("5.2.", format("Negative 64-bit payload length %s", payloadLength));
}
private static WSProtocolException notMinimalEncoding(long payloadLength, int numBytes) {
return new WSProtocolException
("5.2.", format("Payload length (%s) is not encoded with minimal number (%s) of bytes",
payloadLength, numBytes));
}
}
}

289
jdk/src/java.httpclient/share/classes/java/net/http/WSFrameConsumer.java Normal file
View File

@ -0,0 +1,289 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.http.WSFrame.Opcode;
import java.net.http.WebSocket.MessagePart;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.util.concurrent.atomic.AtomicInteger;
import static java.lang.String.format;
import static java.lang.System.Logger.Level.TRACE;
import static java.net.http.WSUtils.dump;
import static java.net.http.WSUtils.logger;
import static java.net.http.WebSocket.CloseCode.NOT_CONSISTENT;
import static java.net.http.WebSocket.CloseCode.of;
import static java.util.Objects.requireNonNull;
/*
* Consumes frame parts and notifies a message consumer, when there is
* sufficient data to produce a message, or part thereof.
*
* Data consumed but not yet translated is accumulated until it's sufficient to
* form a message.
*/
final class WSFrameConsumer implements WSFrame.Consumer {
private final AtomicInteger invocationOrder = new AtomicInteger();
private final WSMessageConsumer output;
private final WSCharsetToolkit.Decoder decoder = new WSCharsetToolkit.Decoder();
private boolean fin;
private Opcode opcode, originatingOpcode;
private MessagePart part = MessagePart.WHOLE;
private long payloadLen;
private WSShared<ByteBuffer> binaryData;
WSFrameConsumer(WSMessageConsumer output) {
this.output = requireNonNull(output);
}
@Override
public void fin(boolean value) {
assert invocationOrder.compareAndSet(0, 1) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
// Checked for being loggable because of autoboxing of 'value'
logger.log(TRACE, "Reading fin: {0}", value);
}
fin = value;
}
@Override
public void rsv1(boolean value) {
assert invocationOrder.compareAndSet(1, 2) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading rsv1: {0}", value);
}
if (value) {
throw new WSProtocolException("5.2.", "rsv1 bit is set unexpectedly");
}
}
@Override
public void rsv2(boolean value) {
assert invocationOrder.compareAndSet(2, 3) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading rsv2: {0}", value);
}
if (value) {
throw new WSProtocolException("5.2.", "rsv2 bit is set unexpectedly");
}
}
@Override
public void rsv3(boolean value) {
assert invocationOrder.compareAndSet(3, 4) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading rsv3: {0}", value);
}
if (value) {
throw new WSProtocolException("5.2.", "rsv3 bit is set unexpectedly");
}
}
@Override
public void opcode(Opcode v) {
assert invocationOrder.compareAndSet(4, 5) : dump(invocationOrder, v);
logger.log(TRACE, "Reading opcode: {0}", v);
if (v == Opcode.PING || v == Opcode.PONG || v == Opcode.CLOSE) {
if (!fin) {
throw new WSProtocolException("5.5.", "A fragmented control frame " + v);
}
opcode = v;
} else if (v == Opcode.TEXT || v == Opcode.BINARY) {
if (originatingOpcode != null) {
throw new WSProtocolException
("5.4.", format("An unexpected frame %s (fin=%s)", v, fin));
}
opcode = v;
if (!fin) {
originatingOpcode = v;
}
} else if (v == Opcode.CONTINUATION) {
if (originatingOpcode == null) {
throw new WSProtocolException
("5.4.", format("An unexpected frame %s (fin=%s)", v, fin));
}
opcode = v;
} else {
throw new WSProtocolException("5.2.", "An unknown opcode " + v);
}
}
@Override
public void mask(boolean value) {
assert invocationOrder.compareAndSet(5, 6) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading mask: {0}", value);
}
if (value) {
throw new WSProtocolException
("5.1.", "Received a masked frame from the server");
}
}
@Override
public void payloadLen(long value) {
assert invocationOrder.compareAndSet(6, 7) : dump(invocationOrder, value);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading payloadLen: {0}", value);
}
if (opcode.isControl()) {
if (value > 125) {
throw new WSProtocolException
("5.5.", format("A control frame %s has a payload length of %s",
opcode, value));
}
assert Opcode.CLOSE.isControl();
if (opcode == Opcode.CLOSE && value == 1) {
throw new WSProtocolException
("5.5.1.", "A Close frame's status code is only 1 byte long");
}
}
payloadLen = value;
}
@Override
public void maskingKey(int value) {
assert false : dump(invocationOrder, value);
}
@Override
public void payloadData(WSShared<ByteBuffer> data, boolean isLast) {
assert invocationOrder.compareAndSet(7, isLast ? 8 : 7)
: dump(invocationOrder, data, isLast);
if (logger.isLoggable(TRACE)) {
logger.log(TRACE, "Reading payloadData: data={0}, isLast={1}", data, isLast);
}
if (opcode.isControl()) {
if (binaryData != null) {
binaryData.put(data);
data.dispose();
} else if (!isLast) {
// The first chunk of the message
int remaining = data.remaining();
// It shouldn't be 125, otherwise the next chunk will be of size
// 0, which is not what Reader promises to deliver (eager
// reading)
assert remaining < 125 : dump(remaining);
WSShared<ByteBuffer> b = WSShared.wrap(ByteBuffer.allocate(125)).put(data);
data.dispose();
binaryData = b; // Will be disposed by the user
} else {
// The only chunk; will be disposed by the user
binaryData = data.position(data.limit()); // FIXME: remove this hack
}
} else {
part = determinePart(isLast);
boolean text = opcode == Opcode.TEXT || originatingOpcode == Opcode.TEXT;
if (!text) {
output.onBinary(part, data);
} else {
boolean binaryNonEmpty = data.hasRemaining();
WSShared<CharBuffer> textData;
try {
textData = decoder.decode(data, part.isLast());
} catch (CharacterCodingException e) {
throw new WSProtocolException
("5.6.", "Invalid UTF-8 sequence in frame " + opcode, NOT_CONSISTENT, e);
}
if (!(binaryNonEmpty && !textData.hasRemaining())) {
// If there's a binary data, that result in no text, then we
// don't deliver anything
output.onText(part, new WSDisposableText(textData));
}
}
}
}
@Override
public void endFrame() {
assert invocationOrder.compareAndSet(8, 0) : dump(invocationOrder);
if (opcode.isControl()) {
binaryData.flip();
}
switch (opcode) {
case CLOSE:
WebSocket.CloseCode cc;
String reason;
if (payloadLen == 0) {
cc = null;
reason = "";
} else {
ByteBuffer b = binaryData.buffer();
int len = b.remaining();
assert 2 <= len && len <= 125 : dump(len, payloadLen);
try {
cc = of(b.getChar());
reason = WSCharsetToolkit.decode(b).toString();
} catch (IllegalArgumentException e) {
throw new WSProtocolException
("5.5.1", "Incorrect status code", e);
} catch (CharacterCodingException e) {
throw new WSProtocolException
("5.5.1", "Close reason is a malformed UTF-8 sequence", e);
}
}
binaryData.dispose(); // Manual dispose
output.onClose(cc, reason);
break;
case PING:
output.onPing(binaryData);
binaryData = null;
break;
case PONG:
output.onPong(binaryData);
binaryData = null;
break;
default:
assert opcode == Opcode.TEXT || opcode == Opcode.BINARY
|| opcode == Opcode.CONTINUATION : dump(opcode);
if (fin) {
// It is always the last chunk:
// either TEXT(FIN=TRUE)/BINARY(FIN=TRUE) or CONT(FIN=TRUE)
originatingOpcode = null;
}
break;
}
payloadLen = 0;
opcode = null;
}
private MessagePart determinePart(boolean isLast) {
boolean lastChunk = fin && isLast;
switch (part) {
case LAST:
case WHOLE:
return lastChunk ? MessagePart.WHOLE : MessagePart.FIRST;
case FIRST:
case PART:
return lastChunk ? MessagePart.LAST : MessagePart.PART;
default:
throw new InternalError(String.valueOf(part));
}
}
}

29
jdk/src/java.rmi/share/classes/sun/rmi/transport/proxy/RMISocketInfo.java → jdk/src/java.httpclient/share/classes/java/net/http/WSMessageConsumer.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1996, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -22,18 +22,21 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.rmi.transport.proxy;
package java.net.http;
/**
* RMISocketInfo is an interface that extensions of the java.net.Socket
* class may use to provide more information on its capabilities.
*/
public interface RMISocketInfo {
import java.net.http.WebSocket.CloseCode;
import java.net.http.WebSocket.MessagePart;
import java.nio.ByteBuffer;
/**
* Return true if this socket can be used for more than one
* RMI call. If a socket does not implement this interface, then
* it is assumed to be reusable.
*/
public boolean isReusable();
interface WSMessageConsumer {
void onText(MessagePart part, WSDisposableText data);
void onBinary(MessagePart part, WSShared<ByteBuffer> data);
void onPing(WSShared<ByteBuffer> data);
void onPong(WSShared<ByteBuffer> data);
void onClose(CloseCode code, CharSequence reason);
}

189
jdk/src/java.httpclient/share/classes/java/net/http/WSMessageSender.java Normal file
View File

@ -0,0 +1,189 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.http.WSFrame.HeaderBuilder;
import java.net.http.WSFrame.Masker;
import java.net.http.WSOutgoingMessage.Binary;
import java.net.http.WSOutgoingMessage.Close;
import java.net.http.WSOutgoingMessage.Ping;
import java.net.http.WSOutgoingMessage.Pong;
import java.net.http.WSOutgoingMessage.StreamedText;
import java.net.http.WSOutgoingMessage.Text;
import java.net.http.WSOutgoingMessage.Visitor;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.security.SecureRandom;
import java.util.function.Consumer;
import static java.net.http.WSFrame.MAX_HEADER_SIZE_BYTES;
import static java.net.http.WSFrame.Opcode.BINARY;
import static java.net.http.WSFrame.Opcode.CLOSE;
import static java.net.http.WSFrame.Opcode.CONTINUATION;
import static java.net.http.WSFrame.Opcode.PING;
import static java.net.http.WSFrame.Opcode.PONG;
import static java.net.http.WSFrame.Opcode.TEXT;
import static java.util.Objects.requireNonNull;
/*
* A Sender of outgoing messages. Given a message,
*
* 1) constructs the frame
* 2) initiates the channel write
* 3) notifies when the message has been sent
*/
final class WSMessageSender {
private final Visitor frameBuilderVisitor;
private final Consumer<Throwable> completionEventConsumer;
private final WSWriter writer;
private final ByteBuffer[] buffers = new ByteBuffer[2];
WSMessageSender(RawChannel channel, Consumer<Throwable> completionEventConsumer) {
// Single reusable buffer that holds a header
this.buffers[0] = ByteBuffer.allocateDirect(MAX_HEADER_SIZE_BYTES);
this.frameBuilderVisitor = new FrameBuilderVisitor();
this.completionEventConsumer = completionEventConsumer;
this.writer = new WSWriter(channel, this.completionEventConsumer);
}
/*
* Tries to send the given message fully. Invoked once per message.
*/
boolean trySendFully(WSOutgoingMessage m) {
requireNonNull(m);
synchronized (this) {
try {
return sendNow(m);
} catch (Exception e) {
completionEventConsumer.accept(e);
return false;
}
}
}
private boolean sendNow(WSOutgoingMessage m) {
buffers[0].clear();
m.accept(frameBuilderVisitor);
buffers[0].flip();
return writer.tryWriteFully(buffers);
}
/*
* Builds and initiates a write of a frame, from a given message.
*/
class FrameBuilderVisitor implements Visitor {
private final SecureRandom random = new SecureRandom();
private final WSCharsetToolkit.Encoder encoder = new WSCharsetToolkit.Encoder();
private final Masker masker = new Masker();
private final HeaderBuilder headerBuilder = new HeaderBuilder();
private boolean previousIsLast = true;
@Override
public void visit(Text message) {
try {
buffers[1] = encoder.encode(CharBuffer.wrap(message.characters));
} catch (CharacterCodingException e) {
completionEventConsumer.accept(e);
return;
}
int mask = random.nextInt();
maskAndRewind(buffers[1], mask);
headerBuilder
.fin(message.isLast)
.opcode(previousIsLast ? TEXT : CONTINUATION)
.payloadLen(buffers[1].remaining())
.mask(mask)
.build(buffers[0]);
previousIsLast = message.isLast;
}
@Override
public void visit(StreamedText streamedText) {
throw new IllegalArgumentException("Not yet implemented");
}
@Override
public void visit(Binary message) {
buffers[1] = message.bytes;
int mask = random.nextInt();
maskAndRewind(buffers[1], mask);
headerBuilder
.fin(message.isLast)
.opcode(previousIsLast ? BINARY : CONTINUATION)
.payloadLen(message.bytes.remaining())
.mask(mask)
.build(buffers[0]);
previousIsLast = message.isLast;
}
@Override
public void visit(Ping message) {
buffers[1] = message.bytes;
int mask = random.nextInt();
maskAndRewind(buffers[1], mask);
headerBuilder
.fin(true)
.opcode(PING)
.payloadLen(message.bytes.remaining())
.mask(mask)
.build(buffers[0]);
}
@Override
public void visit(Pong message) {
buffers[1] = message.bytes;
int mask = random.nextInt();
maskAndRewind(buffers[1], mask);
headerBuilder
.fin(true)
.opcode(PONG)
.payloadLen(message.bytes.remaining())
.mask(mask)
.build(buffers[0]);
}
@Override
public void visit(Close message) {
buffers[1] = message.bytes;
int mask = random.nextInt();
maskAndRewind(buffers[1], mask);
headerBuilder
.fin(true)
.opcode(CLOSE)
.payloadLen(buffers[1].remaining())
.mask(mask)
.build(buffers[0]);
}
private void maskAndRewind(ByteBuffer b, int mask) {
int oldPos = b.position();
masker.mask(mask).applyMask(b, b);
b.position(oldPos);
}
}
}

268
jdk/src/java.httpclient/share/classes/java/net/http/WSOpeningHandshake.java Normal file
View File

@ -0,0 +1,268 @@
/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import static java.lang.String.format;
import static java.lang.System.Logger.Level.TRACE;
import static java.net.http.WSUtils.logger;
import static java.net.http.WSUtils.webSocketSpecViolation;
final class WSOpeningHandshake {
private static final String HEADER_CONNECTION = "Connection";
private static final String HEADER_UPGRADE = "Upgrade";
private static final String HEADER_ACCEPT = "Sec-WebSocket-Accept";
private static final String HEADER_EXTENSIONS = "Sec-WebSocket-Extensions";
private static final String HEADER_KEY = "Sec-WebSocket-Key";
private static final String HEADER_PROTOCOL = "Sec-WebSocket-Protocol";
private static final String HEADER_VERSION = "Sec-WebSocket-Version";
private static final String VALUE_VERSION = "13"; // WebSocket's lucky number
private static final SecureRandom srandom = new SecureRandom();
private final MessageDigest sha1;
{
try {
sha1 = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException e) {
// Shouldn't happen:
// SHA-1 must be available in every Java platform implementation
throw new InternalError("Minimum platform requirements are not met", e);
}
}
private final HttpRequest request;
private final Collection<String> subprotocols;
private final String nonce;
WSOpeningHandshake(WSBuilder b) {
URI httpURI = createHttpUri(b.getUri());
HttpRequest.Builder requestBuilder = b.getClient().request(httpURI);
if (b.getTimeUnit() != null) {
requestBuilder.timeout(b.getTimeUnit(), b.getTimeout());
}
Collection<String> s = b.getSubprotocols();
if (!s.isEmpty()) {
String p = s.stream().collect(Collectors.joining(", "));
requestBuilder.header(HEADER_PROTOCOL, p);
}
requestBuilder.header(HEADER_VERSION, VALUE_VERSION);
this.nonce = createNonce();
requestBuilder.header(HEADER_KEY, this.nonce);
this.request = requestBuilder.GET();
HttpRequestImpl r = (HttpRequestImpl) this.request;
r.isWebSocket(true);
r.setSystemHeader(HEADER_UPGRADE, "websocket");
r.setSystemHeader(HEADER_CONNECTION, "Upgrade");
this.subprotocols = s;
}
private URI createHttpUri(URI webSocketUri) {
// FIXME: check permission for WebSocket URI and translate it into http/https permission
logger.log(TRACE, "->createHttpUri(''{0}'')", webSocketUri);
String httpScheme = webSocketUri.getScheme().equalsIgnoreCase("ws")
? "http"
: "https";
try {
URI uri = new URI(httpScheme,
webSocketUri.getUserInfo(),
webSocketUri.getHost(),
webSocketUri.getPort(),
webSocketUri.getPath(),
webSocketUri.getQuery(),
null);
logger.log(TRACE, "<-createHttpUri: ''{0}''", uri);
return uri;
} catch (URISyntaxException e) {
// Shouldn't happen: URI invariant
throw new InternalError("Error translating WebSocket URI to HTTP URI", e);
}
}
CompletableFuture<Result> performAsync() {
// The whole dancing with thenCompose instead of thenApply is because
// WebSocketHandshakeException is a checked exception
return request.responseAsync()
.thenCompose(response -> {
try {
Result result = handleResponse(response);
return CompletableFuture.completedFuture(result);
} catch (WebSocketHandshakeException e) {
return CompletableFuture.failedFuture(e);
}
});
}
private Result handleResponse(HttpResponse response) throws WebSocketHandshakeException {
// By this point all redirects, authentications, etc. (if any) must have
// been done by the httpClient used by the WebSocket; so only 101 is
// expected
int statusCode = response.statusCode();
if (statusCode != 101) {
String m = webSocketSpecViolation("1.3.",
"Unable to complete handshake; HTTP response status code "
+ statusCode
);
throw new WebSocketHandshakeException(m, response);
}
HttpHeaders h = response.headers();
checkHeader(h, response, HEADER_UPGRADE, v -> v.equalsIgnoreCase("websocket"));
checkHeader(h, response, HEADER_CONNECTION, v -> v.equalsIgnoreCase("Upgrade"));
checkVersion(response, h);
checkAccept(response, h);
checkExtensions(response, h);
String subprotocol = checkAndReturnSubprotocol(response, h);
RawChannel channel = ((HttpResponseImpl) response).rawChannel();
return new Result(subprotocol, channel);
}
private void checkExtensions(HttpResponse response, HttpHeaders headers)
throws WebSocketHandshakeException {
List<String> ext = headers.allValues(HEADER_EXTENSIONS);
if (!ext.isEmpty()) {
String m = webSocketSpecViolation("4.1.",
"Server responded with extension(s) though none were requested "
+ Arrays.toString(ext.toArray())
);
throw new WebSocketHandshakeException(m, response);
}
}
private String checkAndReturnSubprotocol(HttpResponse response, HttpHeaders headers)
throws WebSocketHandshakeException {
assert response.statusCode() == 101 : response.statusCode();
List<String> sp = headers.allValues(HEADER_PROTOCOL);
int size = sp.size();
if (size == 0) {
// In this case the subprotocol requested (if any) by the client
// doesn't matter. If there is no such header in the response, then
// the server doesn't want to use any subprotocol
return null;
} else if (size > 1) {
// We don't know anything about toString implementation of this
// list, so let's create an array
String m = webSocketSpecViolation("4.1.",
"Server responded with multiple subprotocols: "
+ Arrays.toString(sp.toArray())
);
throw new WebSocketHandshakeException(m, response);
} else {
String selectedSubprotocol = sp.get(0);
if (this.subprotocols.contains(selectedSubprotocol)) {
return selectedSubprotocol;
} else {
String m = webSocketSpecViolation("4.1.",
format("Server responded with a subprotocol " +
"not among those requested: '%s'",
selectedSubprotocol));
throw new WebSocketHandshakeException(m, response);
}
}
}
private void checkAccept(HttpResponse response, HttpHeaders headers)
throws WebSocketHandshakeException {
assert response.statusCode() == 101 : response.statusCode();
String x = nonce + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
sha1.update(x.getBytes(StandardCharsets.ISO_8859_1));
String expected = Base64.getEncoder().encodeToString(sha1.digest());
checkHeader(headers, response, HEADER_ACCEPT, actual -> actual.trim().equals(expected));
}
private void checkVersion(HttpResponse response, HttpHeaders headers)
throws WebSocketHandshakeException {
assert response.statusCode() == 101 : response.statusCode();
List<String> versions = headers.allValues(HEADER_VERSION);
if (versions.isEmpty()) { // That's normal and expected
return;
}
String m = webSocketSpecViolation("4.4.",
"Server responded with version(s) "
+ Arrays.toString(versions.toArray()));
throw new WebSocketHandshakeException(m, response);
}
//
// Checks whether there's only one value for the header with the given name
// and the value satisfies the predicate.
//
private static void checkHeader(HttpHeaders headers,
HttpResponse response,
String headerName,
Predicate<? super String> valuePredicate)
throws WebSocketHandshakeException {
assert response.statusCode() == 101 : response.statusCode();
List<String> values = headers.allValues(headerName);
if (values.isEmpty()) {
String m = webSocketSpecViolation("4.1.",
format("Server response field '%s' is missing", headerName)
);
throw new WebSocketHandshakeException(m, response);
} else if (values.size() > 1) {
String m = webSocketSpecViolation("4.1.",
format("Server response field '%s' has multiple values", headerName)
);
throw new WebSocketHandshakeException(m, response);
}
if (!valuePredicate.test(values.get(0))) {
String m = webSocketSpecViolation("4.1.",
format("Server response field '%s' is incorrect", headerName)
);
throw new WebSocketHandshakeException(m, response);
}
}
private static String createNonce() {
byte[] bytes = new byte[16];
srandom.nextBytes(bytes);
return Base64.getEncoder().encodeToString(bytes);
}
static final class Result {
final String subprotocol;
final RawChannel channel;
private Result(String subprotocol, RawChannel channel) {
this.subprotocol = subprotocol;
this.channel = channel;
}
}
}

164
jdk/src/java.httpclient/share/classes/java/net/http/WSOutgoingMessage.java Normal file
View File

@ -0,0 +1,164 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.nio.ByteBuffer;
import java.util.stream.Stream;
abstract class WSOutgoingMessage {
interface Visitor {
void visit(Text message);
void visit(StreamedText message);
void visit(Binary message);
void visit(Ping message);
void visit(Pong message);
void visit(Close message);
}
abstract void accept(Visitor visitor);
private WSOutgoingMessage() { }
static final class Text extends WSOutgoingMessage {
public final boolean isLast;
public final CharSequence characters;
Text(boolean isLast, CharSequence characters) {
this.isLast = isLast;
this.characters = characters;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[isLast=" + isLast
+ ", characters=" + WSUtils.toString(characters) + "]";
}
}
static final class StreamedText extends WSOutgoingMessage {
public final Stream<? extends CharSequence> characters;
StreamedText(Stream<? extends CharSequence> characters) {
this.characters = characters;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[characters=" + characters + "]";
}
}
static final class Binary extends WSOutgoingMessage {
public final boolean isLast;
public final ByteBuffer bytes;
Binary(boolean isLast, ByteBuffer bytes) {
this.isLast = isLast;
this.bytes = bytes;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[isLast=" + isLast
+ ", bytes=" + WSUtils.toString(bytes) + "]";
}
}
static final class Ping extends WSOutgoingMessage {
public final ByteBuffer bytes;
Ping(ByteBuffer bytes) {
this.bytes = bytes;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[" + WSUtils.toString(bytes) + "]";
}
}
static final class Pong extends WSOutgoingMessage {
public final ByteBuffer bytes;
Pong(ByteBuffer bytes) {
this.bytes = bytes;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[" + WSUtils.toString(bytes) + "]";
}
}
static final class Close extends WSOutgoingMessage {
public final ByteBuffer bytes;
Close(ByteBuffer bytes) {
this.bytes = bytes;
}
@Override
void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[" + WSUtils.toString(bytes) + "]";
}
}
}

68
jdk/src/java.httpclient/share/classes/java/net/http/WSProtocolException.java Normal file
View File

@ -0,0 +1,68 @@
package java.net.http;
import java.net.http.WebSocket.CloseCode;
import static java.net.http.WebSocket.CloseCode.PROTOCOL_ERROR;
import static java.util.Objects.requireNonNull;
//
// Special kind of exception closed from the outside world.
//
// Used as a "marker exception" for protocol issues in the incoming data, so the
// implementation could close the connection and specify an appropriate status
// code.
//
// A separate 'section' argument makes it more uncomfortable to be lazy and to
// leave a relevant spec reference empty :-) As a bonus all messages have the
// same style.
//
final class WSProtocolException extends RuntimeException {
private static final long serialVersionUID = 1L;
private final CloseCode closeCode;
private final String section;
WSProtocolException(String section, String detail) {
this(section, detail, PROTOCOL_ERROR);
}
WSProtocolException(String section, String detail, Throwable cause) {
this(section, detail, PROTOCOL_ERROR, cause);
}
private WSProtocolException(String section, String detail, CloseCode code) {
super(formatMessage(section, detail));
this.closeCode = requireNonNull(code);
this.section = section;
}
WSProtocolException(String section, String detail, CloseCode code,
Throwable cause) {
super(formatMessage(section, detail), cause);
this.closeCode = requireNonNull(code);
this.section = section;
}
private static String formatMessage(String section, String detail) {
if (requireNonNull(section).isEmpty()) {
throw new IllegalArgumentException();
}
if (requireNonNull(detail).isEmpty()) {
throw new IllegalArgumentException();
}
return WSUtils.webSocketSpecViolation(section, detail);
}
CloseCode getCloseCode() {
return closeCode;
}
public String getSection() {
return section;
}
@Override
public String toString() {
return super.toString() + "[" + closeCode + "]";
}
}

275
jdk/src/java.httpclient/share/classes/java/net/http/WSReceiver.java Normal file
View File

@ -0,0 +1,275 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.ProtocolException;
import java.net.http.WebSocket.Listener;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.util.Optional;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;
import static java.lang.System.Logger.Level.ERROR;
import static java.net.http.WSUtils.EMPTY_BYTE_BUFFER;
import static java.net.http.WSUtils.logger;
/*
* Receives incoming data from the channel and converts it into a sequence of
* messages, which are then passed to the listener.
*/
final class WSReceiver {
private final Listener listener;
private final WebSocket webSocket;
private final Supplier<WSShared<ByteBuffer>> buffersSupplier =
new WSSharedPool<>(() -> ByteBuffer.allocateDirect(32768), 2);
private final RawChannel channel;
private final RawChannel.NonBlockingEvent channelEvent;
private final WSSignalHandler handler;
private final AtomicLong demand = new AtomicLong();
private final AtomicBoolean readable = new AtomicBoolean();
private boolean started;
private volatile boolean closed;
private final WSFrame.Reader reader = new WSFrame.Reader();
private final WSFrameConsumer frameConsumer;
private WSShared<ByteBuffer> buf = WSShared.wrap(EMPTY_BYTE_BUFFER);
private WSShared<ByteBuffer> data; // TODO: initialize with leftovers from the RawChannel
WSReceiver(Listener listener, WebSocket webSocket, Executor executor,
RawChannel channel) {
this.listener = listener;
this.webSocket = webSocket;
this.channel = channel;
handler = new WSSignalHandler(executor, this::react);
channelEvent = createChannelEvent();
this.frameConsumer = new WSFrameConsumer(new MessageConsumer());
}
private void react() {
synchronized (this) {
while (demand.get() > 0 && !closed) {
try {
if (data == null) {
if (!getData()) {
break;
}
}
reader.readFrame(data, frameConsumer);
if (!data.hasRemaining()) {
data.dispose();
data = null;
}
// In case of exception we don't need to clean any state,
// since it's the terminal condition anyway. Nothing will be
// retried.
} catch (WSProtocolException e) {
// Translate into ProtocolException
closeExceptionally(new ProtocolException().initCause(e));
} catch (Exception e) {
closeExceptionally(e);
}
}
}
}
long request(long n) {
long newDemand = demand.accumulateAndGet(n, (p, i) -> p + i < 0 ? Long.MAX_VALUE : p + i);
handler.signal();
assert newDemand >= 0 : newDemand;
return newDemand;
}
private boolean getData() throws IOException {
if (!readable.get()) {
return false;
}
if (!buf.hasRemaining()) {
buf.dispose();
buf = buffersSupplier.get();
assert buf.hasRemaining() : buf;
}
int oldPosition = buf.position();
int oldLimit = buf.limit();
int numRead = channel.read(buf.buffer());
if (numRead > 0) {
data = buf.share(oldPosition, oldPosition + numRead);
buf.select(buf.limit(), oldLimit); // Move window to the free region
return true;
} else if (numRead == 0) {
readable.set(false);
channel.registerEvent(channelEvent);
return false;
} else {
assert numRead < 0 : numRead;
throw new WSProtocolException
("7.2.1.", "Stream ended before a Close frame has been received");
}
}
void start() {
synchronized (this) {
if (started) {
throw new IllegalStateException("Already started");
}
started = true;
try {
channel.registerEvent(channelEvent);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
try {
listener.onOpen(webSocket);
} catch (Exception e) {
closeExceptionally(new RuntimeException("onOpen threw an exception", e));
}
}
}
private void close() { // TODO: move to WS.java
closed = true;
}
private void closeExceptionally(Throwable error) { // TODO: move to WS.java
close();
try {
listener.onError(webSocket, error);
} catch (Exception e) {
logger.log(ERROR, "onError threw an exception", e);
}
}
private final class MessageConsumer implements WSMessageConsumer {
@Override
public void onText(WebSocket.MessagePart part, WSDisposableText data) {
decrementDemand();
CompletionStage<?> cs;
try {
cs = listener.onText(webSocket, data, part);
} catch (Exception e) {
closeExceptionally(new RuntimeException("onText threw an exception", e));
return;
}
follow(cs, data, "onText");
}
@Override
public void onBinary(WebSocket.MessagePart part, WSShared<ByteBuffer> data) {
decrementDemand();
CompletionStage<?> cs;
try {
cs = listener.onBinary(webSocket, data.buffer(), part);
} catch (Exception e) {
closeExceptionally(new RuntimeException("onBinary threw an exception", e));
return;
}
follow(cs, data, "onBinary");
}
@Override
public void onPing(WSShared<ByteBuffer> data) {
decrementDemand();
CompletionStage<?> cs;
try {
cs = listener.onPing(webSocket, data.buffer());
} catch (Exception e) {
closeExceptionally(new RuntimeException("onPing threw an exception", e));
return;
}
follow(cs, data, "onPing");
}
@Override
public void onPong(WSShared<ByteBuffer> data) {
decrementDemand();
CompletionStage<?> cs;
try {
cs = listener.onPong(webSocket, data.buffer());
} catch (Exception e) {
closeExceptionally(new RuntimeException("onPong threw an exception", e));
return;
}
follow(cs, data, "onPong");
}
@Override
public void onClose(WebSocket.CloseCode code, CharSequence reason) {
decrementDemand();
try {
close();
listener.onClose(webSocket, Optional.ofNullable(code), reason.toString());
} catch (Exception e) {
logger.log(ERROR, "onClose threw an exception", e);
}
}
}
private void follow(CompletionStage<?> cs, WSDisposable d, String source) {
if (cs == null) {
d.dispose();
} else {
cs.whenComplete((whatever, error) -> {
if (error != null) {
String m = "CompletionStage returned by " + source + " completed exceptionally";
closeExceptionally(new RuntimeException(m, error));
}
d.dispose();
});
}
}
private void decrementDemand() {
long newDemand = demand.decrementAndGet();
assert newDemand >= 0 : newDemand;
}
private RawChannel.NonBlockingEvent createChannelEvent() {
return new RawChannel.NonBlockingEvent() {
@Override
public int interestOps() {
return SelectionKey.OP_READ;
}
@Override
public void handle() {
boolean wasNotReadable = readable.compareAndSet(false, true);
assert wasNotReadable;
handler.signal();
}
@Override
public String toString() {
return "Read readiness event [" + channel + "]";
}
};
}
}

202
jdk/src/java.httpclient/share/classes/java/net/http/WSShared.java Normal file
View File

@ -0,0 +1,202 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
//
// +-----------+---------------+------------ ~ ------+
// | shared#1 | shared#2 | non-shared |
// +-----------+---------------+------------ ~ ------+
// | |
// |<------------------ shared0 ---------- ~ ----->|
//
//
// Objects of the type are not thread-safe. It's the responsibility of the
// client to access shared buffers safely between threads.
//
// It would be perfect if we could extend java.nio.Buffer, but it's not an
// option since Buffer and all its descendants have package-private
// constructors.
//
abstract class WSShared<T extends Buffer> implements WSDisposable {
protected final AtomicBoolean disposed = new AtomicBoolean();
protected final T buffer;
protected WSShared(T buffer) {
this.buffer = Objects.requireNonNull(buffer);
}
static <T extends Buffer> WSShared<T> wrap(T buffer) {
return new WSShared<>(buffer) {
@Override
WSShared<T> share(int pos, int limit) {
throw new UnsupportedOperationException();
}
};
}
// TODO: should be a terminal operation as after it returns the buffer might
// have escaped (we can't protect it any more)
public T buffer() {
checkDisposed();
return buffer;
}
abstract WSShared<T> share(final int pos, final int limit);
WSShared<T> select(final int pos, final int limit) {
checkRegion(pos, limit, buffer());
select(pos, limit, buffer());
return this;
}
@Override
public void dispose() {
if (!disposed.compareAndSet(false, true)) {
throw new IllegalStateException("Has been disposed previously");
}
}
int limit() {
return buffer().limit();
}
WSShared<T> limit(int newLimit) {
buffer().limit(newLimit);
return this;
}
int position() {
return buffer().position();
}
WSShared<T> position(int newPosition) {
buffer().position(newPosition);
return this;
}
int remaining() {
return buffer().remaining();
}
boolean hasRemaining() {
return buffer().hasRemaining();
}
WSShared<T> flip() {
buffer().flip();
return this;
}
WSShared<T> rewind() {
buffer().rewind();
return this;
}
WSShared<T> put(WSShared<? extends T> src) {
put(this.buffer(), src.buffer());
return this;
}
static void checkRegion(int position, int limit, Buffer buffer) {
if (position < 0 || position > buffer.capacity()) {
throw new IllegalArgumentException("position: " + position);
}
if (limit < 0 || limit > buffer.capacity()) {
throw new IllegalArgumentException("limit: " + limit);
}
if (limit < position) {
throw new IllegalArgumentException
("limit < position: limit=" + limit + ", position=" + position);
}
}
void select(int newPos, int newLim, Buffer buffer) {
int oldPos = buffer.position();
int oldLim = buffer.limit();
assert 0 <= oldPos && oldPos <= oldLim && oldLim <= buffer.capacity();
if (oldLim <= newPos) {
buffer().limit(newLim).position(newPos);
} else {
buffer.position(newPos).limit(newLim);
}
}
// The same as dst.put(src)
static <T extends Buffer> T put(T dst, T src) {
if (dst instanceof ByteBuffer) {
((ByteBuffer) dst).put((ByteBuffer) src);
} else if (dst instanceof CharBuffer) {
((CharBuffer) dst).put((CharBuffer) src);
} else {
// We don't work with buffers of other types
throw new IllegalArgumentException();
}
return dst;
}
// TODO: Remove when JDK-8150785 has been done
@SuppressWarnings("unchecked")
static <T extends Buffer> T slice(T buffer) {
if (buffer instanceof ByteBuffer) {
return (T) ((ByteBuffer) buffer).slice();
} else if (buffer instanceof CharBuffer) {
return (T) ((CharBuffer) buffer).slice();
} else {
// We don't work with buffers of other types
throw new IllegalArgumentException();
}
}
// TODO: Remove when JDK-8150785 has been done
@SuppressWarnings("unchecked")
static <T extends Buffer> T duplicate(T buffer) {
if (buffer instanceof ByteBuffer) {
return (T) ((ByteBuffer) buffer).duplicate();
} else if (buffer instanceof CharBuffer) {
return (T) ((CharBuffer) buffer).duplicate();
} else {
// We don't work with buffers of other types
throw new IllegalArgumentException();
}
}
@Override
public String toString() {
return super.toString() + "[" + WSUtils.toString(buffer()) + "]";
}
private void checkDisposed() {
if (disposed.get()) {
throw new IllegalStateException("Has been disposed previously");
}
}
}

148
jdk/src/java.httpclient/share/classes/java/net/http/WSSharedPool.java Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.nio.Buffer;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import static java.lang.System.Logger.Level.TRACE;
import static java.net.http.WSShared.duplicate;
import static java.net.http.WSUtils.logger;
import static java.util.Objects.requireNonNull;
final class WSSharedPool<T extends Buffer> implements Supplier<WSShared<T>> {
private final Supplier<T> factory;
private final BlockingQueue<T> queue;
WSSharedPool(Supplier<T> factory, int maxPoolSize) {
this.factory = requireNonNull(factory);
this.queue = new LinkedBlockingQueue<>(maxPoolSize);
}
@Override
public Pooled get() {
T b = queue.poll();
if (b == null) {
logger.log(TRACE, "Pool {0} contains no free buffers", this);
b = requireNonNull(factory.get());
}
Pooled buf = new Pooled(new AtomicInteger(1), b, duplicate(b));
logger.log(TRACE, "Pool {0} created new buffer {1}", this, buf);
return buf;
}
private void put(Pooled b) {
assert b.disposed.get() && b.refCount.get() == 0
: WSUtils.dump(b.disposed, b.refCount, b);
b.shared.clear();
boolean accepted = queue.offer(b.getShared());
if (logger.isLoggable(TRACE)) {
if (accepted) {
logger.log(TRACE, "Pool {0} accepted {1}", this, b);
} else {
logger.log(TRACE, "Pool {0} discarded {1}", this, b);
}
}
}
@Override
public String toString() {
return super.toString() + "[queue.size=" + queue.size() + "]";
}
private final class Pooled extends WSShared<T> {
private final AtomicInteger refCount;
private final T shared;
private Pooled(AtomicInteger refCount, T shared, T region) {
super(region);
this.refCount = refCount;
this.shared = shared;
}
private T getShared() {
return shared;
}
@Override
@SuppressWarnings("unchecked")
public Pooled share(final int pos, final int limit) {
synchronized (this) {
T buffer = buffer();
checkRegion(pos, limit, buffer);
final int oldPos = buffer.position();
final int oldLimit = buffer.limit();
select(pos, limit, buffer);
T slice = WSShared.slice(buffer);
select(oldPos, oldLimit, buffer);
referenceAndGetCount();
Pooled buf = new Pooled(refCount, shared, slice);
logger.log(TRACE, "Shared {0} from {1}", buf, this);
return buf;
}
}
@Override
public void dispose() {
logger.log(TRACE, "Disposed {0}", this);
super.dispose();
if (dereferenceAndGetCount() == 0) {
WSSharedPool.this.put(this);
}
}
private int referenceAndGetCount() {
return refCount.updateAndGet(n -> {
if (n != Integer.MAX_VALUE) {
return n + 1;
} else {
throw new IllegalArgumentException
("Too many references: " + this);
}
});
}
private int dereferenceAndGetCount() {
return refCount.updateAndGet(n -> {
if (n > 0) {
return n - 1;
} else {
throw new InternalError();
}
});
}
@Override
public String toString() {
return WSUtils.toStringSimple(this) + "[" + WSUtils.toString(buffer)
+ "[refCount=" + refCount + ", disposed=" + disposed + "]]";
}
}
}

137
jdk/src/java.httpclient/share/classes/java/net/http/WSSignalHandler.java Normal file
View File

@ -0,0 +1,137 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import static java.util.Objects.requireNonNull;
//
// The problem:
// ------------
// 1. For every invocation of 'signal()' there must be at least
// 1 invocation of 'handler.run()' that goes after
// 2. There must be no more than 1 thread running the 'handler.run()'
// at any given time
//
// For example, imagine each signal increments (+1) some number. Then the
// handler responds (eventually) the way that makes the number 0.
//
// For each signal there's a response. Several signals may be handled by a
// single response.
//
final class WSSignalHandler {
// In this state the task is neither submitted nor running.
// No one is handling signals. If a new signal has been received, the task
// has to be submitted to the executor in order to handle this signal.
private static final int DONE = 0;
// In this state the task is running.
// * If the signaller has found the task in this state it will try to change
// the state to RERUN in order to make the already running task to handle
// the new signal before exiting.
// * If the task has found itself in this state it will exit.
private static final int RUNNING = 1;
// A signal to the task, that it must rerun on the spot (without being
// resubmitted to the executor).
// If the task has found itself in this state it resets the state to
// RUNNING and repeats the pass.
private static final int RERUN = 2;
private final AtomicInteger state = new AtomicInteger(DONE);
private final Executor executor;
private final Runnable task;
WSSignalHandler(Executor executor, Runnable handler) {
this.executor = requireNonNull(executor);
requireNonNull(handler);
task = () -> {
while (!Thread.currentThread().isInterrupted()) {
try {
handler.run();
} catch (Exception e) {
// Sorry, the task won't be automatically retried;
// hope next signals (if any) will kick off the handling
state.set(DONE);
throw e;
}
int prev = state.getAndUpdate(s -> {
if (s == RUNNING) {
return DONE;
} else {
return RUNNING;
}
});
// Can't be DONE, since only the task itself may transit state
// into DONE (with one exception: RejectedExecution in signal();
// but in that case we couldn't be here at all)
assert prev == RUNNING || prev == RERUN;
if (prev == RUNNING) {
break;
}
}
};
}
// Invoked by outer code to signal
void signal() {
int prev = state.getAndUpdate(s -> {
switch (s) {
case RUNNING:
return RERUN;
case DONE:
return RUNNING;
case RERUN:
return RERUN;
default:
throw new InternalError(String.valueOf(s));
}
});
if (prev != DONE) {
// Nothing to do! piggybacking on previous signal
return;
}
try {
executor.execute(task);
} catch (RejectedExecutionException e) {
// Sorry some signal() invocations may have been accepted, but won't
// be done, since the 'task' couldn't be submitted
state.set(DONE);
throw e;
}
}
}

176
jdk/src/java.httpclient/share/classes/java/net/http/WSTransmitter.java Normal file
View File

@ -0,0 +1,176 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.http.WSOutgoingMessage.Binary;
import java.net.http.WSOutgoingMessage.Close;
import java.net.http.WSOutgoingMessage.Ping;
import java.net.http.WSOutgoingMessage.Pong;
import java.net.http.WSOutgoingMessage.StreamedText;
import java.net.http.WSOutgoingMessage.Text;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CoderResult;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
import java.util.stream.Stream;
import static java.lang.String.format;
import static java.net.http.Pair.pair;
/*
* Prepares outgoing messages for transmission. Verifies the WebSocket state,
* places the message on the outbound queue, and notifies the signal handler.
*/
final class WSTransmitter {
private final BlockingQueue<Pair<WSOutgoingMessage, CompletableFuture<Void>>>
backlog = new LinkedBlockingQueue<>();
private final WSMessageSender sender;
private final WSSignalHandler handler;
private boolean previousMessageSent = true;
private boolean canSendBinary = true;
private boolean canSendText = true;
WSTransmitter(Executor executor, RawChannel channel, Consumer<Throwable> errorHandler) {
this.handler = new WSSignalHandler(executor, this::handleSignal);
Consumer<Throwable> sendCompletion = (error) -> {
synchronized (this) {
if (error == null) {
previousMessageSent = true;
handler.signal();
} else {
errorHandler.accept(error);
backlog.forEach(p -> p.second.completeExceptionally(error));
backlog.clear();
}
}
};
this.sender = new WSMessageSender(channel, sendCompletion);
}
CompletableFuture<Void> sendText(CharSequence message, boolean isLast) {
checkAndUpdateText(isLast);
return acceptMessage(new Text(isLast, message));
}
CompletableFuture<Void> sendText(Stream<? extends CharSequence> message) {
checkAndUpdateText(true);
return acceptMessage(new StreamedText(message));
}
CompletableFuture<Void> sendBinary(ByteBuffer message, boolean isLast) {
checkAndUpdateBinary(isLast);
return acceptMessage(new Binary(isLast, message));
}
CompletableFuture<Void> sendPing(ByteBuffer message) {
checkSize(message.remaining(), 125);
return acceptMessage(new Ping(message));
}
CompletableFuture<Void> sendPong(ByteBuffer message) {
checkSize(message.remaining(), 125);
return acceptMessage(new Pong(message));
}
CompletableFuture<Void> sendClose(WebSocket.CloseCode code, CharSequence reason) {
return acceptMessage(createCloseMessage(code, reason));
}
CompletableFuture<Void> sendClose() {
return acceptMessage(new Close(ByteBuffer.allocate(0)));
}
private CompletableFuture<Void> acceptMessage(WSOutgoingMessage m) {
CompletableFuture<Void> cf = new CompletableFuture<>();
synchronized (this) {
backlog.offer(pair(m, cf));
}
handler.signal();
return cf;
}
/* Callback for pulling messages from the queue, and initiating the send. */
private void handleSignal() {
synchronized (this) {
while (!backlog.isEmpty() && previousMessageSent) {
previousMessageSent = false;
Pair<WSOutgoingMessage, CompletableFuture<Void>> p = backlog.peek();
boolean sent = sender.trySendFully(p.first);
if (sent) {
backlog.remove();
p.second.complete(null);
previousMessageSent = true;
}
}
}
}
private Close createCloseMessage(WebSocket.CloseCode code, CharSequence reason) {
// TODO: move to construction of CloseDetail (JDK-8155621)
ByteBuffer b = ByteBuffer.allocateDirect(125).putChar((char) code.getCode());
CoderResult result = StandardCharsets.UTF_8.newEncoder()
.encode(CharBuffer.wrap(reason), b, true);
if (result.isError()) {
try {
result.throwException();
} catch (CharacterCodingException e) {
throw new IllegalArgumentException("Reason is a malformed UTF-16 sequence", e);
}
} else if (result.isOverflow()) {
throw new IllegalArgumentException("Reason is too long");
}
return new Close(b.flip());
}
private void checkSize(int size, int maxSize) {
if (size > maxSize) {
throw new IllegalArgumentException(
format("The message is too long: %s;" +
" expected not longer than %s", size, maxSize)
);
}
}
private void checkAndUpdateText(boolean isLast) {
if (!canSendText) {
throw new IllegalStateException("Unexpected text message");
}
canSendBinary = isLast;
}
private void checkAndUpdateBinary(boolean isLast) {
if (!canSendBinary) {
throw new IllegalStateException("Unexpected binary message");
}
canSendText = isLast;
}
}

75
jdk/src/java.httpclient/share/classes/java/net/http/WSUtils.java Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.Arrays;
final class WSUtils {
private WSUtils() { }
static final System.Logger logger = System.getLogger("java.net.http.WebSocket");
static final ByteBuffer EMPTY_BYTE_BUFFER = ByteBuffer.allocate(0);
//
// Helps to trim long names (packages, nested/inner types) in logs/toString
//
static String toStringSimple(Object o) {
return o.getClass().getSimpleName() + "@" +
Integer.toHexString(System.identityHashCode(o));
}
//
// 1. It adds a number of remaining bytes;
// 2. Standard Buffer-type toString for CharBuffer (since it adheres to the
// contract of java.lang.CharSequence.toString() which is both not too
// useful and not too private)
//
static String toString(Buffer b) {
return toStringSimple(b)
+ "[pos=" + b.position()
+ " lim=" + b.limit()
+ " cap=" + b.capacity()
+ " rem=" + b.remaining() + "]";
}
static String toString(CharSequence s) {
return s == null
? "null"
: toStringSimple(s) + "[len=" + s.length() + "]";
}
static String dump(Object... objects) {
return Arrays.toString(objects);
}
static String webSocketSpecViolation(String section, String detail) {
return "RFC 6455 " + section + " " + detail;
}
}

134
jdk/src/java.httpclient/share/classes/java/net/http/WSWriter.java Normal file
View File

@ -0,0 +1,134 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.util.function.Consumer;
import static java.util.Objects.requireNonNull;
/*
* Writes ByteBuffer[] to the channel in a non-blocking, asynchronous fashion.
*
* A client attempts to write data by calling
*
* boolean tryWriteFully(ByteBuffer[] buffers)
*
* If the attempt was successful and all the data has been written, then the
* method returns `true`.
*
* If the data has been written partially, then the method returns `false`, and
* the writer (this object) attempts to complete the write asynchronously by
* calling, possibly more than once
*
* boolean tryCompleteWrite()
*
* in its own threads.
*
* When the write has been completed asynchronously, the callback is signalled
* with `null`.
*
* If an error occurs in any of these stages it will NOT be thrown from the
* method. Instead `false` will be returned and the exception will be signalled
* to the callback. This is done in order to handle all exceptions in a single
* place.
*/
final class WSWriter {
private final RawChannel channel;
private final RawChannel.NonBlockingEvent writeReadinessHandler;
private final Consumer<Throwable> completionCallback;
private ByteBuffer[] buffers;
private int offset;
WSWriter(RawChannel channel, Consumer<Throwable> completionCallback) {
this.channel = channel;
this.completionCallback = completionCallback;
this.writeReadinessHandler = createHandler();
}
boolean tryWriteFully(ByteBuffer[] buffers) {
synchronized (this) {
this.buffers = requireNonNull(buffers);
this.offset = 0;
}
return tryCompleteWrite();
}
private final boolean tryCompleteWrite() {
try {
return writeNow();
} catch (IOException e) {
completionCallback.accept(e);
return false;
}
}
private boolean writeNow() throws IOException {
synchronized (this) {
for (; offset != -1; offset = nextUnwrittenIndex(buffers, offset)) {
long bytesWritten = channel.write(buffers, offset, buffers.length - offset);
if (bytesWritten == 0) {
channel.registerEvent(writeReadinessHandler);
return false;
}
}
return true;
}
}
private static int nextUnwrittenIndex(ByteBuffer[] buffers, int offset) {
for (int i = offset; i < buffers.length; i++) {
if (buffers[i].hasRemaining()) {
return i;
}
}
return -1;
}
private RawChannel.NonBlockingEvent createHandler() {
return new RawChannel.NonBlockingEvent() {
@Override
public int interestOps() {
return SelectionKey.OP_WRITE;
}
@Override
public void handle() {
if (tryCompleteWrite()) {
completionCallback.accept(null);
}
}
@Override
public String toString() {
return "Write readiness event [" + channel + "]";
}
};
}
}

1288
jdk/src/java.httpclient/share/classes/java/net/http/WebSocket.java Normal file
View File

File diff suppressed because it is too large Load Diff

66
jdk/src/java.httpclient/share/classes/java/net/http/WebSocketHandshakeException.java Normal file
View File

@ -0,0 +1,66 @@
/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net.http;
/**
* An exception used to signal the opening handshake failed.
*
* @since 9
*/
public final class WebSocketHandshakeException extends Exception {
private static final long serialVersionUID = 1L;
private final transient HttpResponse response;
WebSocketHandshakeException(HttpResponse response) {
this(null, response);
}
WebSocketHandshakeException(String message, HttpResponse response) {
super(statusCodeOrFullMessage(message, response));
this.response = response;
}
/**
* // FIXME: terrible toString (+ not always status should be displayed I guess)
*/
private static String statusCodeOrFullMessage(String m, HttpResponse response) {
return (m == null || m.isEmpty())
? String.valueOf(response.statusCode())
: response.statusCode() + ": " + m;
}
/**
* Returns a HTTP response from the server.
*
* <p> The value may be unavailable ({@code null}) if this exception has
* been serialized and then read back in.
*
* @return server response
*/
public HttpResponse getResponse() {
return response;
}
}

Some files were not shown because too many files have changed in this diff Show More