obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

17 files changed, 3082 insertions, 0 deletions

diff --git a/libjava/classpath/vm/reference/gnu/java/lang/VMCPStringBuilder.java b/libjava/classpath/vm/reference/gnu/java/lang/VMCPStringBuilder.java
new file mode 100644
index 000000000..c3a3784f3
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/VMCPStringBuilder.java
@@ -0,0 +1,112 @@
+/* VMCPStringBuilder.java -- Growable strings without locking or copying
+   Copyright (C) 2008 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * This class provides VM support for CPStringBuilder
+ * by allowing the package-private constructor
+ * of java.lang.String to be invoked.  The default
+ * implementation uses reflection.  VMs may replace
+ * this class with a more efficient version.
+ */
+final class VMCPStringBuilder
+{
+
+  /**
+   * The package-private constructor for String objects without copying.
+   */
+  private static final Constructor cons;
+
+  static
+  {
+    try
+      {
+        cons = String.class.getDeclaredConstructor(new Class[] { char[].class,
+                                                                 Integer.TYPE,
+                                                                 Integer.TYPE,
+                                                                 Boolean.TYPE });
+        cons.setAccessible(true);
+      }
+    catch (NoSuchMethodException e)
+      {
+        throw (Error)
+          new InternalError("Could not get no-copy String constructor").initCause(e);
+      }
+  }
+
+  /**
+   * Convert this <code>StringBuilder</code> to a <code>String</code>. The
+   * String is composed of the characters currently in this StringBuilder. Note
+   * that the result is not a copy, so the builder will allocate a new array
+   * if a further write operation is attempted.
+   *
+   * @param value the buffered characters.
+   * @param startIndex the index at which to start taking characters from the buffer.
+   * @param count the number of characters used in the buffer.
+   * @return the characters in this StringBuilder
+   */
+  public static String toString(char[] value, int startIndex, int count)
+  {
+    try
+      {
+        return (String)
+          cons.newInstance(new Object[] { value, Integer.valueOf(startIndex),
+                                          Integer.valueOf(count),
+                                          Boolean.valueOf(true) });
+      }
+    catch (InstantiationException e)
+      {
+        throw (Error)
+          new InternalError("Could not instantiate no-copy String constructor").initCause(e);
+      }
+    catch (IllegalAccessException e)
+      {
+        throw (Error)
+          new InternalError("Could not access no-copy String constructor").initCause(e);
+      }
+    catch (InvocationTargetException e)
+      {
+        throw (Error)
+          new InternalError("Error calling no-copy String constructor").initCause(e);
+      }
+  }
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java
new file mode 100644
index 000000000..5501f0f7f
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java
@@ -0,0 +1,108 @@
+/* VMInstrumentationImpl.java -- interface for the GNU implementation
+   of InstrumentationImpl
+   Copyright (C) 2005  Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.lang;
+
+import java.lang.instrument.ClassDefinition;
+import java.lang.instrument.Instrumentation;
+
+/**
+ * @author Nicolas Geoffray (nicolas.geoffray@menlina.com)
+ * @since 1.5
+ */
+final class VMInstrumentationImpl
+{
+
+  /**
+   * Returns if the current JVM supports class redefinition
+   *
+   * @return true if the current JVM supports class redefinition
+   */
+  static native boolean isRedefineClassesSupported();
+
+  /**
+   * Redefines classes given as parameters. The method has to call
+   * the callTransformers from InstrumentationImpl
+   *
+   * @param inst an instrumentation object
+   * @param definitions an array of bytecode<->class correspondance
+   *
+   * @throws ClassNotFoundException if a class cannot be found
+   * @throws UnmodifiableClassException if a class cannot be modified
+   * @throws UnsupportedOperationException if the JVM does not support
+   * redefinition or the redefinition made unsupported changes
+   * @throws ClassFormatError if a class file is not valid
+   * @throws NoClassDefFoundError if a class name is not equal to the name
+   * in the class file specified
+   * @throws UnsupportedClassVersionError if the class file version numbers
+   * are unsupported
+   * @throws ClassCircularityError if circularity occured with the new
+   * classes
+   * @throws LinkageError if a linkage error occurs
+   */
+  static native void redefineClasses(Instrumentation inst,
+      ClassDefinition[] definitions);
+
+  /**
+   * Get all the classes loaded by the JVM.
+   *
+   * @return an array containing all the classes loaded by the JVM. The array
+   * is empty if no class is loaded.
+   */
+  static native Class[] getAllLoadedClasses();
+
+  /**
+   * Get all the classes loaded by a given class loader
+   *
+   * @param loader the loader
+   *
+   * @return an array containing all the classes loaded by the given loader.
+   * The array is empty if no class was loaded by the loader.
+   */
+  static native Class[] getInitiatedClasses(ClassLoader loader);
+
+  /**
+   * Get the size of an object. The object is not null
+   *
+   * @param objectToSize the object
+   * @return the size of the object
+   */
+  static native long getObjectSize(Object objectToSize);
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMClassLoadingMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMClassLoadingMXBeanImpl.java
new file mode 100644
index 000000000..ea4989741
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMClassLoadingMXBeanImpl.java
@@ -0,0 +1,89 @@
+/* VMClassLoadingMXBeanImpl.java - VM impl. of a class loading bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+/**
+ * Provides access to information about the class loading
+ * behaviour of the current invocation of the virtual
+ * machine.  Instances of this bean are obtained by calling
+ * {@link ManagementFactory#getClassLoadingMXBean()}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMClassLoadingMXBeanImpl
+{
+
+  /**
+   * Returns the number of classes currently loaded by
+   * the virtual machine.
+   *
+   * @return the number of loaded classes.
+   */
+  static native int getLoadedClassCount();
+
+  /**
+   * Returns the number of classes that have been unloaded
+   * by the virtual machine since it was started.
+   *
+   * @return the number of unloaded classes.
+   */
+  static native long getUnloadedClassCount();
+
+  /**
+   * Returns true if the virtual machine will emit additional
+   * information when classes are loaded and unloaded.  The
+   * format of the output is left up to the virtual machine.
+   *
+   * @return true if verbose class loading output is on.
+   */
+  static native boolean isVerbose();
+
+  /**
+   * Turns on or off the emission of additional information
+   * when classes are loaded and unloaded.  The format of the
+   * output is left up to the virtual machine.  This method
+   * may be called by multiple threads concurrently, but there
+   * is only one global setting of verbosity that is affected.
+   *
+   * @param verbose the new setting for verbose class loading
+   *                output.
+   */
+  static native void setVerbose(boolean verbose);
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMCompilationMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMCompilationMXBeanImpl.java
new file mode 100644
index 000000000..019af0ca4
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMCompilationMXBeanImpl.java
@@ -0,0 +1,66 @@
+/* VMCompilationMXBeanImpl.java - VM implementation of a compilation bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+/**
+ * Provides access to information about the JIT
+ * compiler of the virtual machine, if one exists.
+ * Instances of this bean are obtained by calling
+ * {@link ManagementFactory#getCompilationMXBean()},
+ * if this is the case.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMCompilationMXBeanImpl
+{
+
+  /**
+   * Returns the number of milliseconds the JIT
+   * compiler has spent compiling Java bytecode
+   * to native machine code.  This is only called
+   * if a JIT compiler exists and the
+   * gnu.java.lang.management.CompilationTimeSupport
+   * property has been set.
+   *
+   * @return the number of milliseconds spent
+   *         compiling.
+   */
+  static native long getTotalCompilationTime();
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java
new file mode 100644
index 000000000..00861bc21
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java
@@ -0,0 +1,80 @@
+/* VMGarbageCollectorMXBeanImpl.java - VM interface for a GC bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+/**
+ * Provides access to information about the garbage collectors
+ * of the virtual machine.  Garbage collectors are responsible
+ * for removing unreferenced objects from memory.  A garbage
+ * collector is a type of memory manager, so this interface
+ * is combined with that of generic memory managers.  An instance
+ * of this bean for each garbage collector is obtained by calling
+ * {@link ManagementFactory#getGarbageCollectorMXBeans()}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMGarbageCollectorMXBeanImpl
+{
+
+  /**
+   * Returns the number of collections the garbage collector
+   * represented by this bean has made.  -1 is returned if the
+   * collection count is undefined.
+   *
+   * @param name the name of the garbage collector.
+   * @return the number of collections made, or -1 if this is
+   *         undefined.
+   */
+  static native long getCollectionCount(String name);
+
+  /**
+   * Returns the accumulated number of milliseconds this garbage
+   * collector has spent freeing the memory used by unreferenced
+   * objects.  -1 is returned if the collection time is undefined.
+   * Note that the accumulated time may not change, even when the
+   * collection count increases, if the time taken is sufficiently
+   * short; this depends on the resolution of the timer used.
+   *
+   * @param name the name of the garbage collector.
+   * @return the accumulated number of milliseconds spent collecting,
+   *         or -1 if this is undefined.
+   */
+  static native long getCollectionTime(String name);
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryMXBeanImpl.java
new file mode 100644
index 000000000..7f69bdfb7
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryMXBeanImpl.java
@@ -0,0 +1,156 @@
+/* VMMemoryMXBeanImpl.java - VM impl. of a memory bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryType;
+import java.lang.management.MemoryUsage;
+
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Provides access to information about the memory
+ * management of the current invocation of the virtual
+ * machine.  Instances of this bean are obtained by calling
+ * {@link ManagementFactory#getMemoryMXBean()}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMMemoryMXBeanImpl
+{
+
+  /**
+   * Returns an instance of {@link java.lang.management.MemoryUsage}
+   * with appropriate initial, used, committed and maximum values
+   * for the heap.  By default, this uses the methods of
+   * {@link java.lang.Runtime} to provide some of the values.
+   *
+   * @return an {@link java.lang.management.MemoryUsage} instance
+   *         for the heap.
+   */
+  static MemoryUsage getHeapMemoryUsage()
+  {
+    return getUsage(MemoryType.HEAP);
+  }
+
+  /**
+   * Returns an instance of {@link java.lang.management.MemoryUsage}
+   * with appropriate initial, used, committed and maximum values
+   * for non-heap memory.
+   *
+   * @return an {@link java.lang.management.MemoryUsage} instance
+   *         for non-heap memory.
+   */
+  static MemoryUsage getNonHeapMemoryUsage()
+  {
+    return getUsage(MemoryType.NON_HEAP);
+  }
+
+  /**
+   * Returns the number of objects ready to be garbage collected.
+   *
+   * @return the number of finalizable objects.
+   */
+  static native int getObjectPendingFinalizationCount();
+
+  /**
+   * Returns true if the virtual machine will emit additional
+   * information when memory is allocated and deallocated.  The
+   * format of the output is left up to the virtual machine.
+   *
+   * @return true if verbose memory usage output is on.
+   */
+  static native boolean isVerbose();
+
+  /**
+   * Turns on or off the emission of additional information
+   * when memory is allocated and deallocated.  The format of the
+   * output is left up to the virtual machine.  This method
+   * may be called by multiple threads concurrently, but there
+   * is only one global setting of verbosity that is affected.
+   *
+   * @param verbose the new setting for verbose memory usage
+   *                output.
+   */
+  static native void setVerbose(boolean verbose);
+
+  /**
+   * Totals the memory usage from all the pools that match
+   * the given type.
+   *
+   * @param type the type of memory pools to accumulate
+   *             (heap or non-heap).
+   * @return the memory usage overall.
+   */
+  private static MemoryUsage getUsage(MemoryType type) {
+    long init = 0, committed = 0, used = 0, max = 0;
+    Iterator pools =
+      ManagementFactory.getMemoryPoolMXBeans().iterator();
+    while (pools.hasNext())
+      {
+        MemoryPoolMXBean pool = (MemoryPoolMXBean) pools.next();
+        if (pool.getType() == type)
+          {
+            MemoryUsage usage = pool.getUsage();
+            if (init != -1)
+              {
+                long poolInit = usage.getInit();
+                if (poolInit == -1)
+                  init = -1;
+                else
+                  init += poolInit;
+              }
+            committed += usage.getCommitted();
+            used += usage.getUsed();
+            if (max != -1)
+              {
+                long poolMax = usage.getMax();
+                if (poolMax == -1)
+                  max = -1;
+                else
+                  max += poolMax;
+              }
+          }
+      }
+    return new MemoryUsage(init, used, committed, max);
+  }
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java
new file mode 100644
index 000000000..477329f0a
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java
@@ -0,0 +1,95 @@
+/* VMMemoryManagerMXBeanImpl.java - VM interface for a memory manager bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryPoolMXBean;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Provides access to information about the memory managers
+ * of the virtual machine.  An instance of this bean for each
+ * memory manager is obtained by calling
+ * {@link ManagementFactory#getMemoryManagerMXBeans()}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMMemoryManagerMXBeanImpl
+{
+
+  /**
+   * Returns an array containing the names of the memory pools
+   * this memory manager manages.
+   *
+   * @param name the name of the memory manager.
+   * @return an array containing the name of each memory pool
+   *         this manager is responsible for.
+   */
+  static String[] getMemoryPoolNames(String name)
+  {
+    List managedPools = new ArrayList();
+    Iterator beans = ManagementFactory.getMemoryPoolMXBeans().iterator();
+    while (beans.hasNext())
+      {
+        MemoryPoolMXBean bean = (MemoryPoolMXBean) beans.next();
+        String[] managers = bean.getMemoryManagerNames();
+        for (int a = 0; a < managers.length; ++a)
+          if (managers[a].equals(name))
+            {
+              managedPools.add(bean.getName());
+              break;
+            }
+      }
+    return (String[]) managedPools.toArray(new String[managedPools.size()]);
+  }
+
+  /**
+   * Returns true if this memory manager is still valid.  A memory
+   * manager becomes invalid when it is removed by the virtual machine
+   * and no longer used.
+   *
+   * @param name the name of the memory manager.
+   * @return true if this memory manager is valid.
+   */
+  static native boolean isValid(String name);
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java
new file mode 100644
index 000000000..36cd2586a
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java
@@ -0,0 +1,195 @@
+/* MemoryPoolMXBeanImpl.java - VM interface for memory pool beans
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import java.lang.management.MemoryUsage;
+
+/**
+ * Provides access to information on the memory resources or
+ * pools used by the current invocation of the virtual machine.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMMemoryPoolMXBeanImpl
+{
+
+  /**
+   * Returns memory usage statistics for the specified pool
+   * just after a best-effort attempt to free memory.  This
+   * is valid only for certain garbage collectors.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return a {@link java.lang.management.MemoryUsage} object
+   *         containing the statistics or <code>null</code>
+   *         if this pool does not support such statistics.
+   */
+  static native MemoryUsage getCollectionUsage(String name);
+
+  /**
+   * Returns the collection usage threshold for the specified pool.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
+   * is defined).  The value is initially zero.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return the collection usage threshold.
+   */
+  static native long getCollectionUsageThreshold(String name);
+
+  /**
+   * Returns the number of times the collection usage threshold
+   * has been met or exceeded by the specified pool.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
+   * is defined).
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return the collection usage threshold count.
+   */
+  static native long getCollectionUsageThresholdCount(String name);
+
+  /**
+   * Returns an array of names of memory managers which manage
+   * the specified pool.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return a list of memory managers for the pool.
+   */
+  static native String[] getMemoryManagerNames(String name);
+
+  /**
+   * Returns the peak usage level of the specified pool.
+   * This is only called if the pool is valid.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return a {@link java.lang.management.MemoryUsage} object
+   *         containing the statistics.
+   */
+  static native MemoryUsage getPeakUsage(String name);
+
+  /**
+   * Returns the type of memory used by the specified pool.
+   * The value must be either "HEAP" or "NON_HEAP".
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return the type of the given pool.
+   */
+  static native String getType(String name);
+
+  /**
+   * Returns the current usage level of the specified pool.
+   * This is only called if the pool is valid.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return a {@link java.lang.management.MemoryUsage} object
+   *         containing the statistics.
+   */
+  static native MemoryUsage getUsage(String name);
+
+  /**
+   * Returns the usage threshold for the specified pool.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.UsageThresholdSupport</code>,
+   * is defined).  The value is initially defined by the
+   * virtual machine.
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return the usage threshold.
+   */
+  static native long getUsageThreshold(String name);
+
+  /**
+   * Returns the number of times the usage threshold
+   * has been met or exceeded by the specified pool.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.UsageThresholdSupport</code>,
+   * is defined).
+   *
+   * @param name the name of the pool to obtain statistics on.
+   * @return the usage threshold count.
+   */
+  static native long getUsageThresholdCount(String name);
+
+  /**
+   * Returns true if the specified pool is still valid i.e.
+   * it is still in use by the virtual machine.
+   *
+   * @param name the name of the pool to check the validity of.
+   * @return true if the pool is valid.
+   */
+  static native boolean isValid(String name);
+
+  /**
+   * Resets the peak usage level to the current usage level for
+   * the specified pool.
+   *
+   * @param name the name of the pool to reset the peak usage of.
+   */
+  static native void resetPeakUsage(String name);
+
+  /**
+   * Sets the collection usage threshold for the specified
+   * pool to the supplied value.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
+   * is defined).
+   *
+   * @param name the name of the pool to set the threshold of.
+   * @param threshold the new threshold level.
+   */
+  static native void setCollectionUsageThreshold(String name, long threshold);
+
+  /**
+   * Sets the usage threshold for the specified pool to the supplied value.
+   * This is only called if this functionality is supported
+   * by the virtual machine (i.e. the appropriate property,
+   * <code>gnu.java.lang.management.UsageThresholdSupport</code>,
+   * is defined).
+   *
+   * @param name the name of the pool to set the threshold of.
+   * @param threshold the new threshold level.
+   */
+  static native void setUsageThreshold(String name, long threshold);
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java
new file mode 100644
index 000000000..20b3f9ed2
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java
@@ -0,0 +1,68 @@
+/* VMOperatingSystemMXBeanImpl.java - VM implementation of an OS bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import gnu.classpath.Configuration;
+
+/**
+ * Provides access to information about the operating system.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+final class VMOperatingSystemMXBeanImpl
+{
+
+  static
+  {
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary("javalangmanagement");
+      }
+  }
+
+  /**
+   * Returns the system load average from the last
+   * minute.
+   *
+   * @return the system load average from the last
+   *         minute.
+   */
+  static native double getSystemLoadAverage();
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMRuntimeMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMRuntimeMXBeanImpl.java
new file mode 100644
index 000000000..32a866046
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMRuntimeMXBeanImpl.java
@@ -0,0 +1,89 @@
+/* VMRuntimeMXBeanImpl.java - VM implementation of an runtime bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import gnu.classpath.SystemProperties;
+
+/**
+ * Provides access to information about the virtual machine.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMRuntimeMXBeanImpl
+{
+
+  /**
+   * Returns the command-line arguments supplied
+   * to the virtual machine, excluding those supplied
+   * to <code>main()</code>.
+   *
+   * @return the command-line arguments.
+   */
+  static native String[] getInputArguments();
+
+  /**
+   * Returns a developer-chosen name for the virtual
+   * machine, which may differ over different running
+   * instances of the same virtual machine binary.
+   * For example, this may include the particular
+   * process identifier used by this instance or
+   * the host name of the machine on which it is
+   * running.  The intention is that this name refers
+   * to the precise entity that the other data supplied
+   * by the bean refers to, rather than the VM in general.
+   *
+   * @return the custom name of the VM.
+   */
+  static String getName()
+  {
+    return SystemProperties.getProperty("java.vm.name") + " " +
+      SystemProperties.getProperty("java.vm.version");
+  }
+
+  /**
+   * The time in milliseconds at which the virtual
+   * machine was started.  This method is only executed
+   * once (for efficency), as the value is not expected
+   * to change.
+   *
+   * @return the VM start time.
+   */
+  static native long getStartTime();
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/lang/management/VMThreadMXBeanImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/management/VMThreadMXBeanImpl.java
new file mode 100644
index 000000000..33448d9d5
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/lang/management/VMThreadMXBeanImpl.java
@@ -0,0 +1,236 @@
+/* VMThreadMXBeanImpl.java - VM impl. of a thread bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import java.lang.management.ThreadInfo;
+
+/**
+ * Provides access to information about the threads
+ * of the virtual machine.  An instance of this bean is
+ * obtained by calling
+ * {@link ManagementFactory#getThreadMXBean()}.
+ * See {@link java.lang.management.ThreadMXBean} for
+ * full documentation.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+final class VMThreadMXBeanImpl
+{
+
+  /**
+   * Cache of how many threads were found.
+   */
+  private static int filled;
+
+  /**
+   * Returns the ids of cycles of deadlocked threads, occurring
+   * due to monitor ownership or ownable synchronizer ownership.
+   * This will only be called if ownable synchronizer monitoring
+   * is supported.
+   *
+   * @return the ids of the deadlocked threads.
+   */
+  static native long[] findDeadlockedThreads();
+
+  /**
+   * Returns the ids of cycles of deadlocked threads, occurring
+   * due to monitor ownership.
+   *
+   * @return the ids of the deadlocked threads.
+   */
+  static native long[] findMonitorDeadlockedThreads();
+
+  /* This is the same as in Thread.getAllStackTraces() */
+  static Thread[] getAllThreads()
+  {
+    ThreadGroup group = Thread.currentThread().getThreadGroup();
+    while (group.getParent() != null)
+      group = group.getParent();
+    int arraySize = group.activeCount();
+    Thread[] threadList = new Thread[arraySize];
+    filled = group.enumerate(threadList);
+    while (filled == arraySize)
+      {
+        arraySize *= 2;
+        threadList = new Thread[arraySize];
+        filled = group.enumerate(threadList);
+      }
+    return threadList;
+  }
+
+  /**
+   * Returns the id of all live threads at the time of execution.
+   *
+   * @return the live thread ids.
+   */
+  static long[] getAllThreadIds()
+  {
+    Thread[] threadList = getAllThreads();
+    long[] ids = new long[filled];
+    for (int a = 0; a < filled; ++a)
+      ids[a] = threadList[a].getId();
+    return ids;
+  }
+
+  /**
+   * Returns the number of nanoseconds of CPU time
+   * the current thread has used in total.   This is
+   * only called if this feature is enabled and
+   * supported.
+   *
+   * @return the nanoseconds of CPU time used by
+   *         the current thread.
+   */
+  static native long getCurrentThreadCpuTime();
+
+  /**
+   * Returns the number of nanoseconds of user time
+   * the current thread has used in total.   This is
+   * only called if this feature is enabled and
+   * supported.
+   *
+   * @return the nanoseconds of user time used by
+   *         the current thread.
+   */
+  static native long getCurrentThreadUserTime();
+
+  /**
+   * Returns the number of live daemon threads.
+   *
+   * @return the number of live daemon threads.
+   */
+  static int getDaemonThreadCount()
+  {
+    Thread[] threadList = getAllThreads();
+    int daemonCount = 0;
+    for (int a = 0; a < filled; ++a)
+      {
+        if (threadList[a].isDaemon())
+          ++daemonCount;
+      }
+    return daemonCount;
+  }
+
+  /**
+   * Fill out the given {@link ThreadInfo} object
+   * with ownable synchronizer usage information.
+   * This is only called if ownable synchronizer
+   * usage monitoring is supported.
+   *
+   * @param info the {@link ThreadInfo} object to modify.
+   */
+  static native void getLockInfo(ThreadInfo info);
+
+  /**
+   * Fill out the given {@link ThreadInfo} object
+   * with monitor usage information.  This is only
+   * called if monitor usage monitoring is supported.
+   *
+   * @param info the {@link ThreadInfo} object to modify.
+   */
+  static native void getMonitorInfo(ThreadInfo info);
+
+  /**
+   * Returns the current peak number of live threads.
+   *
+   * @return the peak number of live threads.
+   */
+  static native int getPeakThreadCount();
+
+  /**
+   * Returns the number of live threads.
+   *
+   * @return the number of live threads.
+   */
+  static int getThreadCount()
+  {
+    getAllThreads();
+    return filled;
+  }
+
+  /**
+   * Returns the number of nanoseconds of CPU time
+   * the specified thread has used in total.   This is
+   * only called if this feature is enabled and
+   * supported.
+   *
+   * @param id the thread to obtain statistics on.
+   * @return the nanoseconds of CPU time used by
+   *         the thread.
+   */
+  static native long getThreadCpuTime(long id);
+
+  /**
+   * Returns the {@link java.lang.management.ThreadInfo}
+   * which corresponds to the specified id.
+   *
+   * @param id the id of the thread.
+   * @param maxDepth the depth of the stack trace.
+   * @return the corresponding <code>ThreadInfo</code>.
+   */
+  static native ThreadInfo getThreadInfoForId(long id, int maxDepth);
+
+  /**
+   * Returns the number of nanoseconds of user time
+   * the specified thread has used in total.   This is
+   * only called if this feature is enabled and
+   * supported.
+   *
+   * @param id the thread to obtain statistics on.
+   * @return the nanoseconds of user time used by
+   *         the thread.
+   */
+  static native long getThreadUserTime(long id);
+
+  /**
+   * Returns the total number of threads that have
+   * been started over the lifetime of the virtual
+   * machine.
+   *
+   * @return the total number of threads started.
+   */
+  static native long getTotalStartedThreadCount();
+
+  /**
+   * Resets the peak thread count to the current
+   * number of live threads.
+   */
+  static native void resetPeakThreadCount();
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/net/VMPlainDatagramSocketImpl.java b/libjava/classpath/vm/reference/gnu/java/net/VMPlainDatagramSocketImpl.java
new file mode 100644
index 000000000..da0f893cf
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/net/VMPlainDatagramSocketImpl.java
@@ -0,0 +1,260 @@
+/* PlainDatagramSocketImpl.java -- VM interface for DatagramSocket impl
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.net;
+
+import gnu.classpath.Configuration;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketAddress;
+import java.net.SocketException;
+
+/**
+ * The VM interface for {@link gnu.java.net.PlainDatagramSocketImpl}.
+ *
+ * @author Ingo Proetel (proetel@aicas.com)
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public final class VMPlainDatagramSocketImpl
+{
+  /**
+   * Option id for the IP_TTL (time to live) value.
+   */
+  static final int IP_TTL = 0x1E61; // 7777
+
+
+  // Static initializer to load native library
+  static
+  {
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary("javanet");
+      }
+  }
+
+  /**
+   * Binds this socket to a particular port and interface
+   *
+   * @param socket the socket object
+   * @param port the port to bind to
+   * @param addr the address to bind to
+   *
+   * @throws SocketException If an error occurs
+   */
+  static native void bind(PlainDatagramSocketImpl socket, int port,
+                          InetAddress addr)
+    throws SocketException;
+
+  /**
+   * Creates a new datagram socket.
+   *
+   * @param socket the socket object
+   *
+   * @throws SocketException If an error occurs
+   */
+  static native void create(PlainDatagramSocketImpl socket)
+    throws SocketException;
+
+  /**
+   * Connects to the remote address and port specified as arguments.
+   *
+   * @param socket the socket object
+   * @param addr the remote address to connect to
+   * @param port the remote port to connect to
+   *
+   * @throws SocketException If an error occurs
+   */
+  static native void connect(PlainDatagramSocketImpl socket, InetAddress addr,
+                             int port)
+    throws SocketException;
+
+  /**
+   * Sends a packet of data to a remote host.
+   *
+   * @param socket the socket object
+   * @param packet the packet to send
+   *
+   * @throws IOException If an error occurs
+   */
+  static void send(PlainDatagramSocketImpl socket, DatagramPacket packet)
+    throws IOException
+  {
+    nativeSendTo(socket, packet.getAddress(), packet.getPort(),
+                 packet.getData(), packet.getOffset(), packet.getLength());
+  }
+
+
+  /**
+   * Sends a packet of data to a remote host.
+   *
+   * @param socket the socket object
+   * @param addr the address to send to
+   * @param port the port to send to
+   * @param buf the buffer to send
+   * @param offset the offset of the data in the buffer to send
+   * @param len the length of the data to send
+   *
+   * @throws IOException If an error occurs
+   */
+  private static native void nativeSendTo(PlainDatagramSocketImpl socket,
+                                          InetAddress addr, int port,
+                                          byte[] buf, int offset, int len)
+    throws IOException;
+
+  /**
+   * Receives a UDP packet from the network
+   *
+   * @param socket the socket object
+   * @param packet the packet to fill in with the data received
+   *
+   * @throws IOException IOException If an error occurs
+   */
+  static void receive(PlainDatagramSocketImpl socket, DatagramPacket packet)
+    throws IOException
+  {
+    byte[] receiveFromAddress = new byte[4];
+    int[] receiveFromPort = new int[1];
+    int[] receivedLength = new int[1];
+
+    nativeReceive(socket, packet.getData(), packet.getOffset(),
+                  packet.getLength(),
+                  receiveFromAddress, receiveFromPort, receivedLength);
+
+    packet.setAddress(InetAddress.getByAddress(receiveFromAddress));
+    packet.setPort(receiveFromPort[0]);
+    packet.setLength(receivedLength[0]);
+  }
+
+  private static native void nativeReceive(PlainDatagramSocketImpl socket,
+                                           byte[] buf, int offset, int len,
+                                           byte[] receiveFromAddress,
+                                           int[] receiveFromPort,
+                                           int[] receivedLength)
+    throws IOException;
+
+  /**
+   * Sets the value of an option on the socket
+   *
+   * @param socket the socket object
+   * @param optionId the identifier of the option to set
+   * @param value the value of the option to set
+   *
+   * @exception SocketException If an error occurs
+   */
+  static native void setOption(PlainDatagramSocketImpl socket, int optionId,
+                               Object value)
+    throws SocketException;
+
+  /**
+   * Retrieves the value of an option on the socket.
+   *
+   * @param socket the socket object
+   * @param optionId the identifier of the option to retrieve
+   *
+   * @return the value of the option
+   *
+   * @throws SocketException if an error occurs
+   */
+  static native Object getOption(PlainDatagramSocketImpl socket, int optionId)
+    throws SocketException;
+
+  /**
+   * Closes the socket.
+   *
+   * @param socket the socket object
+   */
+  static native void close(PlainDatagramSocketImpl socket);
+
+  /**
+   * Joins a multicast group
+   *
+   * @param addr The group to join
+   *
+   * @exception IOException If an error occurs
+   */
+  static native void join(PlainDatagramSocketImpl socket, InetAddress addr)
+    throws IOException;
+
+  /**
+   * Leaves a multicast group
+   *
+   * @param addr The group to leave
+   *
+   * @exception IOException If an error occurs
+   */
+  static native void leave(PlainDatagramSocketImpl socket, InetAddress addr)
+    throws IOException;
+
+  /**
+   * Joins a multicast group.
+   *
+   * @param socket the socket object
+   * @param address the socket address
+   * @param netIf the network interface
+   *
+   * @throws IOException if I/O errors occur
+   */
+  static void joinGroup(PlainDatagramSocketImpl socket, SocketAddress address,
+                        NetworkInterface netIf)
+    throws IOException
+  {
+    throw new InternalError
+      ("PlainDatagramSocketImpl::joinGroup is not implemented");
+  }
+
+  /**
+   * Leaves a multicast group.
+   *
+   * @param socket the socket object
+   * @param address the socket address
+   * @param netIf the network interface
+   *
+   * @throws IOException if I/O errors occur
+   */
+  static void leaveGroup(PlainDatagramSocketImpl socket, SocketAddress address,
+                         NetworkInterface netIf)
+    throws IOException
+  {
+    throw new InternalError
+      ("PlainDatagramSocketImpl::leaveGroup is not implemented");
+  }
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/net/VMPlainSocketImpl.java b/libjava/classpath/vm/reference/gnu/java/net/VMPlainSocketImpl.java
new file mode 100644
index 000000000..c72e6a5eb
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/net/VMPlainSocketImpl.java
@@ -0,0 +1,511 @@
+/* VMPlainSocketImpl.java -- VM interface for default socket implementation
+   Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.net;
+
+import java.io.IOException;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.SocketOptions;
+
+import gnu.classpath.Configuration;
+import gnu.java.nio.VMChannel;
+
+/**
+ * The VM interface for {@link gnu.java.net.PlainSocketImpl}.
+ *
+ * @author Ingo Proetel (proetel@aicas.com)
+ * @author Roman Kennke (kennke@aicas.com)
+ */
+public final class VMPlainSocketImpl
+{
+  /** Option id for time to live
+   */
+  private static final int CP_IP_TTL = 0x1E61;
+
+  private final State nfd;
+
+  /**
+   * Static initializer to load native library.
+   */
+  static
+  {
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary("javanet");
+      }
+  }
+
+  public VMPlainSocketImpl()
+  {
+    // XXX consider adding security check here.
+    nfd = new State();
+  }
+
+  public VMPlainSocketImpl(VMChannel channel) throws IOException
+  {
+    this();
+    nfd.setChannelFD(channel.getState());
+  }
+
+  public State getState()
+  {
+    return nfd;
+  }
+
+  /** This method exists to hide the CP_IP_TTL value from
+   * higher levels.
+   *
+   * Always think of JNode ... :)
+   */
+  public void setTimeToLive(int ttl)
+    throws SocketException
+  {
+    try
+      {
+        setOption(nfd.getNativeFD(), CP_IP_TTL, ttl);
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+  }
+
+  public int getTimeToLive()
+    throws SocketException
+  {
+    try
+      {
+        return getOption(nfd.getNativeFD(), CP_IP_TTL);
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+  }
+
+  public void setOption(int optionId, Object optionValue)
+    throws SocketException
+  {
+    int value;
+    if (optionValue instanceof Integer)
+      value = ((Integer) optionValue).intValue();
+    else if (optionValue instanceof Boolean)
+      // Switching off the linger behavior is done by setting
+      // the value to -1. This is how the Java API interprets
+      // it.
+      value = ((Boolean) optionValue).booleanValue()
+              ? 1
+              : (optionId == SocketOptions.SO_LINGER)
+              ? -1
+              : 0;
+    else
+      throw new IllegalArgumentException("option value type "
+                                         + optionValue.getClass().getName());
+
+    try
+      {
+        setOption(nfd.getNativeFD(), optionId, value);
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+  }
+
+  private static native void setOption(int fd, int id, int value)
+    throws SocketException;
+
+  public void setMulticastInterface(int optionId, InetAddress addr)
+    throws SocketException
+  {
+    try
+      {
+        if (addr instanceof Inet4Address)
+          setMulticastInterface(nfd.getNativeFD(), optionId, (Inet4Address) addr);
+        else if (addr instanceof Inet6Address)
+          {
+            NetworkInterface iface = NetworkInterface.getByInetAddress(addr);
+            setMulticastInterface6(nfd.getNativeFD(), optionId, iface.getName());
+          }
+        else
+          throw new SocketException("Unknown address format: " + addr);
+      }
+    catch (SocketException se)
+      {
+        throw se;
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+  }
+
+  private static native void setMulticastInterface(int fd,
+                                                   int optionId,
+                                                   Inet4Address addr);
+
+  private static native void setMulticastInterface6(int fd,
+                                                    int optionId,
+                                                    String ifName);
+
+  /**
+   * Get a socket option. This implementation is only required to support
+   * socket options that are boolean values, which include:
+   *
+   *  SocketOptions.IP_MULTICAST_LOOP
+   *  SocketOptions.SO_BROADCAST
+   *  SocketOptions.SO_KEEPALIVE
+   *  SocketOptions.SO_OOBINLINE
+   *  SocketOptions.SO_REUSEADDR
+   *  SocketOptions.TCP_NODELAY
+   *
+   * and socket options that are integer values, which include:
+   *
+   *  SocketOptions.IP_TOS
+   *  SocketOptions.SO_LINGER
+   *  SocketOptions.SO_RCVBUF
+   *  SocketOptions.SO_SNDBUF
+   *  SocketOptions.SO_TIMEOUT
+   *
+   * @param optionId The option ID to fetch.
+   * @return A {@link Boolean} or {@link Integer} containing the socket
+   *  option.
+   * @throws SocketException
+   */
+  public Object getOption(int optionId) throws SocketException
+  {
+    int value;
+    try
+      {
+        value = getOption(nfd.getNativeFD(), optionId);
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+
+    switch (optionId)
+      {
+        case SocketOptions.IP_MULTICAST_LOOP:
+        case SocketOptions.SO_BROADCAST:
+        case SocketOptions.SO_KEEPALIVE:
+        case SocketOptions.SO_OOBINLINE:
+        case SocketOptions.SO_REUSEADDR:
+        case SocketOptions.TCP_NODELAY:
+          return Boolean.valueOf(value != 0);
+
+        case SocketOptions.IP_TOS:
+        case SocketOptions.SO_LINGER:
+        case SocketOptions.SO_RCVBUF:
+        case SocketOptions.SO_SNDBUF:
+        case SocketOptions.SO_TIMEOUT:
+          return new Integer(value);
+
+        default:
+          throw new SocketException("getting option " + optionId +
+                                    " not supported here");
+      }
+  }
+
+  private static native int getOption(int fd, int id) throws SocketException;
+
+  /**
+   * Returns an Inet4Address or Inet6Address instance belonging to the
+   * interface which is set as the multicast interface.
+   *
+   * The optionId is provided to make it possible that the native
+   * implementation may do something different depending on whether
+   * the value is SocketOptions.IP_MULTICAST_IF or
+   * SocketOptions.IP_MULTICAST_IF2.
+   */
+  public InetAddress getMulticastInterface(int optionId)
+    throws SocketException
+  {
+    try
+      {
+        return getMulticastInterface(nfd.getNativeFD(), optionId);
+      }
+    catch (IOException ioe)
+      {
+        SocketException se = new SocketException();
+        se.initCause(ioe);
+        throw se;
+      }
+  }
+
+  private static native InetAddress getMulticastInterface(int fd,
+                                                          int optionId);
+
+  /**
+   * Binds this socket to the given local address and port.
+   *
+   * @param address The address to bind to; the InetAddress is either
+   *  an IPv4 or IPv6 address.
+   * @throws IOException If binding fails; for example, if the port
+   *  in the given InetSocketAddress is privileged, and the current
+   *  process has insufficient privileges.
+   */
+  public void bind(InetSocketAddress address) throws IOException
+  {
+    InetAddress addr = address.getAddress();
+    if (addr instanceof Inet4Address)
+      {
+        bind (nfd.getNativeFD(), addr.getAddress(), address.getPort());
+      }
+    else if (addr instanceof Inet6Address)
+      bind6 (nfd.getNativeFD(), addr.getAddress(), address.getPort());
+    else
+      throw new SocketException ("unsupported address type");
+  }
+
+  /**
+   * Native bind function for IPv4 addresses. The addr array must be
+   * exactly four bytes long.
+   *
+   * VMs without native support need not implement this.
+   *
+   * @param fd The native file descriptor integer.
+   * @param addr The IPv4 address, in network byte order.
+   * @param port The port to bind to.
+   * @throws IOException
+   */
+  private static native void bind(int fd, byte[] addr, int port)
+    throws IOException;
+
+  /**
+   * Native bind function for IPv6 addresses. The addr array must be
+   * exactly sixteen bytes long.
+   *
+   * VMs without native support need not implement this.
+   *
+   * @param fd The native file descriptor integer.
+   * @param addr The IPv6 address, in network byte order.
+   * @param port The port to bind to.
+   * @throws IOException
+   */
+  private static native void bind6(int fd, byte[] addr, int port)
+    throws IOException;
+
+  /**
+   * Listen on this socket for incoming connections.
+   *
+   * @param backlog The backlog of connections.
+   * @throws IOException If listening fails.
+   * @see gnu.java.nio.VMChannel#accept()
+   */
+  public void listen(int backlog) throws IOException
+  {
+    listen(nfd.getNativeFD(), backlog);
+  }
+
+  /**
+   * Native listen function. VMs without native support need not implement
+   * this.
+   *
+   * @param fd The file descriptor integer.
+   * @param backlog The listen backlog size.
+   * @throws IOException
+   */
+  private static native void listen(int fd, int backlog) throws IOException;
+
+  public void join(InetAddress group) throws IOException
+  {
+    if (group instanceof Inet4Address)
+      join(nfd.getNativeFD(), group.getAddress());
+    else if (group instanceof Inet6Address)
+      join6(nfd.getNativeFD(), group.getAddress());
+    else
+      throw new IllegalArgumentException("unknown address type");
+  }
+
+  private static native void join(int fd, byte[] addr) throws IOException;
+
+  private static native void join6(int fd, byte[] addr) throws IOException;
+
+  public void leave(InetAddress group) throws IOException
+  {
+    if (group instanceof Inet4Address)
+      leave(nfd.getNativeFD(), group.getAddress());
+    else if (group instanceof Inet6Address)
+      leave6(nfd.getNativeFD(), group.getAddress());
+    else
+      throw new IllegalArgumentException("unknown address type");
+  }
+
+  private static native void leave(int fd, byte[] addr) throws IOException;
+
+  private static native void leave6(int fd, byte[] addr) throws IOException;
+
+  public void joinGroup(InetSocketAddress addr, NetworkInterface netif)
+    throws IOException
+  {
+    InetAddress address = addr.getAddress();
+
+    if (address instanceof Inet4Address)
+      joinGroup(nfd.getNativeFD(), address.getAddress(),
+                netif != null ? netif.getName() : null);
+    else if (address instanceof Inet6Address)
+      joinGroup6(nfd.getNativeFD(), address.getAddress(),
+                 netif != null ? netif.getName() : null);
+    else
+      throw new IllegalArgumentException("unknown address type");
+  }
+
+  private static native void joinGroup(int fd, byte[] addr, String ifname)
+    throws IOException;
+
+  private static native void joinGroup6(int fd, byte[] addr, String ifname)
+    throws IOException;
+
+  public void leaveGroup(InetSocketAddress addr, NetworkInterface netif)
+    throws IOException
+  {
+    InetAddress address = addr.getAddress();
+    if (address instanceof Inet4Address)
+      leaveGroup(nfd.getNativeFD(), address.getAddress(),
+                 netif != null ? netif.getName() : null);
+    else if (address instanceof Inet6Address)
+      leaveGroup6(nfd.getNativeFD(), address.getAddress(),
+                 netif != null ? netif.getName() : null);
+    else
+      throw new IllegalArgumentException("unknown address type");
+  }
+
+  private static native void leaveGroup(int fd, byte[] addr, String ifname)
+    throws IOException;
+
+  private static native void leaveGroup6(int fd, byte[] addr, String ifname)
+    throws IOException;
+
+
+  public void shutdownInput() throws IOException
+  {
+    shutdownInput(nfd.getNativeFD());
+  }
+
+  private static native void shutdownInput(int native_fd) throws IOException;
+
+  public void shutdownOutput() throws IOException
+  {
+    shutdownOutput(nfd.getNativeFD());
+  }
+
+  private static native void shutdownOutput(int native_fd) throws IOException;
+
+  public void sendUrgentData(int data) throws IOException
+  {
+    sendUrgentData(nfd.getNativeFD(), data);
+  }
+
+  private static native void sendUrgentData(int natfive_fd, int data) throws IOException;
+
+  public void close() throws IOException
+  {
+    nfd.close();
+  }
+
+  // Inner classes.
+
+  /**
+   * Our wrapper for the native file descriptor. In this implementation,
+   * it is a simple wrapper around {@link VMChannel.State}, to simplify
+   * management of the native state.
+   */
+  public final class State
+  {
+    private VMChannel.State channelFd;
+
+    State()
+    {
+      channelFd = null;
+    }
+
+    public boolean isValid()
+    {
+      if (channelFd != null)
+        return channelFd.isValid();
+      return false;
+    }
+
+    public int getNativeFD() throws IOException
+    {
+      return channelFd.getNativeFD();
+    }
+
+    public void setChannelFD(final VMChannel.State nfd) throws IOException
+    {
+      if (this.channelFd != null && this.channelFd.isValid())
+        throw new IOException("file descriptor already initialized");
+      this.channelFd = nfd;
+    }
+
+    public void close() throws IOException
+    {
+      if (channelFd == null)
+        throw new IOException("invalid file descriptor");
+      channelFd.close();
+    }
+
+    protected void finalize() throws Throwable
+    {
+      try
+        {
+          if (isValid())
+            close();
+        }
+      finally
+        {
+          super.finalize();
+        }
+    }
+  }
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/nio/VMChannel.java b/libjava/classpath/vm/reference/gnu/java/nio/VMChannel.java
new file mode 100644
index 000000000..4494ff13c
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/nio/VMChannel.java
@@ -0,0 +1,749 @@
+/* VMChannel.java -- Native interface suppling channel operations.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.nio;
+
+import gnu.classpath.Configuration;
+
+import java.io.IOException;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+
+/**
+ * Native interface to support configuring of channel to run in a non-blocking
+ * manner and support scatter/gather io operations.
+ *
+ * @author Michael Barker <mike@middlesoft.co.uk>
+ *
+ */
+public final class VMChannel
+{
+  /**
+   * Our reference implementation uses an integer to store the native
+   * file descriptor. Implementations without such support
+   */
+  private final State nfd;
+
+  private Kind kind;
+
+  public VMChannel()
+  {
+    // XXX consider adding security check here, so only Classpath
+    // code may create instances.
+    this.nfd = new State();
+    kind = Kind.OTHER;
+  }
+
+  /**
+   * This constructor is used by the POSIX reference implementation;
+   * other virtual machines need not support it.
+   *
+   * <strong>Important:</strong> do not call this in library code that is
+   * not specific to Classpath's reference implementation.
+   *
+   * @param native_fd The native file descriptor integer.
+   * @throws IOException
+   */
+  VMChannel(final int native_fd) throws IOException
+  {
+    this();
+    this.nfd.setNativeFD(native_fd);
+  }
+
+  public State getState()
+  {
+    return nfd;
+  }
+
+  static
+  {
+    // load the shared library needed for native methods.
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary ("javanio");
+      }
+    initIDs();
+  }
+
+  public static VMChannel getStdin() throws IOException
+  {
+    return new VMChannel(stdin_fd());
+  }
+
+  public static VMChannel getStdout() throws IOException
+  {
+    return new VMChannel(stdout_fd());
+  }
+
+  public static VMChannel getStderr() throws IOException
+  {
+    return new VMChannel(stderr_fd());
+  }
+
+  private static native int stdin_fd();
+  private static native int stdout_fd();
+  private static native int stderr_fd();
+
+  /**
+   * Set the file descriptor to have the required blocking
+   * setting.
+   *
+   * @param blocking The blocking flag to set.
+   */
+  public void setBlocking(boolean blocking) throws IOException
+  {
+    setBlocking(nfd.getNativeFD(), blocking);
+  }
+
+  private static native void setBlocking(int fd, boolean blocking)
+    throws IOException;
+
+  public int available() throws IOException
+  {
+    return available(nfd.getNativeFD());
+  }
+
+  private static native int available(int native_fd) throws IOException;
+
+  /**
+   * Reads a byte buffer directly using the supplied file descriptor.
+   *
+   * @param dst Direct Byte Buffer to read to.
+   * @return Number of bytes read.
+   * @throws IOException If an error occurs or dst is not a direct buffers.
+   */
+  public int read(ByteBuffer dst)
+    throws IOException
+  {
+    return read(nfd.getNativeFD(), dst);
+  }
+
+  private static native int read(int fd, ByteBuffer dst) throws IOException;
+
+  /**
+   * Read a single byte.
+   *
+   * @return The byte read, or -1 on end of file.
+   * @throws IOException
+   */
+  public int read() throws IOException
+  {
+    return read(nfd.getNativeFD());
+  }
+
+  private static native int read(int fd) throws IOException;
+
+  /**
+   * Reads into byte buffers directly using the supplied file descriptor.
+   * Assumes that the buffer list contains DirectBuffers.  Will perform a
+   * scattering read.
+   *
+   * @param dsts An array direct byte buffers.
+   * @param offset Index of the first buffer to read to.
+   * @param length The number of buffers to read to.
+   * @return Number of bytes read.
+   * @throws IOException If an error occurs or the dsts are not direct buffers.
+   */
+  public long readScattering(ByteBuffer[] dsts, int offset, int length)
+    throws IOException
+  {
+    if (offset + length > dsts.length)
+      throw new IndexOutOfBoundsException("offset + length > dsts.length");
+
+    return readScattering(nfd.getNativeFD(), dsts, offset, length);
+  }
+
+  private static native long readScattering(int fd, ByteBuffer[] dsts,
+                                            int offset, int length)
+    throws IOException;
+
+  /**
+   * Receive a datagram on this channel, returning the host address
+   * that sent the datagram.
+   *
+   * @param dst Where to store the datagram.
+   * @return The host address that sent the datagram.
+   * @throws IOException
+   */
+  public SocketAddress receive(ByteBuffer dst) throws IOException
+  {
+    if (kind != Kind.SOCK_DGRAM)
+      throw new SocketException("not a datagram socket");
+    ByteBuffer hostPort = ByteBuffer.allocateDirect(18);
+    int hostlen = receive(nfd.getNativeFD(), dst, hostPort);
+    if (hostlen == 0)
+      return null;
+    if (hostlen == 4) // IPv4
+      {
+        byte[] addr = new byte[4];
+        hostPort.get(addr);
+        int port = hostPort.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
+      }
+    if (hostlen == 16) // IPv6
+      {
+        byte[] addr = new byte[16];
+        hostPort.get(addr);
+        int port = hostPort.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
+      }
+
+    throw new SocketException("host address received with invalid length: "
+                              + hostlen);
+  }
+
+  private static native int receive (int fd, ByteBuffer dst, ByteBuffer address)
+    throws IOException;
+
+  /**
+   * Writes from a direct byte bufer using the supplied file descriptor.
+   * Assumes the buffer is a DirectBuffer.
+   *
+   * @param src The source buffer.
+   * @return Number of bytes written.
+   * @throws IOException
+   */
+  public int write(ByteBuffer src) throws IOException
+  {
+    return write(nfd.getNativeFD(), src);
+  }
+
+  private native int write(int fd, ByteBuffer src) throws IOException;
+
+  /**
+   * Writes from byte buffers directly using the supplied file descriptor.
+   * Assumes the that buffer list constains DirectBuffers.  Will perform
+   * as gathering write.
+   *
+   * @param srcs
+   * @param offset
+   * @param length
+   * @return Number of bytes written.
+   * @throws IOException
+   */
+  public long writeGathering(ByteBuffer[] srcs, int offset, int length)
+    throws IOException
+  {
+    if (offset + length > srcs.length)
+      throw new IndexOutOfBoundsException("offset + length > srcs.length");
+
+    // A gathering write is limited to 16 buffers; when writing, ensure
+    // that we have at least one buffer with something in it in the 16
+    // buffer window starting at offset.
+    while (!srcs[offset].hasRemaining() && offset < srcs.length)
+      offset++;
+
+    // There are no buffers with anything to write.
+    if (offset == srcs.length)
+      return 0;
+
+    // If we advanced `offset' so far that we don't have `length'
+    // buffers left, reset length to only the remaining buffers.
+    if (length > srcs.length - offset)
+      length = srcs.length - offset;
+
+    return writeGathering(nfd.getNativeFD(), srcs, offset, length);
+  }
+
+  private native long writeGathering(int fd, ByteBuffer[] srcs,
+                                     int offset, int length)
+    throws IOException;
+
+  /**
+   * Send a datagram to the given address.
+   *
+   * @param src The source buffer.
+   * @param dst The destination address.
+   * @return The number of bytes written.
+   * @throws IOException
+   */
+  public int send(ByteBuffer src, InetSocketAddress dst)
+    throws IOException
+  {
+    InetAddress addr = dst.getAddress();
+    if (addr == null)
+      throw new NullPointerException();
+    if (addr instanceof Inet4Address)
+      return send(nfd.getNativeFD(), src, addr.getAddress(), dst.getPort());
+    else if (addr instanceof Inet6Address)
+      return send6(nfd.getNativeFD(), src, addr.getAddress(), dst.getPort());
+    else
+      throw new SocketException("unrecognized inet address type");
+  }
+
+  // Send to an IPv4 address.
+  private static native int send(int fd, ByteBuffer src, byte[] addr, int port)
+    throws IOException;
+
+  // Send to an IPv6 address.
+  private static native int send6(int fd, ByteBuffer src, byte[] addr, int port)
+    throws IOException;
+
+  /**
+   * Write a single byte.
+   *
+   * @param b The byte to write.
+   * @throws IOException
+   */
+  public void write(int b) throws IOException
+  {
+    write(nfd.getNativeFD(), b);
+  }
+
+  private static native void write(int fd, int b) throws IOException;
+
+  private native static void initIDs();
+
+  // Network (socket) specific methods.
+
+  /**
+   * Create a new socket. This method will initialize the native file
+   * descriptor state of this instance.
+   *
+   * @param stream Whether or not to create a streaming socket, or a datagram
+   *  socket.
+   * @throws IOException If creating a new socket fails, or if this
+   *  channel already has its native descriptor initialized.
+   */
+  public void initSocket(boolean stream) throws IOException
+  {
+    if (nfd.isValid())
+      throw new IOException("native FD already initialized");
+    if (stream)
+      kind = Kind.SOCK_STREAM;
+    else
+      kind = Kind.SOCK_DGRAM;
+    nfd.setNativeFD(socket(stream));
+  }
+
+  /**
+   * Create a new socket, returning the native file descriptor.
+   *
+   * @param stream Set to true for streaming sockets; false for datagrams.
+   * @return The native file descriptor.
+   * @throws IOException If creating the socket fails.
+   */
+  private static native int socket(boolean stream) throws IOException;
+
+  /**
+   * Connect the underlying socket file descriptor to the remote host.
+   *
+   * @param saddr The address to connect to.
+   * @param timeout The connect timeout to use for blocking connects.
+   * @return True if the connection succeeded; false if the file descriptor
+   *  is in non-blocking mode and the connection did not immediately
+   *  succeed.
+   * @throws IOException If an error occurs while connecting.
+   */
+  public boolean connect(InetSocketAddress saddr, int timeout)
+    throws SocketException
+  {
+    int fd;
+
+    InetAddress addr = saddr.getAddress();
+
+    // Translates an IOException into a SocketException to conform
+    // to the throws clause.
+    try
+      {
+        fd = nfd.getNativeFD();
+      }
+    catch (IOException ioe)
+      {
+        throw new SocketException(ioe.getMessage());
+      }
+
+    if (addr instanceof Inet4Address)
+      return connect(fd, addr.getAddress(), saddr.getPort(),
+                     timeout);
+    if (addr instanceof Inet6Address)
+      return connect6(fd, addr.getAddress(), saddr.getPort(),
+                      timeout);
+    throw new SocketException("unsupported internet address");
+  }
+
+  private static native boolean connect(int fd, byte[] addr, int port, int timeout)
+    throws SocketException;
+
+  private static native boolean connect6(int fd, byte[] addr, int port, int timeout)
+    throws SocketException;
+
+  /**
+   * Disconnect this channel, if it is a datagram socket. Disconnecting
+   * a datagram channel will disassociate it from any address, so the
+   * socket will remain open, but can send and receive datagrams from
+   * any address.
+   *
+   * @throws IOException If disconnecting this channel fails, or if this
+   *  channel is not a datagram channel.
+   */
+  public void disconnect() throws IOException
+  {
+    if (kind != Kind.SOCK_DGRAM)
+      throw new IOException("can only disconnect datagram channels");
+    disconnect(nfd.getNativeFD());
+  }
+
+  private static native void disconnect(int fd) throws IOException;
+
+  public InetSocketAddress getLocalAddress() throws IOException
+  {
+    if (!nfd.isValid())
+      return null;
+    ByteBuffer name = ByteBuffer.allocateDirect(18);
+    int namelen = getsockname(nfd.getNativeFD(), name);
+    if (namelen == 0) // not bound
+      return null; // XXX return some wildcard?
+    if (namelen == 4)
+      {
+        byte[] addr = new byte[4];
+        name.get(addr);
+        int port = name.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
+      }
+    if (namelen == 16)
+      {
+        byte[] addr = new byte[16];
+        name.get(addr);
+        int port = name.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
+      }
+    throw new SocketException("invalid address length");
+  }
+
+  private static native int getsockname(int fd, ByteBuffer name)
+    throws IOException;
+
+  /**
+   * Returns the socket address of the remote peer this channel is connected
+   * to, or null if this channel is not yet connected.
+   *
+   * @return The peer address.
+   * @throws IOException
+   */
+  public InetSocketAddress getPeerAddress() throws IOException
+  {
+    if (!nfd.isValid())
+      return null;
+    ByteBuffer name = ByteBuffer.allocateDirect(18);
+    int namelen = getpeername (nfd.getNativeFD(), name);
+    if (namelen == 0) // not connected yet
+      return null;
+    if (namelen == 4) // IPv4
+      {
+        byte[] addr = new byte[4];
+        name.get(addr);
+        int port = name.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
+      }
+    else if (namelen == 16) // IPv6
+      {
+        byte[] addr = new byte[16];
+        name.get(addr);
+        int port = name.getShort() & 0xFFFF;
+        return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
+      }
+    throw new SocketException("invalid address length");
+  }
+
+  /*
+   * The format here is the peer address, followed by the port number.
+   * The returned value is the length of the peer address; thus, there
+   * will be LEN + 2 valid bytes put into NAME.
+   */
+  private static native int getpeername(int fd, ByteBuffer name)
+    throws IOException;
+
+  /**
+   * Accept an incoming connection, returning a new VMChannel, or null
+   * if the channel is nonblocking and no connection is pending.
+   *
+   * @return The accepted connection, or null.
+   * @throws IOException If an IO error occurs.
+   */
+  public VMChannel accept() throws IOException
+  {
+    int new_fd = accept(nfd.getNativeFD());
+    if (new_fd == -1) // non-blocking accept had no pending connection
+      return null;
+    return new VMChannel(new_fd);
+  }
+
+  private static native int accept(int native_fd) throws IOException;
+
+  // File-specific methods.
+
+  /**
+   * Open a file at PATH, initializing the native state to operate on
+   * that open file.
+   *
+   * @param path The absolute file path.
+   * @throws IOException If the file cannot be opened, or if this
+   *  channel was previously initialized.
+   */
+  public void openFile(String path, int mode) throws IOException
+  {
+    if (nfd.isValid() || nfd.isClosed())
+      throw new IOException("can't reinitialize this channel");
+    int fd = open(path, mode);
+    nfd.setNativeFD(fd);
+    kind = Kind.FILE;
+  }
+
+  private static native int open(String path, int mode) throws IOException;
+
+  public long position() throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    return position(nfd.getNativeFD());
+  }
+
+  private static native long position(int fd) throws IOException;
+
+  public void seek(long pos) throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    seek(nfd.getNativeFD(), pos);
+  }
+
+  private static native void seek(int fd, long pos) throws IOException;
+
+  public void truncate(long length) throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    truncate(nfd.getNativeFD(), length);
+  }
+
+  private static native void truncate(int fd, long len) throws IOException;
+
+  public boolean lock(long pos, long len, boolean shared, boolean wait)
+    throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    return lock(nfd.getNativeFD(), pos, len, shared, wait);
+  }
+
+  private static native boolean lock(int fd, long pos, long len,
+                                     boolean shared, boolean wait)
+    throws IOException;
+
+  public void unlock(long pos, long len) throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    unlock(nfd.getNativeFD(), pos, len);
+  }
+
+  private static native void unlock(int fd, long pos, long len) throws IOException;
+
+  public long size() throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    return size(nfd.getNativeFD());
+  }
+
+  private static native long size(int fd) throws IOException;
+
+  public MappedByteBuffer map(char mode, long position, int size)
+    throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    return map(nfd.getNativeFD(), mode, position, size);
+  }
+
+  private static native MappedByteBuffer map(int fd, char mode,
+                                             long position, int size)
+    throws IOException;
+
+  public boolean flush(boolean metadata) throws IOException
+  {
+    if (kind != Kind.FILE)
+      throw new IOException("not a file");
+    return flush(nfd.getNativeFD(), metadata);
+  }
+
+  private static native boolean flush(int fd, boolean metadata) throws IOException;
+
+  // Close.
+
+  /**
+   * Close this socket. The socket is also automatically closed when this
+   * object is finalized.
+   *
+   * @throws IOException If closing the socket fails, or if this object has
+   *  no open socket.
+   */
+  public void close() throws IOException
+  {
+    nfd.close();
+  }
+
+  static native void close(int native_fd) throws IOException;
+
+  /**
+   * <p>Provides a simple mean for the JNI code to find out whether the
+   * current thread was interrupted by a call to Thread.interrupt().</p>
+   *
+   * @return
+   */
+  static boolean isThreadInterrupted()
+  {
+    return Thread.currentThread().isInterrupted();
+  }
+
+  // Inner classes.
+
+  /**
+   * A wrapper for a native file descriptor integer. This tracks the state
+   * of an open file descriptor, and ensures that
+   *
+   * This class need not be fully supported by virtual machines; if a
+   * virtual machine does not use integer file descriptors, or does and
+   * wishes to hide that, then the methods of this class may be stubbed out.
+   *
+   * System-specific classes that depend on access to native file descriptor
+   * integers SHOULD declare this fact.
+   */
+  public final class State
+  {
+    private int native_fd;
+    private boolean valid;
+    private boolean closed;
+
+    State()
+    {
+      native_fd = -1;
+      valid = false;
+      closed = false;
+    }
+
+    public boolean isValid()
+    {
+      return valid;
+    }
+
+    public boolean isClosed()
+    {
+      return closed;
+    }
+
+    public int getNativeFD() throws IOException
+    {
+      if (!valid)
+        throw new IOException("invalid file descriptor");
+      return native_fd;
+    }
+
+    void setNativeFD(final int native_fd) throws IOException
+    {
+      if (valid)
+        throw new IOException("file descriptor already initialized");
+      this.native_fd = native_fd;
+      valid = true;
+    }
+
+    public void close() throws IOException
+    {
+      if (!valid)
+        throw new IOException("invalid file descriptor");
+      try
+        {
+          VMChannel.close(native_fd);
+        }
+      finally
+        {
+          valid = false;
+          closed = true;
+        }
+    }
+
+    public String toString()
+    {
+      if (closed)
+        return "<<closed>>";
+      if (!valid)
+        return "<<invalid>>";
+      return String.valueOf(native_fd);
+    }
+
+    protected void finalize() throws Throwable
+    {
+      try
+        {
+          if (valid)
+            close();
+        }
+      finally
+        {
+          super.finalize();
+        }
+    }
+  }
+
+  /**
+   * An enumeration of possible kinds of channel.
+   */
+  static class Kind // XXX enum
+  {
+    /** A streaming (TCP) socket. */
+    static final Kind SOCK_STREAM = new Kind();
+
+    /** A datagram (UDP) socket. */
+    static final Kind SOCK_DGRAM = new Kind();
+
+    /** A file. */
+    static final Kind FILE = new Kind();
+
+    /** Something else; not a socket or file. */
+    static final Kind OTHER = new Kind();
+
+    private Kind() { }
+  }
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/nio/VMPipe.java b/libjava/classpath/vm/reference/gnu/java/nio/VMPipe.java
new file mode 100644
index 000000000..a36970452
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/nio/VMPipe.java
@@ -0,0 +1,80 @@
+/* VMPipe.java -- Reference implementation for VM hooks used by PipeImpl
+   Copyright (C) 2004 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.nio;
+
+import java.io.IOException;
+import gnu.classpath.Configuration;
+
+/**
+ * This class contains the native methods for gnu.java.nio.PipeImpl
+ * As such, it needs help from the VM.
+ *
+ * @author Patrik Reali
+ */
+final class VMPipe
+{
+
+  static
+  {
+    // load the shared library needed for native methods.
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary ("javanio");
+      }
+  }
+
+  /**
+   * Create a pipe, consisting of a readable VMChannel and a writable
+   * VMChannel. The readable channel is returned is the first element
+   * of the array, and the writable in the second.
+   *
+   * @return A pair of VMChannels; the first readable, the second
+   *  writable.
+   * @throws IOException If the pipe cannot be created.
+   */
+  static VMChannel[] pipe() throws IOException
+  {
+    VMChannel[] pipe = new VMChannel[2];
+    int[] fds = pipe0();
+    pipe[0] = new VMChannel(fds[0]);
+    pipe[1] = new VMChannel(fds[1]);
+    return pipe;
+  }
+
+  private static native int[] pipe0() throws IOException;
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/nio/VMSelector.java b/libjava/classpath/vm/reference/gnu/java/nio/VMSelector.java
new file mode 100644
index 000000000..4d37c2c1c
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/nio/VMSelector.java
@@ -0,0 +1,59 @@
+/* VMSelector.java --
+   Copyright (C) 2004 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.nio;
+
+import gnu.classpath.Configuration;
+import java.io.IOException;
+
+public final class VMSelector
+{
+  static
+  {
+    // load the shared library needed for native methods.
+    if (Configuration.INIT_LOAD_LIBRARY)
+      {
+        System.loadLibrary ("javanio");
+      }
+  }
+
+  // A timeout value of 0 means block forever.
+  static native int select (int[] read, int[] write,
+                                        int[] except, long timeout)
+    throws IOException;
+
+}
diff --git a/libjava/classpath/vm/reference/gnu/java/security/jce/prng/VMSecureRandom.java b/libjava/classpath/vm/reference/gnu/java/security/jce/prng/VMSecureRandom.java
new file mode 100644
index 000000000..86faa097c
--- /dev/null
+++ b/libjava/classpath/vm/reference/gnu/java/security/jce/prng/VMSecureRandom.java
@@ -0,0 +1,129 @@
+/* VMSecureRandom.java -- random seed generator.
+   Copyright (C) 2006  Free Software Foundation, Inc.
+
+This file is a part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or (at
+your option) any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+USA
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version.  */
+
+
+package gnu.java.security.jce.prng;
+
+/**
+ * VM-specific methods for generating real (or almost real) random
+ * seeds. VM implementors should write a version of this class that
+ * reads random bytes from some system source.
+ *
+ * <p>The default implementation of this class runs eight threads that
+ * increment counters in a tight loop, and XORs each counter to
+ * produce one byte of seed data. This is not very efficient, and is
+ * not guaranteed to be random (the thread scheduler is probably
+ * deterministic, after all). If possible, VM implementors should
+ * reimplement this class so it obtains a random seed from a system
+ * facility, such as a system entropy gathering device or hardware
+ * random number generator.
+ */
+final class VMSecureRandom
+{
+
+  /**
+   * Generate a random seed. Implementations are free to generate
+   * fewer random bytes than are requested, and leave the remaining
+   * bytes of the destination buffer as zeros. Implementations SHOULD,
+   * however, make a best-effort attempt to satisfy the request.
+   *
+   * @param buffer The destination buffer.
+   * @param offset The offset in the buffer to start putting bytes.
+   * @param length The number of random bytes to generate.
+   */
+  static int generateSeed(byte[] buffer, int offset, int length)
+  {
+    if (length < 0)
+      throw new IllegalArgumentException("length must be nonnegative");
+    if (offset < 0 || offset + length > buffer.length)
+      throw new IndexOutOfBoundsException();
+
+    Spinner[] spinners = new Spinner[8];
+    int n = 0x1;
+    for (int i = 0; i < spinners.length; i++)
+      {
+        spinners[i] = new Spinner((byte) n);
+        Thread t = new Thread(spinners[i]);
+        t.start();
+        n <<= 1;
+      }
+
+    // Wait until at least one spinner has started.
+    while (!(spinners[0].running || spinners[1].running || spinners[2].running
+             || spinners[3].running || spinners[4].running || spinners[5].running
+             || spinners[6].running || spinners[7].running))
+      {
+        Thread.yield();
+      }
+
+    for (int i = offset; i < length; i++)
+      {
+        buffer[i] = (byte) (spinners[0].value ^ spinners[1].value ^ spinners[2].value
+                            ^ spinners[3].value ^ spinners[4].value ^ spinners[5].value
+                            ^ spinners[6].value ^ spinners[7].value);
+        Thread.yield();
+      }
+
+    for (int i = 0; i < spinners.length; i++)
+      spinners[i].stop();
+
+    return length;
+  }
+
+  static class Spinner implements Runnable
+  {
+    volatile byte value;
+    volatile boolean running;
+
+    Spinner(final byte initial)
+    {
+      value = initial;
+    }
+
+    public void run()
+    {
+      running = true;
+      while (running)
+        value++;
+    }
+
+    private void stop()
+    {
+      running = false;
+    }
+  }
+}