* This method applies an arbitrary scale factor to each of the three RGB
* components of this Color to create a brighter version
- * of this Color. Although brighter and
+ * of this Color.
+ * The {@code alpha} value is preserved.
+ * Although brighter and
* darker are inverse operations, the results of a
* series of invocations of these two methods might be inconsistent
* because of rounding errors.
* @return a new Color object that is
- * a brighter version of this Color.
+ * a brighter version of this Color
+ * with the same {@code alpha} value.
* @see java.awt.Color#darker
* @since JDK1.0
*/
@@ -624,6 +627,7 @@ public class Color implements Paint, java.io.Serializable {
int r = getRed();
int g = getGreen();
int b = getBlue();
+ int alpha = getAlpha();
/* From 2D group:
* 1. black.brighter() should return grey
@@ -632,7 +636,7 @@ public class Color implements Paint, java.io.Serializable {
*/
int i = (int)(1.0/(1.0-FACTOR));
if ( r == 0 && g == 0 && b == 0) {
- return new Color(i, i, i);
+ return new Color(i, i, i, alpha);
}
if ( r > 0 && r < i ) r = i;
if ( g > 0 && g < i ) g = i;
@@ -640,7 +644,8 @@ public class Color implements Paint, java.io.Serializable {
return new Color(Math.min((int)(r/FACTOR), 255),
Math.min((int)(g/FACTOR), 255),
- Math.min((int)(b/FACTOR), 255));
+ Math.min((int)(b/FACTOR), 255),
+ alpha);
}
/**
@@ -649,19 +654,23 @@ public class Color implements Paint, java.io.Serializable {
*
* This method applies an arbitrary scale factor to each of the three RGB
* components of this Color to create a darker version of
- * this Color. Although brighter and
+ * this Color.
+ * The {@code alpha} value is preserved.
+ * Although brighter and
* darker are inverse operations, the results of a series
* of invocations of these two methods might be inconsistent because
* of rounding errors.
* @return a new Color object that is
- * a darker version of this Color.
+ * a darker version of this Color
+ * with the same {@code alpha} value.
* @see java.awt.Color#brighter
* @since JDK1.0
*/
public Color darker() {
return new Color(Math.max((int)(getRed() *FACTOR), 0),
Math.max((int)(getGreen()*FACTOR), 0),
- Math.max((int)(getBlue() *FACTOR), 0));
+ Math.max((int)(getBlue() *FACTOR), 0),
+ getAlpha());
}
/**
diff --git a/src/share/classes/java/awt/Container.java b/src/share/classes/java/awt/Container.java
index a7ee77e16cbf5a711e34256fade7a0d46796b97e..8a463b005e4a6ec1f44f18e4d659a29a66acec37 100644
--- a/src/share/classes/java/awt/Container.java
+++ b/src/share/classes/java/awt/Container.java
@@ -51,6 +51,7 @@ import javax.accessibility.*;
import sun.util.logging.PlatformLogger;
import sun.awt.AppContext;
+import sun.awt.AWTAccessor;
import sun.awt.CausedFocusEvent;
import sun.awt.PeerEvent;
import sun.awt.SunToolkit;
@@ -247,6 +248,13 @@ public class Container extends Component {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
+
+ AWTAccessor.setContainerAccessor(new AWTAccessor.ContainerAccessor() {
+ @Override
+ public void validateUnconditionally(Container cont) {
+ cont.validateUnconditionally();
+ }
+ });
}
/**
diff --git a/src/share/classes/java/awt/Dialog.java b/src/share/classes/java/awt/Dialog.java
index b408148b1cb8b410533ad70047122443c71ebd36..c3a87bda6ad063e00c8fde6b37eb642c03fd052d 100644
--- a/src/share/classes/java/awt/Dialog.java
+++ b/src/share/classes/java/awt/Dialog.java
@@ -1248,14 +1248,31 @@ public class Dialog extends Window {
/**
* Disables or enables decorations for this dialog.
- * This method can only be called while the dialog is not displayable.
- * @param undecorated true if no dialog decorations are
- * to be enabled;
- * false if dialog decorations are to be enabled.
- * @throws IllegalComponentStateException if the dialog
- * is displayable.
+ *
+ * This method can only be called while the dialog is not displayable. To
+ * make this dialog decorated, it must be opaque and have the default shape,
+ * otherwise the {@code IllegalComponentStateException} will be thrown.
+ * Refer to {@link Window#setShape}, {@link Window#setOpacity} and {@link
+ * Window#setBackground} for details
+ *
+ * @param undecorated {@code true} if no dialog decorations are to be
+ * enabled; {@code false} if dialog decorations are to be enabled
+ *
+ * @throws IllegalComponentStateException if the dialog is displayable
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and this dialog does not have the default shape
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and this dialog opacity is less than {@code 1.0f}
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and the alpha value of this dialog background
+ * color is less than {@code 1.0f}
+ *
* @see #isUndecorated
* @see Component#isDisplayable
+ * @see Window#getShape
+ * @see Window#getOpacity
+ * @see Window#getBackground
+ *
* @since 1.4
*/
public void setUndecorated(boolean undecorated) {
@@ -1264,6 +1281,18 @@ public class Dialog extends Window {
if (isDisplayable()) {
throw new IllegalComponentStateException("The dialog is displayable.");
}
+ if (!undecorated) {
+ if (getOpacity() < 1.0f) {
+ throw new IllegalComponentStateException("The dialog is not opaque");
+ }
+ if (getShape() != null) {
+ throw new IllegalComponentStateException("The dialog does not have a default shape");
+ }
+ Color bg = getBackground();
+ if ((bg != null) && (bg.getAlpha() < 255)) {
+ throw new IllegalComponentStateException("The dialog background color is not opaque");
+ }
+ }
this.undecorated = undecorated;
}
}
@@ -1280,6 +1309,45 @@ public class Dialog extends Window {
return undecorated;
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setOpacity(float opacity) {
+ synchronized (getTreeLock()) {
+ if ((opacity < 1.0f) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The dialog is decorated");
+ }
+ super.setOpacity(opacity);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setShape(Shape shape) {
+ synchronized (getTreeLock()) {
+ if ((shape != null) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The dialog is decorated");
+ }
+ super.setShape(shape);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setBackground(Color bgColor) {
+ synchronized (getTreeLock()) {
+ if ((bgColor != null) && (bgColor.getAlpha() < 255) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The dialog is decorated");
+ }
+ super.setBackground(bgColor);
+ }
+ }
+
/**
* Returns a string representing the state of this dialog. This
* method is intended to be used only for debugging purposes, and the
diff --git a/src/share/classes/java/awt/FileDialog.java b/src/share/classes/java/awt/FileDialog.java
index 033b7660d0edbf36ab1af970cfc13437db93f755..5e35bfe2ea90d3d0a16257b07b5d9763157d4192 100644
--- a/src/share/classes/java/awt/FileDialog.java
+++ b/src/share/classes/java/awt/FileDialog.java
@@ -99,7 +99,7 @@ public class FileDialog extends Dialog {
* Contains the File instances for all the files that the user selects.
*
* @serial
- * @see getFiles
+ * @see #getFiles
* @since 1.7
*/
private File[] files;
diff --git a/src/share/classes/java/awt/Frame.java b/src/share/classes/java/awt/Frame.java
index f69e02f5239aa9453736c422528ba940d444fede..bd2539f055bd7a12ac8f28e589e2506d32929ea4 100644
--- a/src/share/classes/java/awt/Frame.java
+++ b/src/share/classes/java/awt/Frame.java
@@ -828,6 +828,11 @@ public class Frame extends Window implements MenuContainer {
return frame.state;
}
}
+ public Rectangle getMaximizedBounds(Frame frame) {
+ synchronized(frame.getObjectLock()) {
+ return frame.maximizedBounds;
+ }
+ }
}
);
}
@@ -855,8 +860,10 @@ public class Frame extends Window implements MenuContainer {
* @see #getMaximizedBounds()
* @since 1.4
*/
- public synchronized void setMaximizedBounds(Rectangle bounds) {
- this.maximizedBounds = bounds;
+ public void setMaximizedBounds(Rectangle bounds) {
+ synchronized(getObjectLock()) {
+ this.maximizedBounds = bounds;
+ }
FramePeer peer = (FramePeer)this.peer;
if (peer != null) {
peer.setMaximizedBounds(bounds);
@@ -873,21 +880,40 @@ public class Frame extends Window implements MenuContainer {
* @since 1.4
*/
public Rectangle getMaximizedBounds() {
- return maximizedBounds;
+ synchronized(getObjectLock()) {
+ return maximizedBounds;
+ }
}
/**
* Disables or enables decorations for this frame.
- * This method can only be called while the frame is not displayable.
- * @param undecorated true if no frame decorations are
- * to be enabled;
- * false if frame decorations are to be enabled.
- * @throws IllegalComponentStateException if the frame
- * is displayable.
+ *
+ * This method can only be called while the frame is not displayable. To
+ * make this frame decorated, it must be opaque and have the default shape,
+ * otherwise the {@code IllegalComponentStateException} will be thrown.
+ * Refer to {@link Window#setShape}, {@link Window#setOpacity} and {@link
+ * Window#setBackground} for details
+ *
+ * @param undecorated {@code true} if no frame decorations are to be
+ * enabled; {@code false} if frame decorations are to be enabled
+ *
+ * @throws IllegalComponentStateException if the frame is displayable
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and this frame does not have the default shape
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and this frame opacity is less than {@code 1.0f}
+ * @throws IllegalComponentStateException if {@code undecorated} is
+ * {@code false}, and the alpha value of this frame background
+ * color is less than {@code 1.0f}
+ *
* @see #isUndecorated
* @see Component#isDisplayable
+ * @see Window#getShape
+ * @see Window#getOpacity
+ * @see Window#getBackground
* @see javax.swing.JFrame#setDefaultLookAndFeelDecorated(boolean)
+ *
* @since 1.4
*/
public void setUndecorated(boolean undecorated) {
@@ -896,6 +922,18 @@ public class Frame extends Window implements MenuContainer {
if (isDisplayable()) {
throw new IllegalComponentStateException("The frame is displayable.");
}
+ if (!undecorated) {
+ if (getOpacity() < 1.0f) {
+ throw new IllegalComponentStateException("The frame is not opaque");
+ }
+ if (getShape() != null) {
+ throw new IllegalComponentStateException("The frame does not have a default shape");
+ }
+ Color bg = getBackground();
+ if ((bg != null) && (bg.getAlpha() < 255)) {
+ throw new IllegalComponentStateException("The frame background color is not opaque");
+ }
+ }
this.undecorated = undecorated;
}
}
@@ -912,6 +950,45 @@ public class Frame extends Window implements MenuContainer {
return undecorated;
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setOpacity(float opacity) {
+ synchronized (getTreeLock()) {
+ if ((opacity < 1.0f) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The frame is decorated");
+ }
+ super.setOpacity(opacity);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setShape(Shape shape) {
+ synchronized (getTreeLock()) {
+ if ((shape != null) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The frame is decorated");
+ }
+ super.setShape(shape);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setBackground(Color bgColor) {
+ synchronized (getTreeLock()) {
+ if ((bgColor != null) && (bgColor.getAlpha() < 255) && !isUndecorated()) {
+ throw new IllegalComponentStateException("The frame is decorated");
+ }
+ super.setBackground(bgColor);
+ }
+ }
+
/**
* Removes the specified menu bar from this frame.
* @param m the menu component to remove.
diff --git a/src/share/classes/java/awt/Window.java b/src/share/classes/java/awt/Window.java
index 03dbd535e9f0d5f146c83ba2ad6247399096e1e6..064c8494f4e969479a92cf648b04ae7975af58db 100644
--- a/src/share/classes/java/awt/Window.java
+++ b/src/share/classes/java/awt/Window.java
@@ -3474,14 +3474,20 @@ public class Window extends Container implements Accessible {
* level of 0 may or may not disable the mouse event handling on this
* window. This is a platform-dependent behavior.
*
- * In order for this method to enable the translucency effect, the {@link
- * GraphicsDevice#isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency)} method must indicate that
- * the {@link GraphicsDevice.WindowTranslucency#TRANSLUCENT TRANSLUCENT}
- * translucency is supported.
+ * The following conditions must be met in order to set the opacity value
+ * less than {@code 1.0f}:
+ *
- * Also note that the window must not be in the full-screen mode when
- * setting the opacity value < 1.0f. Otherwise the {@code
- * IllegalComponentStateException} is thrown.
+ * If the requested opacity value is less than {@code 1.0f}, and any of the
+ * above conditions are not met, the window opacity will not change,
+ * and the {@code IllegalComponentStateException} will be thrown.
*
* The translucency levels of individual pixels may also be effected by the
* alpha component of their color (see {@link Window#setBackground(Color)}) and the
@@ -3491,15 +3497,20 @@ public class Window extends Container implements Accessible {
*
* @throws IllegalArgumentException if the opacity is out of the range
* [0..1]
+ * @throws IllegalComponentStateException if the window is decorated and
+ * the opacity is less than {@code 1.0f}
* @throws IllegalComponentStateException if the window is in full screen
- * mode, and the opacity is less than 1.0f
+ * mode, and the opacity is less than {@code 1.0f}
* @throws UnsupportedOperationException if the {@code
* GraphicsDevice.WindowTranslucency#TRANSLUCENT TRANSLUCENT}
- * translucency kind is not supported and the opacity is less than 1.0f
+ * translucency is not supported and the opacity is less than
+ * {@code 1.0f}
*
* @see Window#getOpacity
* @see Window#setBackground(Color)
* @see Window#setShape(Shape)
+ * @see Frame#isUndecorated
+ * @see Dialog#isUndecorated
* @see GraphicsDevice.WindowTranslucency
* @see GraphicsDevice#isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency)
*
@@ -3557,24 +3568,26 @@ public class Window extends Container implements Accessible {
/**
* Sets the shape of the window.
*
- * Setting a shape enables cutting off some parts of the window, leaving
- * visible and clickable only those parts belonging to the given shape
- * (see {@link Shape}). If the shape argument is null, this methods
- * restores the default shape (making the window rectangular on most
- * platforms.)
+ * Setting a shape cuts off some parts of the window. Only the parts that
+ * belong to the given {@link Shape} remain visible and clickable. If
+ * the shape argument is {@code null}, this method restores the default
+ * shape, making the window rectangular on most platforms.
*
- * The following conditions must be met in order to set a non-null shape:
+ * The following conditions must be met to set a non-null shape:
*
+ * If the requested shape is not {@code null}, and any of the above
+ * conditions are not met, the shape of this window will not change,
+ * and either the {@code UnsupportedOperationException} or {@code
+ * IllegalComponentStateException} will be thrown.
*
* The tranlucency levels of individual pixels may also be effected by the
* alpha component of their color (see {@link Window#setBackground(Color)}) and the
@@ -3584,6 +3597,8 @@ public class Window extends Container implements Accessible {
* @param shape the shape to set to the window
*
* @throws IllegalComponentStateException if the shape is not {@code
+ * null} and the window is decorated
+ * @throws IllegalComponentStateException if the shape is not {@code
* null} and the window is in full-screen mode
* @throws UnsupportedOperationException if the shape is not {@code
* null} and {@link GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSPARENT
@@ -3592,6 +3607,8 @@ public class Window extends Container implements Accessible {
* @see Window#getShape()
* @see Window#setBackground(Color)
* @see Window#setOpacity(float)
+ * @see Frame#isUndecorated
+ * @see Dialog#isUndecorated
* @see GraphicsDevice.WindowTranslucency
* @see GraphicsDevice#isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency)
*
@@ -3645,37 +3662,46 @@ public class Window extends Container implements Accessible {
* GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT PERPIXEL_TRANSLUCENT}
* tranclucency, the alpha component of the given background color
* may effect the mode of operation for this window: it indicates whether
- * this window must be opaque (alpha == 1.0f) or per-pixel translucent
- * (alpha < 1.0f). All the following conditions must be met in order
- * to be able to enable the per-pixel transparency mode for this window:
+ * this window must be opaque (alpha equals {@code 1.0f}) or per-pixel translucent
+ * (alpha is less than {@code 1.0f}). If the given background color is
+ * {@code null}, the window is considered completely opaque.
+ *
+ * All the following conditions must be met to enable the per-pixel
+ * transparency mode for this window:
*
+ * If the alpha component of the requested background color is less than
+ * {@code 1.0f}, and any of the above conditions are not met, the background
+ * color of this window will not change, the alpha component of the given
+ * background color will not affect the mode of operation for this window,
+ * and either the {@code UnsupportedOperationException} or {@code
+ * IllegalComponentStateException} will be thrown.
*
* When the window is per-pixel translucent, the drawing sub-system
* respects the alpha value of each individual pixel. If a pixel gets
* painted with the alpha color component equal to zero, it becomes
- * visually transparent, if the alpha of the pixel is equal to 1.0f, the
+ * visually transparent. If the alpha of the pixel is equal to 1.0f, the
* pixel is fully opaque. Interim values of the alpha color component make
- * the pixel semi-transparent. In this mode the background of the window
- * gets painted with the alpha value of the given background color (meaning
- * that it is not painted at all if the alpha value of the argument of this
- * method is equal to zero.)
+ * the pixel semi-transparent. In this mode, the background of the window
+ * gets painted with the alpha value of the given background color. If the
+ * alpha value of the argument of this method is equal to {@code 0}, the
+ * background is not painted at all.
*
* The actual level of translucency of a given pixel also depends on window
* opacity (see {@link #setOpacity(float)}), as well as the current shape of
* this window (see {@link #setShape(Shape)}).
*
- * Note that painting a pixel with the alpha value of 0 may or may not
- * disable the mouse event handling on this pixel. This is a
- * platform-dependent behavior. To make sure the mouse clicks do not get
+ * Note that painting a pixel with the alpha value of {@code 0} may or may
+ * not disable the mouse event handling on this pixel. This is a
+ * platform-dependent behavior. To make sure the mouse events do not get
* dispatched to a particular pixel, the pixel must be excluded from the
* shape of the window.
*
@@ -3685,17 +3711,21 @@ public class Window extends Container implements Accessible {
* @param bgColor the color to become this window's background color.
*
* @throws IllegalComponentStateException if the alpha value of the given
- * background color is less than 1.0f and the window is in
+ * background color is less than {@code 1.0f} and the window is decorated
+ * @throws IllegalComponentStateException if the alpha value of the given
+ * background color is less than {@code 1.0f} and the window is in
* full-screen mode
* @throws UnsupportedOperationException if the alpha value of the given
- * background color is less than 1.0f and
- * {@link GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT
+ * background color is less than {@code 1.0f} and {@link
+ * GraphicsDevice.WindowTranslucency#PERPIXEL_TRANSLUCENT
* PERPIXEL_TRANSLUCENT} translucency is not supported
*
* @see Window#getBackground
* @see Window#isOpaque
* @see Window#setOpacity(float)
* @see Window#setShape(Shape)
+ * @see Frame#isUndecorated
+ * @see Dialog#isUndecorated
* @see GraphicsDevice.WindowTranslucency
* @see GraphicsDevice#isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency)
* @see GraphicsConfiguration#isTranslucencyCapable()
@@ -3739,7 +3769,7 @@ public class Window extends Container implements Accessible {
*
* The method returns {@code false} if the background color of the window
* is not {@code null} and the alpha component of the color is less than
- * 1.0f. The method returns {@code true} otherwise.
+ * {@code 1.0f}. The method returns {@code true} otherwise.
*
* @return {@code true} if the window is opaque, {@code false} otherwise
*
diff --git a/src/share/classes/java/io/BufferedInputStream.java b/src/share/classes/java/io/BufferedInputStream.java
index d61f74bcbd38189f986c50ed28c38af2049c6106..73885f318d9b69a6c8b78a01cfde31adfcca3b12 100644
--- a/src/share/classes/java/io/BufferedInputStream.java
+++ b/src/share/classes/java/io/BufferedInputStream.java
@@ -395,7 +395,11 @@ class BufferedInputStream extends FilterInputStream {
* or an I/O error occurs.
*/
public synchronized int available() throws IOException {
- return getInIfOpen().available() + (count - pos);
+ int n = count - pos;
+ int avail = getInIfOpen().available();
+ return n > (Integer.MAX_VALUE - avail)
+ ? Integer.MAX_VALUE
+ : n + avail;
}
/**
diff --git a/src/share/classes/java/io/PushbackInputStream.java b/src/share/classes/java/io/PushbackInputStream.java
index 1984247e57573c4179c80106d6e3c2abb886db3d..0a8e0c9cf64acfb7873792674969d8a60ec0d576 100644
--- a/src/share/classes/java/io/PushbackInputStream.java
+++ b/src/share/classes/java/io/PushbackInputStream.java
@@ -273,7 +273,11 @@ class PushbackInputStream extends FilterInputStream {
*/
public int available() throws IOException {
ensureOpen();
- return (buf.length - pos) + super.available();
+ int n = buf.length - pos;
+ int avail = super.available();
+ return n > (Integer.MAX_VALUE - avail)
+ ? Integer.MAX_VALUE
+ : n + avail;
}
/**
diff --git a/src/share/classes/java/lang/Readable.java b/src/share/classes/java/lang/Readable.java
index c97d792cca8c7b65376829bbb4221a60c5b58a97..51279ef27ec186dcdaabc5bfd0d6afb927dee94b 100644
--- a/src/share/classes/java/lang/Readable.java
+++ b/src/share/classes/java/lang/Readable.java
@@ -44,11 +44,11 @@ public interface Readable {
* rewinding of the buffer is performed.
*
* @param cb the buffer to read characters into
- * @return @return The number of char values added to the buffer,
+ * @return The number of {@code char} values added to the buffer,
* or -1 if this source of characters is at its end
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cb is null
- * @throws ReadOnlyBufferException if cb is a read only buffer
+ * @throws java.nio.ReadOnlyBufferException if cb is a read only buffer
*/
public int read(java.nio.CharBuffer cb) throws IOException;
diff --git a/src/share/classes/java/nio/StringCharBuffer.java b/src/share/classes/java/nio/StringCharBuffer.java
index b5df238573c1a09509b7092434d56a42668cb30e..52d7a2087a500371e2b54e63976d8b92064ff4e3 100644
--- a/src/share/classes/java/nio/StringCharBuffer.java
+++ b/src/share/classes/java/nio/StringCharBuffer.java
@@ -47,7 +47,7 @@ class StringCharBuffer // package-private
0,
this.remaining(),
this.remaining(),
- this.position());
+ offset + this.position());
}
private StringCharBuffer(CharSequence s,
diff --git a/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java b/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java
index d37bd2efc463d7750a37dd4ddb14c972e55802ca..6d04f4f52a2a74309bb8eeb4d88435f566c30772 100644
--- a/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java
+++ b/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java
@@ -110,7 +110,8 @@ import java.nio.ByteBuffer;
* state of the {@link ByteBuffer}, or the sequence of buffers, for the I/O
* operation is not defined. Buffers should be discarded or at least care must
* be taken to ensure that the buffers are not accessed while the channel remains
- * open.
+ * open. All methods that accept timeout parameters treat values less than or
+ * equal to zero to mean that the I/O operation does not timeout.
*
* @since 1.7
*/
@@ -367,7 +368,7 @@ public abstract class AsynchronousSocketChannel
* @param dst
* The buffer into which bytes are to be transferred
* @param timeout
- * The timeout, or {@code 0L} for no timeout
+ * The maximum time for the I/O operation to complete
* @param unit
* The time unit of the {@code timeout} argument
* @param attachment
@@ -376,8 +377,7 @@ public abstract class AsynchronousSocketChannel
* The handler for consuming the result
*
* @throws IllegalArgumentException
- * If the {@code timeout} parameter is negative or the buffer is
- * read-only
+ * If the buffer is read-only
* @throws ReadPendingException
* If a read operation is already in progress on this channel
* @throws NotYetConnectedException
@@ -471,7 +471,7 @@ public abstract class AsynchronousSocketChannel
* The maximum number of buffers to be accessed; must be non-negative
* and no larger than {@code dsts.length - offset}
* @param timeout
- * The timeout, or {@code 0L} for no timeout
+ * The maximum time for the I/O operation to complete
* @param unit
* The time unit of the {@code timeout} argument
* @param attachment
@@ -483,8 +483,7 @@ public abstract class AsynchronousSocketChannel
* If the pre-conditions for the {@code offset} and {@code length}
* parameter aren't met
* @throws IllegalArgumentException
- * If the {@code timeout} parameter is negative, or a buffer is
- * read-only
+ * If the buffer is read-only
* @throws ReadPendingException
* If a read operation is already in progress on this channel
* @throws NotYetConnectedException
@@ -524,7 +523,7 @@ public abstract class AsynchronousSocketChannel
* @param src
* The buffer from which bytes are to be retrieved
* @param timeout
- * The timeout, or {@code 0L} for no timeout
+ * The maximum time for the I/O operation to complete
* @param unit
* The time unit of the {@code timeout} argument
* @param attachment
@@ -532,8 +531,6 @@ public abstract class AsynchronousSocketChannel
* @param handler
* The handler for consuming the result
*
- * @throws IllegalArgumentException
- * If the {@code timeout} parameter is negative
* @throws WritePendingException
* If a write operation is already in progress on this channel
* @throws NotYetConnectedException
@@ -623,7 +620,7 @@ public abstract class AsynchronousSocketChannel
* The maximum number of buffers to be accessed; must be non-negative
* and no larger than {@code srcs.length - offset}
* @param timeout
- * The timeout, or {@code 0L} for no timeout
+ * The maximum time for the I/O operation to complete
* @param unit
* The time unit of the {@code timeout} argument
* @param attachment
@@ -634,8 +631,6 @@ public abstract class AsynchronousSocketChannel
* @throws IndexOutOfBoundsException
* If the pre-conditions for the {@code offset} and {@code length}
* parameter aren't met
- * @throws IllegalArgumentException
- * If the {@code timeout} parameter is negative
* @throws WritePendingException
* If a write operation is already in progress on this channel
* @throws NotYetConnectedException
diff --git a/src/share/classes/java/sql/SQLPermission.java b/src/share/classes/java/sql/SQLPermission.java
index e7e799c1caca038fb4defc9d04046693f00f705d..9f45718853d020c53690e4b3fe7a4552c680671f 100644
--- a/src/share/classes/java/sql/SQLPermission.java
+++ b/src/share/classes/java/sql/SQLPermission.java
@@ -84,7 +84,7 @@ import java.security.*;
* {@code setJNDIContext} and {@code setLogger}
*
| {@code 'Z'}
+ * | '\u005a'
* | A string representing the abbreviation for the time zone. This
* value will be adjusted as necessary for Daylight Saving Time. For
* {@code long}, {@link Long}, and {@link Date} the time zone used is
diff --git a/src/share/classes/javax/security/auth/Policy.java b/src/share/classes/javax/security/auth/Policy.java
index 6c508b2ce95eb5cd68ae57ee9e21c0250893796d..88264b3fc49e9d1f17b5f8bd7f9c43a901ca9d7c 100644
--- a/src/share/classes/javax/security/auth/Policy.java
+++ b/src/share/classes/javax/security/auth/Policy.java
@@ -25,6 +25,9 @@
package javax.security.auth;
+import java.security.Security;
+import sun.security.util.Debug;
+
/**
* This is an abstract class for representing the system policy for
* Subject-based authorization. A subclass implementation
@@ -159,6 +162,10 @@ public abstract class Policy {
private static Policy policy;
private static ClassLoader contextClassLoader;
+ // true if a custom (not com.sun.security.auth.PolicyFile) system-wide
+ // policy object is set
+ private static boolean isCustomPolicy;
+
static {
contextClassLoader = java.security.AccessController.doPrivileged
(new java.security.PrivilegedAction() {
@@ -234,6 +241,8 @@ public abstract class Policy {
contextClassLoader).newInstance();
}
});
+ isCustomPolicy =
+ !finalClass.equals("com.sun.security.auth.PolicyFile");
} catch (Exception e) {
throw new SecurityException
(sun.security.util.ResourcesMgr.getString
@@ -265,6 +274,46 @@ public abstract class Policy {
java.lang.SecurityManager sm = System.getSecurityManager();
if (sm != null) sm.checkPermission(new AuthPermission("setPolicy"));
Policy.policy = policy;
+ // all non-null policy objects are assumed to be custom
+ isCustomPolicy = policy != null ? true : false;
+ }
+
+ /**
+ * Returns true if a custom (not com.sun.security.auth.PolicyFile)
+ * system-wide policy object has been set or installed. This method is
+ * called by SubjectDomainCombiner to provide backwards compatibility for
+ * developers that provide their own javax.security.auth.Policy
+ * implementations.
+ *
+ * @return true if a custom (not com.sun.security.auth.PolicyFile)
+ * system-wide policy object has been set; false otherwise
+ */
+ static boolean isCustomPolicySet(Debug debug) {
+ if (policy != null) {
+ if (debug != null && isCustomPolicy) {
+ debug.println("Providing backwards compatibility for " +
+ "javax.security.auth.policy implementation: " +
+ policy.toString());
+ }
+ return isCustomPolicy;
+ }
+ // check if custom policy has been set using auth.policy.provider prop
+ String policyClass = java.security.AccessController.doPrivileged
+ (new java.security.PrivilegedAction() {
+ public String run() {
+ return Security.getProperty("auth.policy.provider");
+ }
+ });
+ if (policyClass != null
+ && !policyClass.equals("com.sun.security.auth.PolicyFile")) {
+ if (debug != null) {
+ debug.println("Providing backwards compatibility for " +
+ "javax.security.auth.policy implementation: " +
+ policyClass);
+ }
+ return true;
+ }
+ return false;
}
/**
diff --git a/src/share/classes/javax/security/auth/SubjectDomainCombiner.java b/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
index 00d57f6c6daa59684d91a6a69842995cd2f72bcd..9dc82fc0153a37f72c6114847a4ecec21e569f68 100644
--- a/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
+++ b/src/share/classes/javax/security/auth/SubjectDomainCombiner.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2010, 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
@@ -26,8 +26,6 @@
package javax.security.auth;
import java.security.AccessController;
-import java.security.AccessControlContext;
-import java.security.AllPermission;
import java.security.Permission;
import java.security.Permissions;
import java.security.PermissionCollection;
@@ -35,10 +33,8 @@ import java.security.Policy;
import java.security.Principal;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
-import java.lang.ClassLoader;
import java.security.Security;
import java.util.Set;
-import java.util.Iterator;
import java.util.WeakHashMap;
import java.lang.ref.WeakReference;
@@ -61,7 +57,8 @@ public class SubjectDomainCombiner implements java.security.DomainCombiner {
"\t[SubjectDomainCombiner]");
// Note: check only at classloading time, not dynamically during combine()
- private static final boolean useJavaxPolicy = compatPolicy();
+ private static final boolean useJavaxPolicy =
+ javax.security.auth.Policy.isCustomPolicySet(debug);
// Relevant only when useJavaxPolicy is true
private static final boolean allowCaching =
@@ -202,8 +199,8 @@ public class SubjectDomainCombiner implements java.security.DomainCombiner {
return null;
}
- // maintain backwards compatibility for people who provide
- // their own javax.security.auth.Policy implementations
+ // maintain backwards compatibility for developers who provide
+ // their own custom javax.security.auth.Policy implementations
if (useJavaxPolicy) {
return combineJavaxPolicy(currentDomains, assignedDomains);
}
@@ -476,8 +473,7 @@ public class SubjectDomainCombiner implements java.security.DomainCombiner {
String s = AccessController.doPrivileged
(new PrivilegedAction() {
public String run() {
- return java.security.Security.getProperty
- ("cache.auth.policy");
+ return Security.getProperty("cache.auth.policy");
}
});
if (s != null) {
@@ -488,29 +484,6 @@ public class SubjectDomainCombiner implements java.security.DomainCombiner {
return true;
}
- // maintain backwards compatibility for people who provide
- // their own javax.security.auth.Policy implementations
- private static boolean compatPolicy() {
- javax.security.auth.Policy javaxPolicy = AccessController.doPrivileged
- (new PrivilegedAction() {
- public javax.security.auth.Policy run() {
- return javax.security.auth.Policy.getPolicy();
- }
- });
-
- if (!(javaxPolicy instanceof com.sun.security.auth.PolicyFile)) {
- if (debug != null) {
- debug.println("Providing backwards compatibility for " +
- "javax.security.auth.policy implementation: " +
- javaxPolicy.toString());
- }
-
- return true;
- } else {
- return false;
- }
- }
-
private static void printInputDomains(ProtectionDomain[] currentDomains,
ProtectionDomain[] assignedDomains) {
if (currentDomains == null || currentDomains.length == 0) {
diff --git a/src/share/classes/sun/awt/AWTAccessor.java b/src/share/classes/sun/awt/AWTAccessor.java
index b9171ce9798eb7c133ec15175c70a5c520d1543b..abef250993d334d6b9cfb9cc6e4b7bd7a0e919e5 100644
--- a/src/share/classes/sun/awt/AWTAccessor.java
+++ b/src/share/classes/sun/awt/AWTAccessor.java
@@ -223,6 +223,16 @@ public final class AWTAccessor {
void processEvent(Component comp, AWTEvent e);
}
+ /*
+ * An interface of accessor for the java.awt.Container class.
+ */
+ public interface ContainerAccessor {
+ /**
+ * Validates the container unconditionally.
+ */
+ void validateUnconditionally(Container cont);
+ }
+
/*
* An interface of accessor for java.awt.Window class.
*/
@@ -334,6 +344,10 @@ public final class AWTAccessor {
* Gets the state of this frame.
*/
int getExtendedState(Frame frame);
+ /*
+ * Gets the maximized bounds of this frame.
+ */
+ Rectangle getMaximizedBounds(Frame frame);
}
/*
@@ -440,53 +454,19 @@ public final class AWTAccessor {
}
/*
- * The java.awt.Component class accessor object.
+ * Accessor instances are initialized in the static initializers of
+ * corresponding AWT classes by using setters defined below.
*/
private static ComponentAccessor componentAccessor;
-
- /*
- * The java.awt.Window class accessor object.
- */
+ private static ContainerAccessor containerAccessor;
private static WindowAccessor windowAccessor;
-
- /*
- * The java.awt.AWTEvent class accessor object.
- */
private static AWTEventAccessor awtEventAccessor;
-
- /*
- * The java.awt.event.InputEvent class accessor object.
- */
private static InputEventAccessor inputEventAccessor;
-
- /*
- * The java.awt.Frame class accessor object.
- */
private static FrameAccessor frameAccessor;
-
- /*
- * The java.awt.KeyboardFocusManager class accessor object.
- */
private static KeyboardFocusManagerAccessor kfmAccessor;
-
- /*
- * The java.awt.MenuComponent class accessor object.
- */
private static MenuComponentAccessor menuComponentAccessor;
-
- /*
- * The java.awt.EventQueue class accessor object.
- */
private static EventQueueAccessor eventQueueAccessor;
-
- /*
- * The java.awt.PopupMenu class accessor object.
- */
private static PopupMenuAccessor popupMenuAccessor;
-
- /*
- * The java.awt.FileDialog class accessor object.
- */
private static FileDialogAccessor fileDialogAccessor;
/*
@@ -497,7 +477,7 @@ public final class AWTAccessor {
}
/*
- * Retrieve the accessor object for the java.awt.Window class.
+ * Retrieve the accessor object for the java.awt.Component class.
*/
public static ComponentAccessor getComponentAccessor() {
if (componentAccessor == null) {
@@ -507,6 +487,24 @@ public final class AWTAccessor {
return componentAccessor;
}
+ /*
+ * Set an accessor object for the java.awt.Container class.
+ */
+ public static void setContainerAccessor(ContainerAccessor ca) {
+ containerAccessor = ca;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Container class.
+ */
+ public static ContainerAccessor getContainerAccessor() {
+ if (containerAccessor == null) {
+ unsafe.ensureClassInitialized(Container.class);
+ }
+
+ return containerAccessor;
+ }
+
/*
* Set an accessor object for the java.awt.Window class.
*/
diff --git a/src/share/classes/sun/io/ByteToCharCp833.java b/src/share/classes/sun/io/ByteToCharCp833.java
new file mode 100644
index 0000000000000000000000000000000000000000..a83a893d137405ccadb7c94e63b6874e9d76e3f8
--- /dev/null
+++ b/src/share/classes/sun/io/ByteToCharCp833.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2010 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.io;
+
+import sun.nio.cs.ext.IBM833;
+
+public class ByteToCharCp833 extends ByteToCharSingleByte {
+
+ private final static IBM833 nioCoder = new IBM833();
+
+ public String getCharacterEncoding() {
+ return "Cp833";
+ }
+
+ public ByteToCharCp833() {
+ super.byteToCharTable = nioCoder.getDecoderSingleByteMappings();
+ }
+}
+
diff --git a/src/share/classes/sun/io/CharToByteCp833.java b/src/share/classes/sun/io/CharToByteCp833.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d531406c17889362b40b7e97309b9839c52e940
--- /dev/null
+++ b/src/share/classes/sun/io/CharToByteCp833.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2010 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.io;
+
+import sun.nio.cs.ext.IBM833;
+
+public class CharToByteCp833 extends CharToByteSingleByte {
+
+ private final static IBM833 nioCoder = new IBM833();
+
+ public String getCharacterEncoding() {
+ return "Cp833";
+ }
+
+ public CharToByteCp833() {
+ super.mask1 = 0xFF00;
+ super.mask2 = 0x00FF;
+ super.shift = 8;
+ super.index1 = nioCoder.getEncoderIndex1();
+ super.index2 = nioCoder.getEncoderIndex2();
+ }
+}
+
diff --git a/src/share/classes/sun/io/CharacterEncoding.java b/src/share/classes/sun/io/CharacterEncoding.java
index 94ce7040f5dc694498b7ec6b48b543c8b1e8ab57..f577a9bc79bc31dfe1b01e2d93084b0b7f3f48a3 100644
--- a/src/share/classes/sun/io/CharacterEncoding.java
+++ b/src/share/classes/sun/io/CharacterEncoding.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2010, 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
@@ -406,6 +406,11 @@ public class CharacterEncoding {
aliasTable.put("cp775", "Cp775");
aliasTable.put("775", "Cp775");
+ aliasTable.put("ibm833", "Cp833");
+ aliasTable.put("ibm-833", "Cp833");
+ aliasTable.put("cp833", "Cp833");
+ aliasTable.put("833", "Cp833");
+
aliasTable.put("ibm834", "Cp834");
aliasTable.put("ibm-834", "Cp834");
aliasTable.put("cp834", "Cp834");
diff --git a/src/share/classes/sun/launcher/LauncherHelper.java b/src/share/classes/sun/launcher/LauncherHelper.java
index cba795968c69c0875894aed1da6f67ebe74ac60f..dbaebc0ee862d9a465cc4b7ae77cef0e8987425f 100644
--- a/src/share/classes/sun/launcher/LauncherHelper.java
+++ b/src/share/classes/sun/launcher/LauncherHelper.java
@@ -44,8 +44,16 @@ import java.io.IOException;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
import java.util.ResourceBundle;
import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Properties;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
@@ -59,6 +67,17 @@ public enum LauncherHelper {
private static StringBuilder outBuf = new StringBuilder();
private static ResourceBundle javarb = null;
+
+ private static final String INDENT = " ";
+ private static final String VM_SETTINGS = "VM settings:";
+ private static final String PROP_SETTINGS = "Property settings:";
+ private static final String LOCALE_SETTINGS = "Locale settings:";
+
+ private static final long K = 1024;
+ private static final long M = K * K;
+ private static final long G = M * K;
+ private static final long T = G * K;
+
private static synchronized ResourceBundle getLauncherResourceBundle() {
if (javarb == null) {
javarb = ResourceBundle.getBundle(defaultBundleName);
@@ -66,6 +85,184 @@ public enum LauncherHelper {
return javarb;
}
+ /*
+ * A method called by the launcher to print out the standard settings,
+ * by default -XshowSettings is equivalent to -XshowSettings:all,
+ * Specific information may be gotten by using suboptions with possible
+ * values vm, properties and locale.
+ *
+ * printToStderr: choose between stdout and stderr
+ *
+ * optionFlag: specifies which options to print default is all other
+ * possible values are vm, properties, locale.
+ *
+ * maxHeapSize: in bytes, as set by the launcher, a zero-value indicates
+ * this code should determine this value, using a suitable method.
+ *
+ * stackSize: in bytes, as set by the launcher, a zero-value indicates
+ * this code determine this value, using a suitable method.
+ */
+ static void showSettings(boolean printToStderr, String optionFlag,
+ long maxHeapSize, long stackSize, boolean isServer) {
+
+ PrintStream ostream = (printToStderr) ? System.err : System.out;
+ String opts[] = optionFlag.split(":");
+ String optStr = (opts.length > 1 && opts[1] != null)
+ ? opts[1].trim()
+ : "all";
+ switch (optStr) {
+ case "vm":
+ printVmSettings(ostream, maxHeapSize, stackSize, isServer);
+ break;
+ case "properties":
+ printProperties(ostream);
+ break;
+ case "locale":
+ printLocale(ostream);
+ break;
+ default:
+ printVmSettings(ostream, maxHeapSize, stackSize, isServer);
+ printProperties(ostream);
+ printLocale(ostream);
+ break;
+ }
+ }
+
+ /*
+ * prints the main vm settings subopt/section
+ */
+ private static void printVmSettings(PrintStream ostream, long maxHeapSize,
+ long stackSize, boolean isServer) {
+
+ ostream.println(VM_SETTINGS);
+ if (stackSize != 0L) {
+ ostream.println(INDENT + "Stack Size: " + scaleValue(stackSize));
+ }
+ if (maxHeapSize != 0L) {
+ ostream.println(INDENT + "Max. Heap Size: " + scaleValue(maxHeapSize));
+ } else {
+ ostream.println(INDENT + "Max. Heap Size (Estimated): "
+ + scaleValue(Runtime.getRuntime().maxMemory()));
+ }
+ ostream.println(INDENT + "Ergonomics Machine Class: "
+ + ((isServer) ? "server" : "client"));
+ ostream.println(INDENT + "Using VM: "
+ + System.getProperty("java.vm.name"));
+ ostream.println();
+ }
+
+ /*
+ * scale the incoming values to a human readable form, represented as
+ * K, M, G and T, see java.c parse_size for the scaled values and
+ * suffixes.
+ */
+
+ private static String scaleValue(double v) {
+ MathContext mc2 = new MathContext(3, RoundingMode.HALF_EVEN);
+
+ if (v >= K && v < M) {
+ return (new BigDecimal(v / K, mc2)).toPlainString() + "K";
+ } else if (v >= M && v < G) {
+ return (new BigDecimal(v / M, mc2)).toPlainString() + "M";
+ } else if (v >= G && v < T) {
+ return (new BigDecimal(v / G, mc2)).toPlainString() + "G";
+ } else if (v >= T) {
+ return (new BigDecimal(v / T, mc2)).toPlainString() + "T";
+ } else {
+ return String.format("%.0f", v);
+ }
+ }
+
+ /*
+ * prints the properties subopt/section
+ */
+ private static void printProperties(PrintStream ostream) {
+ Properties p = System.getProperties();
+ ostream.println(PROP_SETTINGS);
+ List sortedPropertyKeys = new ArrayList<>();
+ sortedPropertyKeys.addAll(p.stringPropertyNames());
+ Collections.sort(sortedPropertyKeys);
+ for (String x : sortedPropertyKeys) {
+ printPropertyValue(ostream, x, p.getProperty(x));
+ }
+ ostream.println();
+ }
+
+ private static boolean isPath(String key) {
+ return key.endsWith(".dirs") || key.endsWith(".path");
+ }
+
+ private static void printPropertyValue(PrintStream ostream,
+ String key, String value) {
+ ostream.print(INDENT + key + " = ");
+ if (key.equals("line.separator")) {
+ byte[] bytes = value.getBytes();
+ for (byte b : bytes) {
+ switch (b) {
+ case 0xd:
+ ostream.print("CR ");
+ break;
+ case 0xa:
+ ostream.print("LF ");
+ break;
+ default:
+ ostream.printf("0x%02X", b & 0xff);
+ break;
+ }
+ }
+ ostream.println();
+ return;
+ }
+ if (!isPath(key)) {
+ ostream.println(value);
+ return;
+ }
+ // pretty print the path values as a list
+ String[] values = value.split(System.getProperty("path.separator"));
+ int len = values.length;
+ for (int i = 0 ; i < len ; i++) {
+ if (i == 0) { // first line treated specially
+ ostream.println(values[i]);
+ } else { // following lines prefix with indents
+ ostream.print(INDENT + INDENT);
+ ostream.println(values[i]);
+ }
+ }
+ }
+
+ /*
+ * prints the locale subopt/section
+ */
+ private static void printLocale(PrintStream ostream) {
+ Locale locale = Locale.getDefault();
+ ostream.println(LOCALE_SETTINGS);
+ ostream.println(INDENT + "default locale = " + locale.getDisplayLanguage());
+ printLocales(ostream);
+ ostream.println();
+ }
+
+ private static void printLocales(PrintStream ostream) {
+ Locale[] locales = Locale.getAvailableLocales();
+ final int len = locales == null ? 0 : locales.length;
+ if (len < 1 ) {
+ return;
+ }
+ ostream.print(INDENT + "available locales = ");
+ final int last = len - 1 ;
+ for (int i = 0; i < last ; i++) {
+ ostream.print(locales[i]);
+ if (i != last) {
+ ostream.print(", ");
+ }
+ // print columns of 8
+ if ((i + 1) % 8 == 0) {
+ ostream.println();
+ ostream.print(INDENT + INDENT);
+ }
+ }
+ ostream.println(locales[last]);
+ }
+
/**
* A private helper method to get a localized message and also
* apply any arguments that we might pass.
diff --git a/src/share/classes/sun/launcher/resources/launcher.properties b/src/share/classes/sun/launcher/resources/launcher.properties
index e89d147a5bba82b96edc51d297343ec426729607..17ba48a13842ea68a03ea9231f69fc344b550e7e 100644
--- a/src/share/classes/sun/launcher/resources/launcher.properties
+++ b/src/share/classes/sun/launcher/resources/launcher.properties
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2007, 2010, 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
@@ -97,7 +97,15 @@ java.launcher.X.usage=\
\ -Xcheck:jni perform additional checks for JNI functions\n\
\ -Xshare:off do not attempt to use shared class data\n\
\ -Xshare:auto use shared class data if possible (default)\n\
-\ -Xshare:on require using shared class data, otherwise fail.\n\n\
+\ -Xshare:on require using shared class data, otherwise fail.\n\
+\ -XshowSettings show all settings and continue\n\
+\ -XshowSettings:all\n\
+\ show all settings and continue\n\
+\ -XshowSettings:vm show all vm related settings and continue\n\
+\ -XshowSettings:properties\n\
+\ show all property settings and continue\n\
+\ -XshowSettings:locale\n\
+\ show all locale related settings and continue\n\n\
The -X options are non-standard and subject to change without notice.\n
java.launcher.cls.error1=\
diff --git a/src/share/classes/sun/net/httpserver/ChunkedInputStream.java b/src/share/classes/sun/net/httpserver/ChunkedInputStream.java
index 8a7c88ac6032dec7ed268a740766d4d38d73937c..6339e87bd4481e317e3839309997e0f44af18cc9 100644
--- a/src/share/classes/sun/net/httpserver/ChunkedInputStream.java
+++ b/src/share/classes/sun/net/httpserver/ChunkedInputStream.java
@@ -110,6 +110,7 @@ class ChunkedInputStream extends LeftOverInputStream {
if (remaining == 0) {
eof = true;
consumeCRLF();
+ t.getServerImpl().requestCompleted (t.getConnection());
return -1;
}
needToReadHeader = false;
diff --git a/src/share/classes/sun/net/httpserver/Event.java b/src/share/classes/sun/net/httpserver/Event.java
index fa7512b99e8c58ab7e285b4565dd0a98b645ca4e..e3109eeb61831699d23e2124e0df516fc91081bb 100644
--- a/src/share/classes/sun/net/httpserver/Event.java
+++ b/src/share/classes/sun/net/httpserver/Event.java
@@ -40,5 +40,7 @@ class Event {
class WriteFinishedEvent extends Event {
WriteFinishedEvent (ExchangeImpl t) {
super (t);
+ assert !t.writefinished;
+ t.writefinished = true;
}
}
diff --git a/src/share/classes/sun/net/httpserver/ExchangeImpl.java b/src/share/classes/sun/net/httpserver/ExchangeImpl.java
index 26453e6973ead4a4b3e6d8a5d73174ad3e7a4861..edf813e2814a0faa3e044fac2b625eb93bf40b24 100644
--- a/src/share/classes/sun/net/httpserver/ExchangeImpl.java
+++ b/src/share/classes/sun/net/httpserver/ExchangeImpl.java
@@ -38,6 +38,7 @@ class ExchangeImpl {
Headers reqHdrs, rspHdrs;
Request req;
String method;
+ boolean writefinished;
URI uri;
HttpConnection connection;
long reqContentLen;
diff --git a/src/share/classes/sun/net/httpserver/FixedLengthInputStream.java b/src/share/classes/sun/net/httpserver/FixedLengthInputStream.java
index a98779295cba43abc87b8129d187394bddedba2c..abc5bf9244bfdab62703cccf83fdb78a06bddc7b 100644
--- a/src/share/classes/sun/net/httpserver/FixedLengthInputStream.java
+++ b/src/share/classes/sun/net/httpserver/FixedLengthInputStream.java
@@ -56,6 +56,9 @@ class FixedLengthInputStream extends LeftOverInputStream {
int n = in.read(b, off, len);
if (n > -1) {
remaining -= n;
+ if (remaining == 0) {
+ t.getServerImpl().requestCompleted (t.getConnection());
+ }
}
return n;
}
diff --git a/src/share/classes/sun/net/httpserver/HttpConnection.java b/src/share/classes/sun/net/httpserver/HttpConnection.java
index 6d2cf7f954ca33089374a4a3d28c13d191038076..adb79556fc5c06258b924ab961632bf3b071871a 100644
--- a/src/share/classes/sun/net/httpserver/HttpConnection.java
+++ b/src/share/classes/sun/net/httpserver/HttpConnection.java
@@ -55,10 +55,15 @@ class HttpConnection {
SelectionKey selectionKey;
String protocol;
long time;
+ volatile long creationTime; // time this connection was created
+ volatile long rspStartedTime; // time we started writing the response
int remaining;
boolean closed = false;
Logger logger;
+ public enum State {IDLE, REQUEST, RESPONSE};
+ volatile State state;
+
public String toString() {
String s = null;
if (chan != null) {
@@ -78,6 +83,14 @@ class HttpConnection {
context = ctx;
}
+ State getState() {
+ return state;
+ }
+
+ void setState (State s) {
+ state = s;
+ }
+
void setParameters (
InputStream in, OutputStream rawout, SocketChannel chan,
SSLEngine engine, SSLStreams sslStreams, SSLContext sslContext, String protocol,
diff --git a/src/share/classes/sun/net/httpserver/Request.java b/src/share/classes/sun/net/httpserver/Request.java
index 56c2e137f57f80a0251b84cecf9b7e417dbb2ef8..a51664b32b0c2012a3536840eba053c19f44ab55 100644
--- a/src/share/classes/sun/net/httpserver/Request.java
+++ b/src/share/classes/sun/net/httpserver/Request.java
@@ -201,32 +201,22 @@ class Request {
static class ReadStream extends InputStream {
SocketChannel channel;
- SelectorCache sc;
- Selector selector;
ByteBuffer chanbuf;
- SelectionKey key;
- int available;
byte[] one;
- boolean closed = false, eof = false;
+ private boolean closed = false, eof = false;
ByteBuffer markBuf; /* reads may be satisifed from this buffer */
boolean marked;
boolean reset;
int readlimit;
static long readTimeout;
ServerImpl server;
-
- static {
- readTimeout = ServerConfig.getReadTimeout();
- }
+ final static int BUFSIZE = 8 * 1024;
public ReadStream (ServerImpl server, SocketChannel chan) throws IOException {
this.channel = chan;
this.server = server;
- sc = SelectorCache.getSelectorCache();
- selector = sc.getSelector();
- chanbuf = ByteBuffer.allocate (8* 1024);
- key = chan.register (selector, SelectionKey.OP_READ);
- available = 0;
+ chanbuf = ByteBuffer.allocate (BUFSIZE);
+ chanbuf.clear();
one = new byte[1];
closed = marked = reset = false;
}
@@ -255,6 +245,12 @@ class Request {
return -1;
}
+ assert channel.isBlocking();
+
+ if (off < 0 || srclen < 0|| srclen > (b.length-off)) {
+ throw new IndexOutOfBoundsException ();
+ }
+
if (reset) { /* satisfy from markBuf */
canreturn = markBuf.remaining ();
willreturn = canreturn>srclen ? srclen : canreturn;
@@ -263,17 +259,19 @@ class Request {
reset = false;
}
} else { /* satisfy from channel */
- canreturn = available();
- while (canreturn == 0 && !eof) {
- block ();
- canreturn = available();
+ chanbuf.clear ();
+ if (srclen < BUFSIZE) {
+ chanbuf.limit (srclen);
}
- if (eof) {
+ do {
+ willreturn = channel.read (chanbuf);
+ } while (willreturn == 0);
+ if (willreturn == -1) {
+ eof = true;
return -1;
}
- willreturn = canreturn>srclen ? srclen : canreturn;
+ chanbuf.flip ();
chanbuf.get(b, off, willreturn);
- available -= willreturn;
if (marked) { /* copy into markBuf */
try {
@@ -286,6 +284,11 @@ class Request {
return willreturn;
}
+ public boolean markSupported () {
+ return true;
+ }
+
+ /* Does not query the OS socket */
public synchronized int available () throws IOException {
if (closed)
throw new IOException ("Stream is closed");
@@ -296,36 +299,7 @@ class Request {
if (reset)
return markBuf.remaining();
- if (available > 0)
- return available;
-
- chanbuf.clear ();
- available = channel.read (chanbuf);
- if (available > 0) {
- chanbuf.flip();
- } else if (available == -1) {
- eof = true;
- available = 0;
- }
- return available;
- }
-
- /**
- * block() only called when available==0 and buf is empty
- */
- private synchronized void block () throws IOException {
- long currtime = server.getTime();
- long maxtime = currtime + readTimeout;
-
- while (currtime < maxtime) {
- if (selector.select (readTimeout) == 1) {
- selector.selectedKeys().clear();
- available ();
- return;
- }
- currtime = server.getTime();
- }
- throw new SocketTimeoutException ("no data received");
+ return chanbuf.remaining();
}
public void close () throws IOException {
@@ -333,8 +307,6 @@ class Request {
return;
}
channel.close ();
- selector.selectNow();
- sc.freeSelector(selector);
closed = true;
}
@@ -362,23 +334,14 @@ class Request {
SocketChannel channel;
ByteBuffer buf;
SelectionKey key;
- SelectorCache sc;
- Selector selector;
boolean closed;
byte[] one;
ServerImpl server;
- static long writeTimeout;
-
- static {
- writeTimeout = ServerConfig.getWriteTimeout();
- }
public WriteStream (ServerImpl server, SocketChannel channel) throws IOException {
this.channel = channel;
this.server = server;
- sc = SelectorCache.getSelectorCache();
- selector = sc.getSelector();
- key = channel.register (selector, SelectionKey.OP_WRITE);
+ assert channel.isBlocking();
closed = false;
one = new byte [1];
buf = ByteBuffer.allocate (4096);
@@ -411,31 +374,14 @@ class Request {
l -= n;
if (l == 0)
return;
- block();
- }
- }
-
- void block () throws IOException {
- long currtime = server.getTime();
- long maxtime = currtime + writeTimeout;
-
- while (currtime < maxtime) {
- if (selector.select (writeTimeout) == 1) {
- selector.selectedKeys().clear ();
- return;
- }
- currtime = server.getTime();
}
- throw new SocketTimeoutException ("write blocked too long");
}
-
public void close () throws IOException {
if (closed)
return;
+ //server.logStackTrace ("Request.OS.close: isOpen="+channel.isOpen());
channel.close ();
- selector.selectNow();
- sc.freeSelector(selector);
closed = true;
}
}
diff --git a/src/share/classes/sun/net/httpserver/SSLStreams.java b/src/share/classes/sun/net/httpserver/SSLStreams.java
index fed7f4b49434518b391b8b3ab2151996e71e6d3c..8578177a61b3366d39439cfb6fb4c5ceab91702e 100644
--- a/src/share/classes/sun/net/httpserver/SSLStreams.java
+++ b/src/share/classes/sun/net/httpserver/SSLStreams.java
@@ -53,8 +53,6 @@ class SSLStreams {
EngineWrapper wrapper;
OutputStream os;
InputStream is;
- static long readTimeout = ServerConfig.getReadTimeout();
- static long writeTimeout = ServerConfig.getWriteTimeout();
/* held by thread doing the hand-shake on this connection */
Lock handshaking = new ReentrantLock();
@@ -77,10 +75,13 @@ class SSLStreams {
if (cfg != null) {
Parameters params = new Parameters (cfg, addr);
cfg.configure (params);
+//BEGIN_TIGER_EXCLUDE
SSLParameters sslParams = params.getSSLParameters();
if (sslParams != null) {
engine.setSSLParameters (sslParams);
- } else {
+ } else
+//END_TIGER_EXCLUDE
+ {
/* tiger compatibility */
if (params.getCipherSuites() != null) {
try {
@@ -104,7 +105,6 @@ class SSLStreams {
class Parameters extends HttpsParameters {
InetSocketAddress addr;
- SSLParameters params;
HttpsConfigurator cfg;
Parameters (HttpsConfigurator cfg, InetSocketAddress addr) {
@@ -117,12 +117,15 @@ class SSLStreams {
public HttpsConfigurator getHttpsConfigurator() {
return cfg;
}
+//BEGIN_TIGER_EXCLUDE
+ SSLParameters params;
public void setSSLParameters (SSLParameters p) {
params = p;
}
SSLParameters getSSLParameters () {
return params;
}
+//END_TIGER_EXCLUDE
}
/**
@@ -245,9 +248,6 @@ class SSLStreams {
SocketChannel chan;
SSLEngine engine;
- SelectorCache sc;
- Selector write_selector, read_selector;
- SelectionKey wkey, rkey;
Object wrapLock, unwrapLock;
ByteBuffer unwrap_src, wrap_dst;
boolean closed = false;
@@ -260,16 +260,9 @@ class SSLStreams {
unwrapLock = new Object();
unwrap_src = allocate(BufType.PACKET);
wrap_dst = allocate(BufType.PACKET);
- sc = SelectorCache.getSelectorCache();
- write_selector = sc.getSelector();
- wkey = chan.register (write_selector, SelectionKey.OP_WRITE);
- read_selector = sc.getSelector();
- wkey = chan.register (read_selector, SelectionKey.OP_READ);
}
void close () throws IOException {
- sc.freeSelector (write_selector);
- sc.freeSelector (read_selector);
}
/* try to wrap and send the data in src. Handles OVERFLOW.
@@ -304,15 +297,7 @@ class SSLStreams {
wrap_dst.flip();
int l = wrap_dst.remaining();
assert l == r.result.bytesProduced();
- long currtime = time.getTime();
- long maxtime = currtime + writeTimeout;
while (l>0) {
- write_selector.select(writeTimeout); // timeout
- currtime = time.getTime();
- if (currtime > maxtime) {
- throw new SocketTimeoutException ("write timed out");
- }
- write_selector.selectedKeys().clear();
l -= chan.write (wrap_dst);
}
}
@@ -342,20 +327,12 @@ class SSLStreams {
needData = true;
}
synchronized (unwrapLock) {
- int x,y;
+ int x;
do {
if (needData) {
- long currTime = time.getTime();
- long maxtime = currTime + readTimeout;
do {
- if (currTime > maxtime) {
- throw new SocketTimeoutException ("read timedout");
- }
- y = read_selector.select (readTimeout);
- currTime = time.getTime();
- } while (y != 1);
- read_selector.selectedKeys().clear();
x = chan.read (unwrap_src);
+ } while (x == 0);
if (x == -1) {
throw new IOException ("connection closed for reading");
}
diff --git a/src/share/classes/sun/net/httpserver/SelectorCache.java b/src/share/classes/sun/net/httpserver/SelectorCache.java
deleted file mode 100644
index afd87c022356e363faae70569dfa9d09e5f15127..0000000000000000000000000000000000000000
--- a/src/share/classes/sun/net/httpserver/SelectorCache.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2006, 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.net.httpserver;
-
-import java.util.*;
-import java.nio.*;
-import java.net.*;
-import java.io.*;
-import java.security.*;
-import java.nio.channels.*;
-
-/*
- * Implements a cache of java.nio.channels.Selector
- * where Selectors are allocated on demand and placed
- * in a temporary cache for a period of time, so they
- * can be reused. If a period of between 2 and 4 minutes
- * elapses without being used, then they are closed.
- */
-public class SelectorCache {
-
- static SelectorCache cache = null;
-
- private SelectorCache () {
- freeSelectors = new LinkedList();
- CacheCleaner c = AccessController.doPrivileged(
- new PrivilegedAction() {
- public CacheCleaner run() {
- CacheCleaner cleaner = new CacheCleaner();
- cleaner.setDaemon (true);
- return cleaner;
- }
- });
- c.start();
- }
-
- /**
- * factory method for creating single instance
- */
- public static SelectorCache getSelectorCache () {
- synchronized (SelectorCache.class) {
- if (cache == null) {
- cache = new SelectorCache ();
- }
- }
- return cache;
- }
-
- private static class SelectorWrapper {
- private Selector sel;
- private boolean deleteFlag;
- private SelectorWrapper (Selector sel) {
- this.sel = sel;
- this.deleteFlag = false;
- }
- public Selector getSelector() { return sel;}
- public boolean getDeleteFlag () {return deleteFlag;}
- public void setDeleteFlag (boolean b) {deleteFlag = b;}
- }
-
- /* list of free selectors. Can be re-allocated for a period
- * of time, after which if not allocated will be closed
- * and removed from the list (by CacheCleaner thread)
- */
- LinkedList freeSelectors;
-
- synchronized Selector getSelector () throws IOException {
- SelectorWrapper wrapper = null;
- Selector selector;
-
- if (freeSelectors.size() > 0) {
- wrapper = freeSelectors.remove();
- selector = wrapper.getSelector();
- } else {
- selector = Selector.open();
- }
- return selector;
- }
-
- synchronized void freeSelector (Selector selector) {
- freeSelectors.add (new SelectorWrapper (selector));
- }
-
- /* Thread ensures that entries on freeSelector list
- * remain there for at least 2 minutes and no longer
- * than 4 minutes.
- */
- class CacheCleaner extends Thread {
- public void run () {
- long timeout = ServerConfig.getSelCacheTimeout() * 1000;
- while (true) {
- try {Thread.sleep (timeout); } catch (Exception e) {}
- synchronized (freeSelectors) {
- ListIterator l = freeSelectors.listIterator();
- while (l.hasNext()) {
- SelectorWrapper w = l.next();
- if (w.getDeleteFlag()) {
- /* 2nd pass. Close the selector */
- try {
- w.getSelector().close();
- } catch (IOException e) {}
- l.remove();
- } else {
- /* 1st pass. Set the flag */
- w.setDeleteFlag (true);
- }
- }
- }
- }
- }
- }
-}
diff --git a/src/share/classes/sun/net/httpserver/ServerConfig.java b/src/share/classes/sun/net/httpserver/ServerConfig.java
index d4c87847547071c629348a705959a49ae5f01df9..cae3cdd84d9c7c5aeef345edb32cad97f1148424 100644
--- a/src/share/classes/sun/net/httpserver/ServerConfig.java
+++ b/src/share/classes/sun/net/httpserver/ServerConfig.java
@@ -27,6 +27,8 @@ package sun.net.httpserver;
import com.sun.net.httpserver.*;
import com.sun.net.httpserver.spi.*;
+import java.util.logging.Logger;
+import java.security.PrivilegedAction;
/**
* Parameters that users will not likely need to set
@@ -37,23 +39,26 @@ class ServerConfig {
static int clockTick;
- static int defaultClockTick = 10000 ; // 10 sec.
+ static final int DEFAULT_CLOCK_TICK = 10000 ; // 10 sec.
/* These values must be a reasonable multiple of clockTick */
- static long defaultReadTimeout = 20 ; // 20 sec.
- static long defaultWriteTimeout = 60 ; // 60 sec.
- static long defaultIdleInterval = 300 ; // 5 min
- static long defaultSelCacheTimeout = 120 ; // seconds
- static int defaultMaxIdleConnections = 200 ;
+ static final long DEFAULT_IDLE_INTERVAL = 300 ; // 5 min
+ static final int DEFAULT_MAX_IDLE_CONNECTIONS = 200 ;
- static long defaultDrainAmount = 64 * 1024;
+ static final long DEFAULT_MAX_REQ_TIME = -1; // default: forever
+ static final long DEFAULT_MAX_RSP_TIME = -1; // default: forever
+ static final long DEFAULT_TIMER_MILLIS = 1000;
+
+ static final long DEFAULT_DRAIN_AMOUNT = 64 * 1024;
- static long readTimeout;
- static long writeTimeout;
static long idleInterval;
- static long selCacheTimeout;
static long drainAmount; // max # of bytes to drain from an inputstream
static int maxIdleConnections;
+
+ // max time a request or response is allowed to take
+ static long maxReqTime;
+ static long maxRspTime;
+ static long timerMillis;
static boolean debug = false;
static {
@@ -61,49 +66,79 @@ class ServerConfig {
idleInterval = ((Long)java.security.AccessController.doPrivileged(
new sun.security.action.GetLongAction(
"sun.net.httpserver.idleInterval",
- defaultIdleInterval))).longValue() * 1000;
+ DEFAULT_IDLE_INTERVAL))).longValue() * 1000;
clockTick = ((Integer)java.security.AccessController.doPrivileged(
new sun.security.action.GetIntegerAction(
"sun.net.httpserver.clockTick",
- defaultClockTick))).intValue();
+ DEFAULT_CLOCK_TICK))).intValue();
maxIdleConnections = ((Integer)java.security.AccessController.doPrivileged(
new sun.security.action.GetIntegerAction(
"sun.net.httpserver.maxIdleConnections",
- defaultMaxIdleConnections))).intValue();
+ DEFAULT_MAX_IDLE_CONNECTIONS))).intValue();
- readTimeout = ((Long)java.security.AccessController.doPrivileged(
+ drainAmount = ((Long)java.security.AccessController.doPrivileged(
new sun.security.action.GetLongAction(
- "sun.net.httpserver.readTimeout",
- defaultReadTimeout))).longValue()* 1000;
+ "sun.net.httpserver.drainAmount",
+ DEFAULT_DRAIN_AMOUNT))).longValue();
- selCacheTimeout = ((Long)java.security.AccessController.doPrivileged(
+ maxReqTime = ((Long)java.security.AccessController.doPrivileged(
new sun.security.action.GetLongAction(
- "sun.net.httpserver.selCacheTimeout",
- defaultSelCacheTimeout))).longValue()* 1000;
+ "sun.net.httpserver.maxReqTime",
+ DEFAULT_MAX_REQ_TIME))).longValue();
- writeTimeout = ((Long)java.security.AccessController.doPrivileged(
+ maxRspTime = ((Long)java.security.AccessController.doPrivileged(
new sun.security.action.GetLongAction(
- "sun.net.httpserver.writeTimeout",
- defaultWriteTimeout))).longValue()* 1000;
+ "sun.net.httpserver.maxRspTime",
+ DEFAULT_MAX_RSP_TIME))).longValue();
- drainAmount = ((Long)java.security.AccessController.doPrivileged(
+ timerMillis = ((Long)java.security.AccessController.doPrivileged(
new sun.security.action.GetLongAction(
- "sun.net.httpserver.drainAmount",
- defaultDrainAmount))).longValue();
+ "sun.net.httpserver.timerMillis",
+ DEFAULT_TIMER_MILLIS))).longValue();
debug = ((Boolean)java.security.AccessController.doPrivileged(
new sun.security.action.GetBooleanAction(
"sun.net.httpserver.debug"))).booleanValue();
}
- static long getReadTimeout () {
- return readTimeout;
- }
- static long getSelCacheTimeout () {
- return selCacheTimeout;
+ static void checkLegacyProperties (final Logger logger) {
+
+ // legacy properties that are no longer used
+ // print a warning to logger if they are set.
+
+ java.security.AccessController.doPrivileged(
+ new PrivilegedAction() {
+ public Void run () {
+ if (System.getProperty("sun.net.httpserver.readTimeout")
+ !=null)
+ {
+ logger.warning ("sun.net.httpserver.readTimeout "+
+ "property is no longer used. "+
+ "Use sun.net.httpserver.maxReqTime instead."
+ );
+ }
+ if (System.getProperty("sun.net.httpserver.writeTimeout")
+ !=null)
+ {
+ logger.warning ("sun.net.httpserver.writeTimeout "+
+ "property is no longer used. Use "+
+ "sun.net.httpserver.maxRspTime instead."
+ );
+ }
+ if (System.getProperty("sun.net.httpserver.selCacheTimeout")
+ !=null)
+ {
+ logger.warning ("sun.net.httpserver.selCacheTimeout "+
+ "property is no longer used."
+ );
+ }
+ return null;
+ }
+ }
+ );
}
static boolean debugEnabled () {
@@ -122,11 +157,19 @@ class ServerConfig {
return maxIdleConnections;
}
- static long getWriteTimeout () {
- return writeTimeout;
- }
-
static long getDrainAmount () {
return drainAmount;
}
+
+ static long getMaxReqTime () {
+ return maxReqTime;
+ }
+
+ static long getMaxRspTime () {
+ return maxRspTime;
+ }
+
+ static long getTimerMillis () {
+ return timerMillis;
+ }
}
diff --git a/src/share/classes/sun/net/httpserver/ServerImpl.java b/src/share/classes/sun/net/httpserver/ServerImpl.java
index a8b0287808230d5c5cbe7226b12775ad5e4be337..08edeaf8a80687c3859296ac2b6a24fd3fd5edc4 100644
--- a/src/share/classes/sun/net/httpserver/ServerImpl.java
+++ b/src/share/classes/sun/net/httpserver/ServerImpl.java
@@ -37,6 +37,7 @@ import java.util.logging.Level;
import javax.net.ssl.*;
import com.sun.net.httpserver.*;
import com.sun.net.httpserver.spi.*;
+import sun.net.httpserver.HttpConnection.State;
/**
* Provides implementation for both HTTP and HTTPS
@@ -55,6 +56,12 @@ class ServerImpl implements TimeSource {
private SelectionKey listenerKey;
private Set idleConnections;
private Set allConnections;
+ /* following two are used to keep track of the times
+ * when a connection/request is first received
+ * and when we start to send the response
+ */
+ private Set reqConnections;
+ private Set rspConnections;
private List events;
private Object lolock = new Object();
private volatile boolean finished = false;
@@ -62,14 +69,19 @@ class ServerImpl implements TimeSource {
private boolean bound = false;
private boolean started = false;
private volatile long time; /* current time */
+ private volatile long subticks = 0;
private volatile long ticks; /* number of clock ticks since server started */
private HttpServer wrapper;
final static int CLOCK_TICK = ServerConfig.getClockTick();
final static long IDLE_INTERVAL = ServerConfig.getIdleInterval();
final static int MAX_IDLE_CONNECTIONS = ServerConfig.getMaxIdleConnections();
+ final static long TIMER_MILLIS = ServerConfig.getTimerMillis ();
+ final static long MAX_REQ_TIME=getTimeMillis(ServerConfig.getMaxReqTime());
+ final static long MAX_RSP_TIME=getTimeMillis(ServerConfig.getMaxRspTime());
+ final static boolean timer1Enabled = MAX_REQ_TIME != -1 || MAX_RSP_TIME != -1;
- private Timer timer;
+ private Timer timer, timer1;
private Logger logger;
ServerImpl (
@@ -79,6 +91,7 @@ class ServerImpl implements TimeSource {
this.protocol = protocol;
this.wrapper = wrapper;
this.logger = Logger.getLogger ("com.sun.net.httpserver");
+ ServerConfig.checkLegacyProperties (logger);
https = protocol.equalsIgnoreCase ("https");
this.address = addr;
contexts = new ContextList();
@@ -94,9 +107,18 @@ class ServerImpl implements TimeSource {
dispatcher = new Dispatcher();
idleConnections = Collections.synchronizedSet (new HashSet());
allConnections = Collections.synchronizedSet (new HashSet());
+ reqConnections = Collections.synchronizedSet (new HashSet());
+ rspConnections = Collections.synchronizedSet (new HashSet());
time = System.currentTimeMillis();
timer = new Timer ("server-timer", true);
timer.schedule (new ServerTimerTask(), CLOCK_TICK, CLOCK_TICK);
+ if (timer1Enabled) {
+ timer1 = new Timer ("server-timer1", true);
+ timer1.schedule (new ServerTimerTask1(),TIMER_MILLIS,TIMER_MILLIS);
+ logger.config ("HttpServer timer1 enabled period in ms: "+TIMER_MILLIS);
+ logger.config ("MAX_REQ_TIME: "+MAX_REQ_TIME);
+ logger.config ("MAX_RSP_TIME: "+MAX_RSP_TIME);
+ }
events = new LinkedList();
logger.config ("HttpServer created "+protocol+" "+ addr);
}
@@ -181,6 +203,9 @@ class ServerImpl implements TimeSource {
allConnections.clear();
idleConnections.clear();
timer.cancel();
+ if (timer1Enabled) {
+ timer1.cancel();
+ }
}
Dispatcher dispatcher;
@@ -236,13 +261,6 @@ class ServerImpl implements TimeSource {
}
}
- int resultSize () {
- synchronized (lolock) {
- return events.size ();
- }
- }
-
-
/* main server listener task */
class Dispatcher implements Runnable {
@@ -257,7 +275,7 @@ class ServerImpl implements TimeSource {
if (terminating && exchanges == 0) {
finished = true;
}
- SocketChannel chan = c.getChannel();
+ responseCompleted (c);
LeftOverInputStream is = t.getOriginalInputStream();
if (!is.isEOF()) {
t.close = true;
@@ -268,17 +286,10 @@ class ServerImpl implements TimeSource {
} else {
if (is.isDataBuffered()) {
/* don't re-enable the interestops, just handle it */
+ requestStarted (c);
handle (c.getChannel(), c);
} else {
- /* re-enable interestops */
- SelectionKey key = c.getSelectionKey();
- if (key.isValid()) {
- key.interestOps (
- key.interestOps()|SelectionKey.OP_READ
- );
- }
- c.time = getTime() + IDLE_INTERVAL;
- idleConnections.add (c);
+ connsToRegister.add (c);
}
}
}
@@ -290,22 +301,51 @@ class ServerImpl implements TimeSource {
}
}
+ final LinkedList connsToRegister =
+ new LinkedList();
+
+ void reRegister (HttpConnection c) {
+ /* re-register with selector */
+ try {
+ SocketChannel chan = c.getChannel();
+ chan.configureBlocking (false);
+ SelectionKey key = chan.register (selector, SelectionKey.OP_READ);
+ key.attach (c);
+ c.selectionKey = key;
+ c.time = getTime() + IDLE_INTERVAL;
+ idleConnections.add (c);
+ } catch (IOException e) {
+ dprint(e);
+ logger.log(Level.FINER, "Dispatcher(8)", e);
+ c.close();
+ }
+ }
+
public void run() {
while (!finished) {
try {
+ ListIterator li =
+ connsToRegister.listIterator();
+ for (HttpConnection c : connsToRegister) {
+ reRegister(c);
+ }
+ connsToRegister.clear();
- /* process the events list first */
+ List list = null;
+ selector.select(1000);
+ synchronized (lolock) {
+ if (events.size() > 0) {
+ list = events;
+ events = new LinkedList();
+ }
+ }
- while (resultSize() > 0) {
- Event r;
- synchronized (lolock) {
- r = events.remove(0);
+ if (list != null) {
+ for (Event r: list) {
handleEvent (r);
}
}
- selector.select(1000);
-
/* process the selected list now */
Set selected = selector.selectedKeys();
@@ -327,6 +367,7 @@ class ServerImpl implements TimeSource {
c.selectionKey = newkey;
c.setChannel (chan);
newkey.attach (c);
+ requestStarted (c);
allConnections.add (c);
} else {
try {
@@ -334,27 +375,44 @@ class ServerImpl implements TimeSource {
boolean closed;
SocketChannel chan = (SocketChannel)key.channel();
HttpConnection conn = (HttpConnection)key.attachment();
- // interestOps will be restored at end of read
- key.interestOps (0);
+
+ key.cancel();
+ chan.configureBlocking (true);
+ if (idleConnections.remove(conn)) {
+ // was an idle connection so add it
+ // to reqConnections set.
+ requestStarted (conn);
+ }
handle (chan, conn);
} else {
assert false;
}
+ } catch (CancelledKeyException e) {
+ handleException(key, null);
} catch (IOException e) {
- HttpConnection conn = (HttpConnection)key.attachment();
- logger.log (
- Level.FINER, "Dispatcher (2)", e
- );
- conn.close();
+ handleException(key, e);
}
}
}
+ // call the selector just to process the cancelled keys
+ selector.selectNow();
+ } catch (IOException e) {
+ logger.log (Level.FINER, "Dispatcher (4)", e);
} catch (Exception e) {
- logger.log (Level.FINER, "Dispatcher (3)", e);
+ e.printStackTrace();
+ logger.log (Level.FINER, "Dispatcher (7)", e);
}
}
}
+ private void handleException (SelectionKey key, Exception e) {
+ HttpConnection conn = (HttpConnection)key.attachment();
+ if (e != null) {
+ logger.log (Level.FINER, "Dispatcher (2)", e);
+ }
+ closeConnection(conn);
+ }
+
public void handle (SocketChannel chan, HttpConnection conn)
throws IOException
{
@@ -363,10 +421,10 @@ class ServerImpl implements TimeSource {
executor.execute (t);
} catch (HttpError e1) {
logger.log (Level.FINER, "Dispatcher (4)", e1);
- conn.close();
+ closeConnection(conn);
} catch (IOException e) {
logger.log (Level.FINER, "Dispatcher (5)", e);
- conn.close();
+ closeConnection(conn);
}
}
}
@@ -390,7 +448,26 @@ class ServerImpl implements TimeSource {
return logger;
}
- /* per exchange task */
+ private void closeConnection(HttpConnection conn) {
+ conn.close();
+ allConnections.remove(conn);
+ switch (conn.getState()) {
+ case REQUEST:
+ reqConnections.remove(conn);
+ break;
+ case RESPONSE:
+ rspConnections.remove(conn);
+ break;
+ case IDLE:
+ idleConnections.remove(conn);
+ break;
+ }
+ assert !reqConnections.remove(conn);
+ assert !rspConnections.remove(conn);
+ assert !idleConnections.remove(conn);
+ }
+
+ /* per exchange task */
class Exchange implements Runnable {
SocketChannel chan;
@@ -450,8 +527,7 @@ class ServerImpl implements TimeSource {
requestLine = req.requestLine();
if (requestLine == null) {
/* connection closed */
- connection.close();
- allConnections.remove(connection);
+ closeConnection(connection);
return;
}
int space = requestLine.indexOf (' ');
@@ -482,6 +558,9 @@ class ServerImpl implements TimeSource {
if (s != null) {
clen = Long.parseLong(s);
}
+ if (clen == 0) {
+ requestCompleted (connection);
+ }
}
ctx = contexts.findContext (protocol, uri.getPath());
if (ctx == null) {
@@ -560,7 +639,7 @@ class ServerImpl implements TimeSource {
} catch (IOException e1) {
logger.log (Level.FINER, "ServerImpl.Exchange (1)", e1);
- connection.close();
+ closeConnection(connection);
} catch (NumberFormatException e3) {
reject (Code.HTTP_BAD_REQUEST,
requestLine, "NumberFormatException thrown");
@@ -569,7 +648,7 @@ class ServerImpl implements TimeSource {
requestLine, "URISyntaxException thrown");
} catch (Exception e4) {
logger.log (Level.FINER, "ServerImpl.Exchange (2)", e4);
- connection.close();
+ closeConnection(connection);
}
}
@@ -591,47 +670,60 @@ class ServerImpl implements TimeSource {
rejected = true;
logReply (code, requestStr, message);
sendReply (
- code, true, ""+code+Code.msg(code)+""+message
+ code, false, ""+code+Code.msg(code)+""+message
);
- /* connection is already closed by sendReply, now remove it */
- allConnections.remove(connection);
+ closeConnection(connection);
}
void sendReply (
int code, boolean closeNow, String text)
{
try {
- String s = "HTTP/1.1 " + code + Code.msg(code) + "\r\n";
+ StringBuilder builder = new StringBuilder (512);
+ builder.append ("HTTP/1.1 ")
+ .append (code).append (Code.msg(code)).append ("\r\n");
+
if (text != null && text.length() != 0) {
- s = s + "Content-Length: "+text.length()+"\r\n";
- s = s + "Content-Type: text/html\r\n";
+ builder.append ("Content-Length: ")
+ .append (text.length()).append ("\r\n")
+ .append ("Content-Type: text/html\r\n");
} else {
- s = s + "Content-Length: 0\r\n";
+ builder.append ("Content-Length: 0\r\n");
text = "";
}
if (closeNow) {
- s = s + "Connection: close\r\n";
+ builder.append ("Connection: close\r\n");
}
- s = s + "\r\n" + text;
+ builder.append ("\r\n").append (text);
+ String s = builder.toString();
byte[] b = s.getBytes("ISO8859_1");
rawout.write (b);
rawout.flush();
if (closeNow) {
- connection.close();
+ closeConnection(connection);
}
} catch (IOException e) {
logger.log (Level.FINER, "ServerImpl.sendReply", e);
- connection.close();
+ closeConnection(connection);
}
}
}
void logReply (int code, String requestStr, String text) {
+ if (!logger.isLoggable(Level.FINE)) {
+ return;
+ }
if (text == null) {
text = "";
}
- String message = requestStr + " [" + code + " " +
+ String r;
+ if (requestStr.length() > 80) {
+ r = requestStr.substring (0, 80) + "";
+ } else {
+ r = requestStr;
+ }
+ String message = r + " [" + code + " " +
Code.msg(code) + "] ("+text+")";
logger.fine (message);
}
@@ -667,6 +759,34 @@ class ServerImpl implements TimeSource {
return wrapper;
}
+ void requestStarted (HttpConnection c) {
+ c.creationTime = getTime();
+ c.setState (State.REQUEST);
+ reqConnections.add (c);
+ }
+
+ // called after a request has been completely read
+ // by the server. This stops the timer which would
+ // close the connection if the request doesn't arrive
+ // quickly enough. It then starts the timer
+ // that ensures the client reads the response in a timely
+ // fashion.
+
+ void requestCompleted (HttpConnection c) {
+ assert c.getState() == State.REQUEST;
+ reqConnections.remove (c);
+ c.rspStartedTime = getTime();
+ rspConnections.add (c);
+ c.setState (State.RESPONSE);
+ }
+
+ // called after response has been sent
+ void responseCompleted (HttpConnection c) {
+ assert c.getState() == State.RESPONSE;
+ rspConnections.remove (c);
+ c.setState (State.IDLE);
+ }
+
/**
* TimerTask run every CLOCK_TICK ms
*/
@@ -689,4 +809,62 @@ class ServerImpl implements TimeSource {
}
}
}
+
+ class ServerTimerTask1 extends TimerTask {
+
+ // runs every TIMER_MILLIS
+ public void run () {
+ LinkedList toClose = new LinkedList();
+ time = System.currentTimeMillis();
+ synchronized (reqConnections) {
+ if (MAX_REQ_TIME != -1) {
+ for (HttpConnection c : reqConnections) {
+ if (c.creationTime + TIMER_MILLIS + MAX_REQ_TIME <= time) {
+ toClose.add (c);
+ }
+ }
+ for (HttpConnection c : toClose) {
+ logger.log (Level.FINE, "closing: no request: " + c);
+ reqConnections.remove (c);
+ allConnections.remove (c);
+ c.close();
+ }
+ }
+ }
+ toClose = new LinkedList();
+ synchronized (rspConnections) {
+ if (MAX_RSP_TIME != -1) {
+ for (HttpConnection c : rspConnections) {
+ if (c.rspStartedTime + TIMER_MILLIS +MAX_RSP_TIME <= time) {
+ toClose.add (c);
+ }
+ }
+ for (HttpConnection c : toClose) {
+ logger.log (Level.FINE, "closing: no response: " + c);
+ rspConnections.remove (c);
+ allConnections.remove (c);
+ c.close();
+ }
+ }
+ }
+ }
+ }
+
+ void logStackTrace (String s) {
+ logger.finest (s);
+ StringBuilder b = new StringBuilder ();
+ StackTraceElement[] e = Thread.currentThread().getStackTrace();
+ for (int i=0; i 0) {
+ if (length == 0) {
+ return null;
+ } else {
byte[] bytes = new byte[length];
read(bytes, 0, length);
- Ticket ticket = new Ticket(bytes);
- return ticket;
+ return bytes;
}
- else return null;
}
boolean[] readFlags() throws IOException {
@@ -328,6 +328,17 @@ public class CCacheInputStream extends KrbDataInputStream implements FileCCacheC
}
return flags;
}
+
+ /**
+ * Reads the next cred in stream.
+ * @return the next cred, null if ticket or second_ticket unparseable.
+ *
+ * Note: MIT krb5 1.8.1 might generate a config entry with server principal
+ * X-CACHECONF:/krb5_ccache_conf_data/fast_avail/krbtgt/REALM@REALM. The
+ * entry is used by KDC to inform the client that it support certain
+ * features. Its ticket is not a valid krb5 ticket and thus this method
+ * returns null.
+ */
Credentials readCred(int version) throws IOException,RealmException, KrbApErrException, Asn1Exception {
PrincipalName cpname = readPrincipal(version);
if (DEBUG)
@@ -367,17 +378,17 @@ public class CCacheInputStream extends KrbDataInputStream implements FileCCacheC
if (auData != null) {
auData = new AuthorizationData(auDataEntry);
}
- Ticket ticket = readData();
- if (DEBUG) {
- System.out.println(">>>DEBUG ");
- if (ticket == null) {
- System.out.println("///ticket is null");
- }
+ byte[] ticketData = readData();
+ byte[] ticketData2 = readData();
+
+ try {
+ return new Credentials(cpname, spname, key, authtime, starttime,
+ endtime, renewTill, skey, tFlags,
+ addrs, auData,
+ ticketData != null ? new Ticket(ticketData) : null,
+ ticketData2 != null ? new Ticket(ticketData2) : null);
+ } catch (Exception e) { // If any of new Ticket(*) fails.
+ return null;
}
- Ticket secTicket = readData();
- Credentials cred = new Credentials(cpname, spname, key, authtime, starttime,
- endtime, renewTill, skey, tFlags,
- addrs, auData, ticket, secTicket);
- return cred;
}
}
diff --git a/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java b/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java
index 6095077f503b31f27f3f4297a395912999c84044..4f874903f79596516101b8cbf7331cd7c18664bf 100644
--- a/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java
+++ b/src/share/classes/sun/security/krb5/internal/ccache/FileCredentialsCache.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2010, 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
@@ -186,7 +186,10 @@ public class FileCredentialsCache extends CredentialsCache
primaryRealm = primaryPrincipal.getRealm();
credentialsList = new Vector ();
while (cis.available() > 0) {
- credentialsList.addElement(cis.readCred(version));
+ Credentials cred = cis.readCred(version);
+ if (cred != null) {
+ credentialsList.addElement(cred);
+ }
}
cis.close();
}
diff --git a/src/share/classes/sun/security/pkcs11/P11Cipher.java b/src/share/classes/sun/security/pkcs11/P11Cipher.java
index 1ea39e799d1ad9c786c5befcd151ee92e321bf3f..5568887a5f61a40f80c1774a5fbf7e2a49c7b8b4 100644
--- a/src/share/classes/sun/security/pkcs11/P11Cipher.java
+++ b/src/share/classes/sun/security/pkcs11/P11Cipher.java
@@ -74,7 +74,7 @@ final class P11Cipher extends CipherSpi {
// DEC: return the length of trailing padding bytes given the specified
// padded data
int unpad(byte[] paddedData, int len)
- throws BadPaddingException;
+ throws BadPaddingException, IllegalBlockSizeException;
}
private static class PKCS5Padding implements Padding {
@@ -96,9 +96,10 @@ final class P11Cipher extends CipherSpi {
}
public int unpad(byte[] paddedData, int len)
- throws BadPaddingException {
- if (len < 1 || len > paddedData.length) {
- throw new BadPaddingException("Invalid pad array length!");
+ throws BadPaddingException, IllegalBlockSizeException {
+ if ((len < 1) || (len % blockSize != 0)) {
+ throw new IllegalBlockSizeException
+ ("Input length must be multiples of " + blockSize);
}
byte padValue = paddedData[len - 1];
if (padValue < 1 || padValue > blockSize) {
diff --git a/src/share/classes/sun/security/ssl/Krb5Helper.java b/src/share/classes/sun/security/ssl/Krb5Helper.java
index 440b119861e1f3fe2afbe2bffc44611b88e73814..b61ab4f293829256fea775fe3021c3e7cbc1951b 100644
--- a/src/share/classes/sun/security/ssl/Krb5Helper.java
+++ b/src/share/classes/sun/security/ssl/Krb5Helper.java
@@ -10,7 +10,7 @@
*
* 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
+ * 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).
*
diff --git a/src/share/classes/sun/security/ssl/Krb5Proxy.java b/src/share/classes/sun/security/ssl/Krb5Proxy.java
index 2e5915859420ec3ebcc355ab9044a7f3b4f9b760..24ace2b85dbb197bc77b5545d7a095c89db70974 100644
--- a/src/share/classes/sun/security/ssl/Krb5Proxy.java
+++ b/src/share/classes/sun/security/ssl/Krb5Proxy.java
@@ -10,7 +10,7 @@
*
* 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
+ * 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).
*
diff --git a/src/share/classes/sun/security/ssl/krb5/Krb5ProxyImpl.java b/src/share/classes/sun/security/ssl/krb5/Krb5ProxyImpl.java
index 70dc7532e5bc540ac9bda71fb6fbae547fee2959..ce0479d78af564c37d6c075ea789b0e7250d741d 100644
--- a/src/share/classes/sun/security/ssl/krb5/Krb5ProxyImpl.java
+++ b/src/share/classes/sun/security/ssl/krb5/Krb5ProxyImpl.java
@@ -10,7 +10,7 @@
*
* 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
+ * 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).
*
diff --git a/src/share/demo/applets/NervousText/example1.html b/src/share/demo/applets/NervousText/example1.html
index 38e4f840da5cd204c11813902ed022df08d2ea81..96013da6f4520abb0602ae25727e5ac66d2550da 100644
--- a/src/share/demo/applets/NervousText/example1.html
+++ b/src/share/demo/applets/NervousText/example1.html
@@ -1,7 +1,7 @@
Nervous Text 1.1
The source.
diff --git a/src/share/demo/java2d/J2DBench/src/j2dbench/J2DBench.java b/src/share/demo/java2d/J2DBench/src/j2dbench/J2DBench.java
index 193264670d53c7fb9cd21cdd2f827e643a11b3de..e198c0c84245db5952218558d5933ab4444ba098 100644
--- a/src/share/demo/java2d/J2DBench/src/j2dbench/J2DBench.java
+++ b/src/share/demo/java2d/J2DBench/src/j2dbench/J2DBench.java
@@ -75,7 +75,8 @@ public class J2DBench {
static JFrame guiFrame;
- static final SimpleDateFormat sdf = new SimpleDateFormat("MM.dd.yyyy 'at' HH:mm aaa z");
+ static final SimpleDateFormat sdf =
+ new SimpleDateFormat("MM.dd.yyyy 'at' HH:mm aaa z");
public static void init() {
progoptroot = new Group("prog", "Program Options");
@@ -176,6 +177,8 @@ public class J2DBench {
public static void main(String argv[]) {
init();
TestEnvironment.init();
+ Result.init();
+
Destinations.init();
GraphicsTests.init();
RenderTests.init();
@@ -323,7 +326,7 @@ public class J2DBench {
} else if (type.equalsIgnoreCase("m")) {
multiplyWith = 60;
} else {
- System.out.println("Invalid \"-loop\" option specified.");
+ System.err.println("Invalid \"-loop\" option specified.");
usage(1);
}
@@ -331,32 +334,20 @@ public class J2DBench {
try {
val = Integer.parseInt(argv[i].substring(0, argv[i].length() - 1));
} catch(Exception e) {
- System.out.println("Invalid \"-loop\" option specified.");
+ System.err.println("Invalid \"-loop\" option specified.");
usage(1);
}
requiredLoopTime = val * multiplyWith * 1000;
}
- } else if (arg.length() > 7 &&
- arg.substring(0, 7).equalsIgnoreCase("-report"))
- {
- for (int j = 7; j < arg.length(); j++) {
- char c = arg.charAt(j);
- switch (c) {
- case 'N': Result.unitScale = Result.UNITS_WHOLE; break;
- case 'M': Result.unitScale = Result.UNITS_MILLIONS; break;
- case 'K': Result.unitScale = Result.UNITS_THOUSANDS; break;
- case 'A': Result.unitScale = Result.UNITS_AUTO; break;
- case 'U': Result.useUnits = true; break;
- case 'O': Result.useUnits = false; break;
- case 's': Result.timeScale = Result.SECONDS_WHOLE; break;
- case 'm': Result.timeScale = Result.SECONDS_MILLIS; break;
- case 'u': Result.timeScale = Result.SECONDS_MICROS; break;
- case 'n': Result.timeScale = Result.SECONDS_NANOS; break;
- case 'a': Result.timeScale = Result.SECONDS_AUTO; break;
- case '/': Result.invertRate = !Result.invertRate; break;
- }
+ } else if (arg.length() > 8 &&
+ arg.substring(0, 8).equalsIgnoreCase("-report:"))
+ {
+ String error = Result.parseRateOpt(arg.substring(8));
+ if (error != null) {
+ System.err.println("Invalid rate: "+error);
+ usage(1);
}
} else {
String reason = Group.root.setOption(arg);
@@ -411,7 +402,7 @@ public class J2DBench {
writer.flush();
} catch(IOException ioe) {
ioe.printStackTrace();
- System.out.println("\nERROR : Could not create Loop-Report. Exit");
+ System.err.println("\nERROR : Could not create Loop-Report. Exit");
System.exit(1);
}
}
@@ -466,7 +457,7 @@ public class J2DBench {
} while(J2DBench.looping);
- if(J2DBench.looping) {
+ if (J2DBench.looping) {
writer.println(" |