--- a/ChangeLog	Fri Feb 13 20:38:41 2009 +0000
+++ b/ChangeLog	Fri Feb 20 14:50:00 2009 +0000
@@ -1,3 +1,216 @@
+2009-02-20  Andrew John Hughes  <ahughes@redhat.com>
+
+ 	* overlays/nio2/openjdk/jdk/src/share/classes/java/io/File.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/io/FilePermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/net/ProtocolFamily.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/net/SocketOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/net/StandardProtocolFamily.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/net/StandardSocketOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/Channels.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/DatagramChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/FileChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/FileLock.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/MembershipKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/MulticastChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/NetworkChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/exceptions,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/spi/SelectorProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/spi/package.html,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/util/Scanner.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/misc/JavaIODeleteOnExitAccess.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/misc/JavaNetGetIndexAccess.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/misc/JavaUtilConcurrentThreadPoolExecutorAccess.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/misc/SharedSecrets.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/ExtendedSocketOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/MembershipKeyImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/MembershipRegistry.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/OptionKey.java: Removed
+	* Makefile.am: Remove moved patch.
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/io/Inputs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/io/Outputs.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousByteChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannelGroup.java: Fix imports.
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousDatagramChannel.java: Fix imports,
+	match method naming to those used in main 7 tree.
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousFileChannel.java: Fix imports.
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java:
+	Fix imports, match method named to 7 tree.
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/CompletionHandler.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/SeekableByteChannel.java: Fix imports.
+	(positionSBC(long)): Rename back to position.
+	(truncateSBC(long)): Rename back to truncate.
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/spi/AsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AccessDeniedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AccessMode.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/AtomicMoveNotSupportedException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedDirectoryStreamException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ClosedWatchServiceException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/CopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryNotEmptyException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/DirectoryStreamFilters.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileAction.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileRef.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileStore.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemAlreadyExistsException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystemNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileSystems.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileTreeWalker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitResult.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/FileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Files.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/InvalidPathException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/LinkOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/LinkPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NoSuchFileException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NotDirectoryException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/NotLinkException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/OpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Path.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/PathMatcher.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Paths.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ProviderMismatchException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ProviderNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/ReadOnlyFileSystemException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/SecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/SimpleFileVisitor.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardCopyOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardOpenOption.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/StandardWatchEventKind.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchEvent.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/WatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/Watchable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntry.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryFlag.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryPermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclEntryType.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/AttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/Attributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/BasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/BasicFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/DosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/DosFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileOwnerAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/FileStoreSpaceAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/GroupPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/NamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFilePermission.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/PosixFilePermissions.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipal.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipalLookupService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/UserPrincipalNotFoundException.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/attribute/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/AbstractPath.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/FileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/FileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/java/nio/file/spi/package-info.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AbstractFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousChannelGroupImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousFileLockImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/AsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/CompletedFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/FileLockTable.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/Invoker.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/PendingFuture.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousDatagramChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/SimpleAsynchronousFileChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/ch/ThreadPool.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractAclFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileStoreSpaceAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractPoller.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchKey.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/AbstractWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/FileOwnerAttributeViewImpl.java,
+	* overlays/nio2/openjdk/jdk/src/share/classes/sun/nio/fs/PollingWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/JarFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/JarFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileBasicAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileBasicAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFilePath.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileStream.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipPathParser.java,
+	* overlays/nio2/openjdk/jdk/src/share/demo/nio/ZipFileSystem/com/sun/nio/zipfs/ZipUtils.java: Fix imports.
+	* overlays/nio2/openjdk/jdk/src/share/native/sun/nio/ch/genSocketOptionRegistry.c: Fix imports.
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/aio/EchoServer.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/AclEdit.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Chmod.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Copy.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/DiskUsage.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/FileType.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/WatchDir.java,
+	* overlays/nio2/openjdk/jdk/src/share/sample/nio/file/Xdd.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/EPollPort.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/LinuxAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/Port.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisAsynchronousChannelProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/SolarisEventPort.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/ch/UnixAsynchronousSocketChannelImpl.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/DefaultFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/GnomeFileTypeDetector.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxDosFileAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxNamedAttributeView.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/LinuxWatchService.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixChannelFactory.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixCopyFile.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixException.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributes.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileModeAttribute.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileStore.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystem.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixSecureDirectoryStream.java,
+	* overlays/nio2/openjdk/jdk/src/solaris/classes/sun/nio/fs/UnixUserPrincipals.java,
+	* overlays/nio2/openjdk/jdk/test/demo/nio/ZipFileSystem/Sanity.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/io/Inputs/Basic.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/AsExecutor.java,
+	* overlays/nio2/openjdk/jdk/test/org/classpath/icedtea/java/nio/channels/AsynchronousChannelGroup/Basic.java:
+	Fix imports.
+	* patches/icedtea-doc-headers.patch: Remove extra '+'.
+	* patches/icedtea-nio2.patch: Recreated, now includes patch to java.io.File,
+	java.io.FilePermission, java.net.StandardProtocolFamily, java.net.StandardSocketOption,
+	java.nio.channels.Channels, java.nio.channels.DatagramChannel, java.nio.channels.exceptions,
+	java.nio.channels.FileChannel, java.nio.channels.FileLock, java.nio.channels.package-info.java,
+	java.util.Scanner.  Remove patch to sun.nio.ch.FileChannelImpl. Fix imports.  Remove 6 cruft.
+
 2009-02-13  Andrew John Hughes  <ahughes@redhat.com>
 
 	* overlays/nio2/openjdk/jdk/src/share/classes/org/classpath/icedtea/java/io/File.java,

--- a/Makefile.am	Fri Feb 13 20:38:41 2009 +0000
+++ b/Makefile.am	Fri Feb 20 14:50:00 2009 +0000
@@ -2117,7 +2117,6 @@
 	patches/ecj/icedtea-hotspot-$(HSBUILD).patch \
 	patches/ecj/icedtea-spp.patch \
 	patches/ecj/icedtea-jopt.patch \
-	patches/ecj/icedtea-pr261.patch \
 	patches/ecj/icedtea-sbcs.patch
 
 stamps/patch-ecj.stamp: stamps/clone-ecj.stamp

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedCopyOption.java	Fri Feb 20 14:50:00 2009 +0000
@@ -25,7 +25,7 @@
 
 package com.sun.nio.file;
 
-import org.classpath.icedtea.java.nio.file.CopyOption;
+import java.nio.file.CopyOption;
 
 /**
  * Defines <em>extended</em> copy options supported on some platforms

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedOpenOption.java	Fri Feb 20 14:50:00 2009 +0000
@@ -25,7 +25,7 @@
 
 package com.sun.nio.file;
 
-import org.classpath.icedtea.java.nio.file.OpenOption;
+import java.nio.file.OpenOption;
 
 /**
  * Defines <em>extended</em> open options supported on some platforms

--- a/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/com/sun/nio/file/ExtendedWatchEventModifier.java	Fri Feb 20 14:50:00 2009 +0000
@@ -25,7 +25,7 @@
 
 package com.sun.nio.file;
 
-import org.classpath.icedtea.java.nio.file.WatchEvent.Modifier;
+import java.nio.file.WatchEvent.Modifier;
 
 /**
  * Defines <em>extended</em> watch event modifiers supported on some platforms

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/io/File.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,450 +0,0 @@
-/*
- * Copyright 1994-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.io;
-
-import java.beans.ConstructorProperties;
-import java.net.URI;
-import java.net.URL;
-import java.net.MalformedURLException;
-import java.net.URISyntaxException;
-
-import java.io.IOException;
-import java.io.IOError;
-
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import sun.security.action.GetPropertyAction;
-
-import org.classpath.icedtea.java.nio.file.FileAlreadyExistsException;
-import org.classpath.icedtea.java.nio.file.FileSystem;
-import org.classpath.icedtea.java.nio.file.FileSystems;
-import org.classpath.icedtea.java.nio.file.InvalidPathException;
-import org.classpath.icedtea.java.nio.file.Path;
-import org.classpath.icedtea.java.nio.file.Paths;
-
-import org.classpath.icedtea.java.nio.file.attribute.FileAttribute;
-import org.classpath.icedtea.java.nio.file.attribute.FileAttributeView;
-import org.classpath.icedtea.java.nio.file.attribute.PosixFilePermission;
-import org.classpath.icedtea.java.nio.file.attribute.PosixFilePermissions;
-
-import org.classpath.icedtea.misc.SharedSecrets;
-
-/**
- * An abstract representation of file and directory pathnames.
- *
- * <p> User interfaces and operating systems use system-dependent <em>pathname
- * strings</em> to name files and directories.  This class presents an
- * abstract, system-independent view of hierarchical pathnames.  An
- * <em>abstract pathname</em> has two components:
- *
- * <ol>
- * <li> An optional system-dependent <em>prefix</em> string,
- *      such as a disk-drive specifier, <code>"/"</code>&nbsp;for the UNIX root
- *      directory, or <code>"\\\\"</code>&nbsp;for a Microsoft Windows UNC pathname, and
- * <li> A sequence of zero or more string <em>names</em>.
- * </ol>
- *
- * The first name in an abstract pathname may be a directory name or, in the
- * case of Microsoft Windows UNC pathnames, a hostname.  Each subsequent name
- * in an abstract pathname denotes a directory; the last name may denote
- * either a directory or a file.  The <em>empty</em> abstract pathname has no
- * prefix and an empty name sequence.
- *
- * <p> The conversion of a pathname string to or from an abstract pathname is
- * inherently system-dependent.  When an abstract pathname is converted into a
- * pathname string, each name is separated from the next by a single copy of
- * the default <em>separator character</em>.  The default name-separator
- * character is defined by the system property <code>file.separator</code>, and
- * is made available in the public static fields <code>{@link
- * #separator}</code> and <code>{@link #separatorChar}</code> of this class.
- * When a pathname string is converted into an abstract pathname, the names
- * within it may be separated by the default name-separator character or by any
- * other name-separator character that is supported by the underlying system.
- *
- * <p> A pathname, whether abstract or in string form, may be either
- * <em>absolute</em> or <em>relative</em>.  An absolute pathname is complete in
- * that no other information is required in order to locate the file that it
- * denotes.  A relative pathname, in contrast, must be interpreted in terms of
- * information taken from some other pathname.  By default the classes in the
- * <code>java.io</code> package always resolve relative pathnames against the
- * current user directory.  This directory is named by the system property
- * <code>user.dir</code>, and is typically the directory in which the Java
- * virtual machine was invoked.
- *
- * <p> The <em>parent</em> of an abstract pathname may be obtained by invoking
- * the {@link #getParent} method of this class and consists of the pathname's
- * prefix and each name in the pathname's name sequence except for the last.
- * Each directory's absolute pathname is an ancestor of any <tt>File</tt>
- * object with an absolute abstract pathname which begins with the directory's
- * absolute pathname.  For example, the directory denoted by the abstract
- * pathname <tt>"/usr"</tt> is an ancestor of the directory denoted by the
- * pathname <tt>"/usr/local/bin"</tt>.
- *
- * <p> The prefix concept is used to handle root directories on UNIX platforms,
- * and drive specifiers, root directories and UNC pathnames on Microsoft Windows platforms,
- * as follows:
- *
- * <ul>
- *
- * <li> For UNIX platforms, the prefix of an absolute pathname is always
- * <code>"/"</code>.  Relative pathnames have no prefix.  The abstract pathname
- * denoting the root directory has the prefix <code>"/"</code> and an empty
- * name sequence.
- *
- * <li> For Microsoft Windows platforms, the prefix of a pathname that contains a drive
- * specifier consists of the drive letter followed by <code>":"</code> and
- * possibly followed by <code>"\\"</code> if the pathname is absolute.  The
- * prefix of a UNC pathname is <code>"\\\\"</code>; the hostname and the share
- * name are the first two names in the name sequence.  A relative pathname that
- * does not specify a drive has no prefix.
- *
- * </ul>
- *
- * <p> Instances of this class may or may not denote an actual file-system
- * object such as a file or a directory.  If it does denote such an object
- * then that object resides in a <i>partition</i>.  A partition is an
- * operating system-specific portion of storage for a file system.  A single
- * storage device (e.g. a physical disk-drive, flash memory, CD-ROM) may
- * contain multiple partitions.  The object, if any, will reside on the
- * partition <a name="partName">named</a> by some ancestor of the absolute
- * form of this pathname.
- *
- * <p> A file system may implement restrictions to certain operations on the
- * actual file-system object, such as reading, writing, and executing.  These
- * restrictions are collectively known as <i>access permissions</i>.  The file
- * system may have multiple sets of access permissions on a single object.
- * For example, one set may apply to the object's <i>owner</i>, and another
- * may apply to all other users.  The access permissions on an object may
- * cause some methods in this class to fail.
- *
- * <p> Instances of the <code>File</code> class are immutable; that is, once
- * created, the abstract pathname represented by a <code>File</code> object
- * will never change.
- *
- * <h4>Interoperability with {@code java.nio.file} package</h4>
- *
- * <p> {@note new}
- * The <a href="../../java/nio/file/package-summary.html">{@code java.nio.file}</a>
- * package defines interfaces and classes for the Java virtual machine to access
- * files, file attributes, and file systems. This API may be used to overcome
- * many of the limitations of the {@code java.io.File} class.
- * The {@link #toPath toPath} method may be used to obtain a {@link
- * Path} that uses the abstract path represented by a {@code File} object to
- * locate a file. The resulting {@code Path} provides more efficient and
- * extensive access to file attributes, additional file operations, and I/O
- * exceptions to help diagnose errors when an operation on a file fails.
- *
- * @author  unascribed
- * @since   JDK1.0
- */
-
-public class File
-  extends java.io.File
-{
-
-    /**
-     * Creates a new <code>File</code> instance by converting the given
-     * pathname string into an abstract pathname.  If the given string is
-     * the empty string, then the result is the empty abstract pathname.
-     *
-     * @param   pathname  A pathname string
-     * @throws  NullPointerException
-     *          If the <code>pathname</code> argument is <code>null</code>
-     */
-    @ConstructorProperties("path")
-    public File(String pathname) {
-      super(pathname);
-    }
-
-    /* Note: The two-argument File constructors do not interpret an empty
-       parent abstract pathname as the current user directory.  An empty parent
-       instead causes the child to be resolved against the system-dependent
-       directory defined by the FileSystem.getDefaultParent method.  On Unix
-       this default is "/", while on Microsoft Windows it is "\\".  This is required for
-       compatibility with the original behavior of this class. */
-
-    /**
-     * Creates a new <code>File</code> instance from a parent pathname string
-     * and a child pathname string.
-     *
-     * <p> If <code>parent</code> is <code>null</code> then the new
-     * <code>File</code> instance is created as if by invoking the
-     * single-argument <code>File</code> constructor on the given
-     * <code>child</code> pathname string.
-     *
-     * <p> Otherwise the <code>parent</code> pathname string is taken to denote
-     * a directory, and the <code>child</code> pathname string is taken to
-     * denote either a directory or a file.  If the <code>child</code> pathname
-     * string is absolute then it is converted into a relative pathname in a
-     * system-dependent way.  If <code>parent</code> is the empty string then
-     * the new <code>File</code> instance is created by converting
-     * <code>child</code> into an abstract pathname and resolving the result
-     * against a system-dependent default directory.  Otherwise each pathname
-     * string is converted into an abstract pathname and the child abstract
-     * pathname is resolved against the parent.
-     *
-     * @param   parent  The parent pathname string
-     * @param   child   The child pathname string
-     * @throws  NullPointerException
-     *          If <code>child</code> is <code>null</code>
-     */
-    public File(String parent, String child) {
-      super(parent, child);
-    }
-
-    /**
-     * Creates a new <code>File</code> instance from a parent abstract
-     * pathname and a child pathname string.
-     *
-     * <p> If <code>parent</code> is <code>null</code> then the new
-     * <code>File</code> instance is created as if by invoking the
-     * single-argument <code>File</code> constructor on the given
-     * <code>child</code> pathname string.
-     *
-     * <p> Otherwise the <code>parent</code> abstract pathname is taken to
-     * denote a directory, and the <code>child</code> pathname string is taken
-     * to denote either a directory or a file.  If the <code>child</code>
-     * pathname string is absolute then it is converted into a relative
-     * pathname in a system-dependent way.  If <code>parent</code> is the empty
-     * abstract pathname then the new <code>File</code> instance is created by
-     * converting <code>child</code> into an abstract pathname and resolving
-     * the result against a system-dependent default directory.  Otherwise each
-     * pathname string is converted into an abstract pathname and the child
-     * abstract pathname is resolved against the parent.
-     *
-     * @param   parent  The parent abstract pathname
-     * @param   child   The child pathname string
-     * @throws  NullPointerException
-     *          If <code>child</code> is <code>null</code>
-     */
-    public File(File parent, String child) {
-      super(parent, child);
-    }
-
-
-
-    /* -- Temporary files -- */
-
-    private static class TemporaryDirectory {
-        private TemporaryDirectory() { }
-
-        static final File valueAsFile =
-            new File(AccessController.doPrivileged(new GetPropertyAction("java.io.tmpdir")));
-
-        // file name generation
-        private static final AtomicInteger counter =
-            new AtomicInteger(new Random().nextInt() & 0xffff);
-        static File generateFile(String prefix, String suffix, File dir) {
-            int n = counter.getAndIncrement();
-            return new File(dir, prefix + Integer.toString(n) + suffix);
-        }
-
-        // default file permissions
-        static final FileAttribute<Set<PosixFilePermission>> defaultPosixFilePermissions =
-            PosixFilePermissions.asFileAttribute(EnumSet
-                .of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE));
-        static final boolean isPosix = isPosix();
-        static boolean isPosix() {
-            return AccessController.doPrivileged(
-                new PrivilegedAction<Boolean>() {
-                    public Boolean run() {
-                        try {
-			  return FileSystems.getDefault().getPath(valueAsFile.getPath())
-                                .getFileStore().supportsFileAttributeView("posix");
-                        } catch (IOException e) {
-                            throw new IOError(e);
-                        }
-                    }
-                });
-        }
-    }
-
-    /**
-     * {@note new}
-     * Creates an empty file in the default temporary-file directory, using
-     * the given prefix and suffix to generate its name. This method is
-     * equivalent to invoking the {@link #createTempFile(String,String)
-     * createTempFile(prefix,&nbsp;suffix)} method with the addition that the
-     * resulting pathname may be requested to be deleted when the Java virtual
-     * machine terminates, and the initial file attributes to set atomically
-     * when creating the file may be specified.
-     *
-     * <p> When the value of the {@code deleteOnExit} method is {@code true}
-     * then the resulting file is requested to be deleted when the Java virtual
-     * machine terminates as if by invoking the {@link #deleteOnExit deleteOnExit}
-     * method.
-     *
-     * <p> The {@code attrs} parameter is an optional array of {@link FileAttribute
-     * attributes} to set atomically when creating the file. Each attribute is
-     * identified by its {@link FileAttribute#name name}. If more than one attribute
-     * of the same name is included in the array then all but the last occurrence
-     * is ignored.
-     *
-     * @param   prefix
-     *          The prefix string to be used in generating the file's
-     *          name; must be at least three characters long
-     * @param   suffix
-     *          The suffix string to be used in generating the file's
-     *          name; may be {@code null}, in which case the suffix
-     *          {@code ".tmp"} will be used
-     * @param   deleteOnExit
-     *          {@code true} if the file denoted by resulting pathname be
-     *          deleted when the Java virtual machine terminates
-     * @param   attrs
-     *          An optional list of file attributes to set atomically when creating
-     *          the file
-     *
-     * @return  An abstract pathname denoting a newly-created empty file
-     *
-     * @throws  IllegalArgumentException
-     *          If the <code>prefix</code> argument contains fewer than three
-     *          characters
-     * @throws  UnsupportedOperationException
-     *          If the array contains an attribute that cannot be set atomically
-     *          when creating the file
-     * @throws  IOException
-     *          If a file could not be created
-     * @throws  SecurityException
-     *          If a security manager exists and its <code>{@link
-     *          java.lang.SecurityManager#checkWrite(java.lang.String)}</code>
-     *          method does not allow a file to be created. When the {@code
-     *          deleteOnExit} parameter has the value {@code true} then the
-     *          security manager's {@link
-     *          java.lang.SecurityManager#checkDelete(java.lang.String)} is
-     *          invoked to check delete access to the file.
-     * @since 1.7
-     */
-    public static File createTempFile(String prefix,
-                                      String suffix,
-                                      boolean deleteOnExit,
-                                      FileAttribute<?>... attrs)
-        throws IOException
-    {
-        if (prefix.length() < 3)
-            throw new IllegalArgumentException("Prefix string too short");
-        suffix = (suffix == null) ? ".tmp" : suffix;
-
-        // special case POSIX environments so that 0600 is used as the file mode
-        if (TemporaryDirectory.isPosix) {
-            if (attrs.length == 0) {
-                // no attributes so use default permissions
-                attrs = new FileAttribute<?>[1];
-                attrs[0] = TemporaryDirectory.defaultPosixFilePermissions;
-            } else {
-                // check if posix permissions given; if not use default
-                boolean hasPermissions = false;
-                for (int i=0; i<attrs.length; i++) {
-                    if (attrs[i].name().equals("posix:permissions")) {
-                        hasPermissions = true;
-                        break;
-                    }
-                }
-                if (!hasPermissions) {
-                    FileAttribute<?>[] copy = new FileAttribute<?>[attrs.length+1];
-                    System.arraycopy(attrs, 0, copy, 0, attrs.length);
-                    attrs = copy;
-                    attrs[attrs.length-1] =
-                        TemporaryDirectory.defaultPosixFilePermissions;
-                }
-            }
-        }
-
-        // use Path#createFile to create file
-        SecurityManager sm = System.getSecurityManager();
-        for (;;) {
-            File f = TemporaryDirectory
-                .generateFile(prefix, suffix, TemporaryDirectory.valueAsFile);
-            if (sm != null && deleteOnExit)
-                sm.checkDelete(f.getPath());
-            try {
-                f.toPath().createFile(attrs);
-                if (deleteOnExit)
-		  SharedSecrets.getJavaIODeleteOnExitAccess().add(f.getPath());
-                return f;
-            } catch (InvalidPathException e) {
-                // don't reveal temporary directory location
-                if (sm != null)
-                    throw new IllegalArgumentException("Invalid prefix or suffix");
-                throw e;
-            } catch (SecurityException e) {
-                // don't reveal temporary directory location
-                if (sm != null)
-                    throw new SecurityException("Unable to create temporary file");
-                throw e;
-            } catch (FileAlreadyExistsException e) {
-                // ignore
-            }
-        }
-    }
-
-    // -- Integration with java.nio.file --
-
-    private volatile transient Path filePath;
-
-    /**
-     * {@note new}
-     * Returns a {@link Path java.nio.file.Path} object constructed from the
-     * this abstract path. The first invocation of this method works as if
-     * invoking it were equivalent to evaluating the expression:
-     * <blockquote><pre>
-     * {@link FileSystems#getDefault FileSystems.getDefault}().{@link FileSystem#getPath getPath}(this.{@link #getPath getPath}());
-     * </pre></blockquote>
-     * Subsequent invocations of this method return the same {@code Path}.
-     *
-     * <p> If this abstract pathname is the empty abstract pathname then this
-     * method returns a {@code Path} that may be used to access to the current
-     * user directory.
-     *
-     * @return  A {@code Path} constructed from this abstract path. The resulting
-     *          {@code Path} is associated with the {@link FileSystems#getDefault
-     *          default-filesystem}.
-     *
-     * @throws  InvalidPathException
-     *          If a {@code Path} object cannot be constructed from the abstract
-     *          path (see {@link java.nio.file.FileSystem#getPath FileSystem.getPath})
-     *
-     * @since   1.7
-     */
-    public Path toPath() {
-        if (filePath == null) {
-            synchronized (this) {
-                if (filePath == null) {
-		    String path = getPath();
-                    if (path.length() == 0) {
-                        // assume default file system treats "." as current directory
-                        filePath = Paths.get(".");
-                    } else {
-                        filePath = Paths.get(path);
-                    }
-                }
-            }
-        }
-        return filePath;
-    }
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/io/FilePermission.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,852 +0,0 @@
-/*
- * Copyright 1997-2005 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.io;
-
-import java.security.*;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Vector;
-import java.util.Collections;
-import java.io.IOException;
-import java.io.ObjectStreamField;
-import java.io.ObjectOutputStream;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
-import sun.security.util.SecurityConstants;
-
-/**
- * This class represents access to a file or directory.  A FilePermission consists
- * of a pathname and a set of actions valid for that pathname.
- * <P>
- * Pathname is the pathname of the file or directory granted the specified
- * actions. A pathname that ends in "/*" (where "/" is
- * the file separator character, <code>File.separatorChar</code>) indicates
- * all the files and directories contained in that directory. A pathname
- * that ends with "/-" indicates (recursively) all files
- * and subdirectories contained in that directory. A pathname consisting of
- * the special token "&lt;&lt;ALL FILES&gt;&gt;" matches <b>any</b> file.
- * <P>
- * Note: A pathname consisting of a single "*" indicates all the files
- * in the current directory, while a pathname consisting of a single "-"
- * indicates all the files in the current directory and
- * (recursively) all files and subdirectories contained in the current
- * directory.
- * <P>
- * {@note revised}
- * The actions to be granted are passed to the constructor in a string containing
- * a list of one or more comma-separated keywords. The possible keywords are
- * "read", "write", "execute", "delete", and "readlink". Their meaning is
- * defined as follows:
- * <P>
- * <DL>
- *    <DT> read <DD> read permission
- *    <DT> write <DD> write permission
- *    <DT> execute
- *    <DD> execute permission. Allows <code>Runtime.exec</code> to
- *         be called. Corresponds to <code>SecurityManager.checkExec</code>.
- *    <DT> delete
- *    <DD> delete permission. Allows <code>File.delete</code> to
- *         be called. Corresponds to <code>SecurityManager.checkDelete</code>.
- *    <DT> readlink
- *    <DD> read link permission. Allows the target of a
- *         <a href="../nio/file/package-summary.html#links">symbolic link</a>
- *         to be read by invoking the {@link java.nio.file.Path#readSymbolicLink
- *         readSymbolicLink } method.
- * </DL>
- * <P>
- * The actions string is converted to lowercase before processing.
- * <P>
- * Be careful when granting FilePermissions. Think about the implications
- * of granting read and especially write access to various files and
- * directories. The "&lt;&lt;ALL FILES>>" permission with write action is
- * especially dangerous. This grants permission to write to the entire
- * file system. One thing this effectively allows is replacement of the
- * system binary, including the JVM runtime environment.
- *
- * <p>Please note: Code can always read a file from the same
- * directory it's in (or a subdirectory of that directory); it does not
- * need explicit permission to do so.
- *
- * @see java.security.Permission
- * @see java.security.Permissions
- * @see java.security.PermissionCollection
- *
- *
- * @author Marianne Mueller
- * @author Roland Schemers
- * @since 1.2
- *
- * @serial exclude
- */
-
-public final class FilePermission extends Permission implements Serializable {
-
-    /**
-     * Execute action.
-     */
-    private final static int EXECUTE = 0x1;
-    /**
-     * Write action.
-     */
-    private final static int WRITE   = 0x2;
-    /**
-     * Read action.
-     */
-    private final static int READ    = 0x4;
-    /**
-     * Delete action.
-     */
-    private final static int DELETE  = 0x8;
-    /**
-     * Read link action.
-     */
-    private final static int READLINK    = 0x10;
-
-    /**
-     * All actions (read,write,execute,delete,readlink)
-     */
-    private final static int ALL     = READ|WRITE|EXECUTE|DELETE|READLINK;
-    /**
-     * No actions.
-     */
-    private final static int NONE    = 0x0;
-
-    // the actions mask
-    private transient int mask;
-
-    // does path indicate a directory? (wildcard or recursive)
-    private transient boolean directory;
-
-    // is it a recursive directory specification?
-    private transient boolean recursive;
-
-    /**
-     * the actions string.
-     *
-     * @serial
-     */
-    private String actions; // Left null as long as possible, then
-                            // created and re-used in the getAction function.
-
-    // canonicalized dir path. In the case of
-    // directories, it is the name "/blah/*" or "/blah/-" without
-    // the last character (the "*" or "-").
-
-    private transient String cpath;
-
-    // static Strings used by init(int mask)
-    private static final char RECURSIVE_CHAR = '-';
-    private static final char WILD_CHAR = '*';
-
-/*
-    public String toString()
-    {
-        StringBuffer sb = new StringBuffer();
-        sb.append("***\n");
-        sb.append("cpath = "+cpath+"\n");
-        sb.append("mask = "+mask+"\n");
-        sb.append("actions = "+getActions()+"\n");
-        sb.append("directory = "+directory+"\n");
-        sb.append("recursive = "+recursive+"\n");
-        sb.append("***\n");
-        return sb.toString();
-    }
-*/
-
-    private static final long serialVersionUID = 7930732926638008763L;
-
-    /**
-     * initialize a FilePermission object. Common to all constructors.
-     * Also called during de-serialization.
-     *
-     * @param mask the actions mask to use.
-     *
-     */
-    private void init(int mask)
-    {
-
-        if ((mask & ALL) != mask)
-                throw new IllegalArgumentException("invalid actions mask");
-
-        if (mask == NONE)
-                throw new IllegalArgumentException("invalid actions mask");
-
-        if ((cpath = getName()) == null)
-                throw new NullPointerException("name can't be null");
-
-        this.mask = mask;
-
-        if (cpath.equals("<<ALL FILES>>")) {
-            directory = true;
-            recursive = true;
-            cpath = "";
-            return;
-        }
-
-        // store only the canonical cpath if possible
-        cpath = AccessController.doPrivileged(new PrivilegedAction<String>() {
-            public String run() {
-                try {
-                    return sun.security.provider.PolicyFile.canonPath(cpath);
-                } catch (IOException ioe) {
-                    return cpath;
-                }
-            }
-        });
-
-        int len = cpath.length();
-        char last = ((len > 0) ? cpath.charAt(len - 1) : 0);
-
-        if (last == RECURSIVE_CHAR &&
-            cpath.charAt(len - 2) == File.separatorChar) {
-            directory = true;
-            recursive = true;
-            cpath = cpath.substring(0, --len);
-        } else if (last == WILD_CHAR &&
-            cpath.charAt(len - 2) == File.separatorChar) {
-            directory = true;
-            //recursive = false;
-            cpath = cpath.substring(0, --len);
-        } else {
-            // overkill since they are initialized to false, but
-            // commented out here to remind us...
-            //directory = false;
-            //recursive = false;
-        }
-
-        // XXX: at this point the path should be absolute. die if it isn't?
-    }
-
-    /**
-     * Creates a new FilePermission object with the specified actions.
-     * <i>path</i> is the pathname of a file or directory, and <i>actions</i>
-     * contains a comma-separated list of the desired actions granted on the
-     * file or directory. Possible actions are
-     * "read", "write", "execute", "delete", and "readlink".
-     *
-     * <p>A pathname that ends in "/*" (where "/" is
-     * the file separator character, <code>File.separatorChar</code>)
-     * indicates all the files and directories contained in that directory.
-     * A pathname that ends with "/-" indicates (recursively) all files and
-     * subdirectories contained in that directory. The special pathname
-     * "&lt;&lt;ALL FILES&gt;&gt;" matches any file.
-     *
-     * <p>A pathname consisting of a single "*" indicates all the files
-     * in the current directory, while a pathname consisting of a single "-"
-     * indicates all the files in the current directory and
-     * (recursively) all files and subdirectories contained in the current
-     * directory.
-     *
-     * <p>A pathname containing an empty string represents an empty path.
-     *
-     * @param path the pathname of the file/directory.
-     * @param actions the action string.
-     *
-     * @throws IllegalArgumentException
-     *          If actions is <code>null</code>, empty or contains an action
-     *          other than the specified possible actions.
-     */
-
-    public FilePermission(String path, String actions)
-    {
-        super(path);
-        init(getMask(actions));
-    }
-
-    /**
-     * Creates a new FilePermission object using an action mask.
-     * More efficient than the FilePermission(String, String) constructor.
-     * Can be used from within
-     * code that needs to create a FilePermission object to pass into the
-     * <code>implies</code> method.
-     *
-     * @param path the pathname of the file/directory.
-     * @param mask the action mask to use.
-     */
-
-    // package private for use by the FilePermissionCollection add method
-    FilePermission(String path, int mask)
-    {
-        super(path);
-        init(mask);
-    }
-
-    /**
-     * Checks if this FilePermission object "implies" the specified permission.
-     * <P>
-     * More specifically, this method returns true if:<p>
-     * <ul>
-     * <li> <i>p</i> is an instanceof FilePermission,<p>
-     * <li> <i>p</i>'s actions are a proper subset of this
-     * object's actions, and <p>
-     * <li> <i>p</i>'s pathname is implied by this object's
-     *      pathname. For example, "/tmp/*" implies "/tmp/foo", since
-     *      "/tmp/*" encompasses all files in the "/tmp" directory,
-     *      including the one named "foo".
-     * </ul>
-     *
-     * @param p the permission to check against.
-     *
-     * @return <code>true</code> if the specified permission is not
-     *                  <code>null</code> and is implied by this object,
-     *                  <code>false</code> otherwise.
-     */
-    public boolean implies(Permission p) {
-        if (!(p instanceof FilePermission))
-            return false;
-
-        FilePermission that = (FilePermission) p;
-
-        // we get the effective mask. i.e., the "and" of this and that.
-        // They must be equal to that.mask for implies to return true.
-
-        return ((this.mask & that.mask) == that.mask) && impliesIgnoreMask(that);
-    }
-
-    /**
-     * Checks if the Permission's actions are a proper subset of the
-     * this object's actions. Returns the effective mask iff the
-     * this FilePermission's path also implies that FilePermission's path.
-     *
-     * @param that the FilePermission to check against.
-     * @param exact return immediately if the masks are not equal
-     * @return the effective mask
-     */
-    boolean impliesIgnoreMask(FilePermission that) {
-        if (this.directory) {
-            if (this.recursive) {
-                // make sure that.path is longer then path so
-                // something like /foo/- does not imply /foo
-                if (that.directory) {
-                    return (that.cpath.length() >= this.cpath.length()) &&
-                            that.cpath.startsWith(this.cpath);
-                }  else {
-                    return ((that.cpath.length() > this.cpath.length()) &&
-                        that.cpath.startsWith(this.cpath));
-                }
-            } else {
-                if (that.directory) {
-                    // if the permission passed in is a directory
-                    // specification, make sure that a non-recursive
-                    // permission (i.e., this object) can't imply a recursive
-                    // permission.
-                    if (that.recursive)
-                        return false;
-                    else
-                        return (this.cpath.equals(that.cpath));
-                } else {
-                    int last = that.cpath.lastIndexOf(File.separatorChar);
-                    if (last == -1)
-                        return false;
-                    else {
-                        // this.cpath.equals(that.cpath.substring(0, last+1));
-                        // Use regionMatches to avoid creating new string
-                        return (this.cpath.length() == (last + 1)) &&
-                            this.cpath.regionMatches(0, that.cpath, 0, last+1);
-                    }
-                }
-            }
-        } else if (that.directory) {
-            // if this is NOT recursive/wildcarded,
-            // do not let it imply a recursive/wildcarded permission
-            return false;
-        } else {
-            return (this.cpath.equals(that.cpath));
-        }
-    }
-
-    /**
-     * Checks two FilePermission objects for equality. Checks that <i>obj</i> is
-     * a FilePermission, and has the same pathname and actions as this object.
-     * <P>
-     * @param obj the object we are testing for equality with this object.
-     * @return <code>true</code> if obj is a FilePermission, and has the same
-     *          pathname and actions as this FilePermission object,
-     *          <code>false</code> otherwise.
-     */
-    public boolean equals(Object obj) {
-        if (obj == this)
-            return true;
-
-        if (! (obj instanceof FilePermission))
-            return false;
-
-        FilePermission that = (FilePermission) obj;
-
-        return (this.mask == that.mask) &&
-            this.cpath.equals(that.cpath) &&
-            (this.directory == that.directory) &&
-            (this.recursive == that.recursive);
-    }
-
-    /**
-     * Returns the hash code value for this object.
-     *
-     * @return a hash code value for this object.
-     */
-
-    public int hashCode() {
-        return this.cpath.hashCode();
-    }
-
-    /**
-     * Converts an actions String to an actions mask.
-     *
-     * @param action the action string.
-     * @return the actions mask.
-     */
-    private static int getMask(String actions) {
-
-        int mask = NONE;
-
-        // Null action valid?
-        if (actions == null) {
-            return mask;
-        }
-        // Check against use of constants (used heavily within the JDK)
-        if (actions == SecurityConstants.FILE_READ_ACTION) {
-            return READ;
-        } else if (actions == SecurityConstants.FILE_WRITE_ACTION) {
-            return WRITE;
-        } else if (actions == SecurityConstants.FILE_EXECUTE_ACTION) {
-            return EXECUTE;
-        } else if (actions == SecurityConstants.FILE_DELETE_ACTION) {
-            return DELETE;
-        } else if (actions == SecurityConstants.FILE_READLINK_ACTION) {
-            return READLINK;
-        }
-
-        char[] a = actions.toCharArray();
-
-        int i = a.length - 1;
-        if (i < 0)
-            return mask;
-
-        while (i != -1) {
-            char c;
-
-            // skip whitespace
-            while ((i!=-1) && ((c = a[i]) == ' ' ||
-                               c == '\r' ||
-                               c == '\n' ||
-                               c == '\f' ||
-                               c == '\t'))
-                i--;
-
-            // check for the known strings
-            int matchlen;
-
-            if (i >= 3 && (a[i-3] == 'r' || a[i-3] == 'R') &&
-                          (a[i-2] == 'e' || a[i-2] == 'E') &&
-                          (a[i-1] == 'a' || a[i-1] == 'A') &&
-                          (a[i] == 'd' || a[i] == 'D'))
-            {
-                matchlen = 4;
-                mask |= READ;
-
-            } else if (i >= 4 && (a[i-4] == 'w' || a[i-4] == 'W') &&
-                                 (a[i-3] == 'r' || a[i-3] == 'R') &&
-                                 (a[i-2] == 'i' || a[i-2] == 'I') &&
-                                 (a[i-1] == 't' || a[i-1] == 'T') &&
-                                 (a[i] == 'e' || a[i] == 'E'))
-            {
-                matchlen = 5;
-                mask |= WRITE;
-
-            } else if (i >= 6 && (a[i-6] == 'e' || a[i-6] == 'E') &&
-                                 (a[i-5] == 'x' || a[i-5] == 'X') &&
-                                 (a[i-4] == 'e' || a[i-4] == 'E') &&
-                                 (a[i-3] == 'c' || a[i-3] == 'C') &&
-                                 (a[i-2] == 'u' || a[i-2] == 'U') &&
-                                 (a[i-1] == 't' || a[i-1] == 'T') &&
-                                 (a[i] == 'e' || a[i] == 'E'))
-            {
-                matchlen = 7;
-                mask |= EXECUTE;
-
-            } else if (i >= 5 && (a[i-5] == 'd' || a[i-5] == 'D') &&
-                                 (a[i-4] == 'e' || a[i-4] == 'E') &&
-                                 (a[i-3] == 'l' || a[i-3] == 'L') &&
-                                 (a[i-2] == 'e' || a[i-2] == 'E') &&
-                                 (a[i-1] == 't' || a[i-1] == 'T') &&
-                                 (a[i] == 'e' || a[i] == 'E'))
-            {
-                matchlen = 6;
-                mask |= DELETE;
-
-            } else if (i >= 7 && (a[i-7] == 'r' || a[i-7] == 'R') &&
-                                 (a[i-6] == 'e' || a[i-6] == 'E') &&
-                                 (a[i-5] == 'a' || a[i-5] == 'A') &&
-                                 (a[i-4] == 'd' || a[i-4] == 'D') &&
-                                 (a[i-3] == 'l' || a[i-3] == 'L') &&
-                                 (a[i-2] == 'i' || a[i-2] == 'I') &&
-                                 (a[i-1] == 'n' || a[i-1] == 'N') &&
-                                 (a[i] == 'k' || a[i] == 'K'))
-            {
-                matchlen = 8;
-                mask |= READLINK;
-
-            } else {
-                // parse error
-                throw new IllegalArgumentException(
-                        "invalid permission: " + actions);
-            }
-
-            // make sure we didn't just match the tail of a word
-            // like "ackbarfaccept".  Also, skip to the comma.
-            boolean seencomma = false;
-            while (i >= matchlen && !seencomma) {
-                switch(a[i-matchlen]) {
-                case ',':
-                    seencomma = true;
-                    /*FALLTHROUGH*/
-                case ' ': case '\r': case '\n':
-                case '\f': case '\t':
-                    break;
-                default:
-                    throw new IllegalArgumentException(
-                            "invalid permission: " + actions);
-                }
-                i--;
-            }
-
-            // point i at the location of the comma minus one (or -1).
-            i -= matchlen;
-        }
-
-        return mask;
-    }
-
-    /**
-     * Return the current action mask. Used by the FilePermissionCollection.
-     *
-     * @return the actions mask.
-     */
-
-    int getMask() {
-        return mask;
-    }
-
-    /**
-     * Return the canonical string representation of the actions.
-     * Always returns present actions in the following order:
-     * read, write, execute, delete, readlink.
-     *
-     * @return the canonical string representation of the actions.
-     */
-    private static String getActions(int mask)
-    {
-        StringBuilder sb = new StringBuilder();
-        boolean comma = false;
-
-        if ((mask & READ) == READ) {
-            comma = true;
-            sb.append("read");
-        }
-
-        if ((mask & WRITE) == WRITE) {
-            if (comma) sb.append(',');
-            else comma = true;
-            sb.append("write");
-        }
-
-        if ((mask & EXECUTE) == EXECUTE) {
-            if (comma) sb.append(',');
-            else comma = true;
-            sb.append("execute");
-        }
-
-        if ((mask & DELETE) == DELETE) {
-            if (comma) sb.append(',');
-            else comma = true;
-            sb.append("delete");
-        }
-
-        if ((mask & READLINK) == READLINK) {
-            if (comma) sb.append(',');
-            else comma = true;
-            sb.append("readlink");
-        }
-
-        return sb.toString();
-    }
-
-    /**
-     * Returns the "canonical string representation" of the actions.
-     * That is, this method always returns present actions in the following order:
-     * read, write, execute, delete, readlink. For example, if this FilePermission
-     * object allows both write and read actions, a call to <code>getActions</code>
-     * will return the string "read,write".
-     *
-     * @return the canonical string representation of the actions.
-     */
-    public String getActions()
-    {
-        if (actions == null)
-            actions = getActions(this.mask);
-
-        return actions;
-    }
-
-
-    /**
-     * Returns a new PermissionCollection object for storing FilePermission
-     * objects.
-     * <p>
-     * FilePermission objects must be stored in a manner that allows them
-     * to be inserted into the collection in any order, but that also enables the
-     * PermissionCollection <code>implies</code>
-     * method to be implemented in an efficient (and consistent) manner.
-     *
-     * <p>For example, if you have two FilePermissions:
-     * <OL>
-     * <LI>  <code>"/tmp/-", "read"</code>
-     * <LI>  <code>"/tmp/scratch/foo", "write"</code>
-     * </OL>
-     *
-     * <p>and you are calling the <code>implies</code> method with the FilePermission:
-     *
-     * <pre>
-     *   "/tmp/scratch/foo", "read,write",
-     * </pre>
-     *
-     * then the <code>implies</code> function must
-     * take into account both the "/tmp/-" and "/tmp/scratch/foo"
-     * permissions, so the effective permission is "read,write",
-     * and <code>implies</code> returns true. The "implies" semantics for
-     * FilePermissions are handled properly by the PermissionCollection object
-     * returned by this <code>newPermissionCollection</code> method.
-     *
-     * @return a new PermissionCollection object suitable for storing
-     * FilePermissions.
-     */
-
-    public PermissionCollection newPermissionCollection() {
-        return new FilePermissionCollection();
-    }
-
-    /**
-     * WriteObject is called to save the state of the FilePermission
-     * to a stream. The actions are serialized, and the superclass
-     * takes care of the name.
-     */
-    private void writeObject(ObjectOutputStream s)
-        throws IOException
-    {
-        // Write out the actions. The superclass takes care of the name
-        // call getActions to make sure actions field is initialized
-        if (actions == null)
-            getActions();
-        s.defaultWriteObject();
-    }
-
-    /**
-     * readObject is called to restore the state of the FilePermission from
-     * a stream.
-     */
-    private void readObject(ObjectInputStream s)
-         throws IOException, ClassNotFoundException
-    {
-        // Read in the actions, then restore everything else by calling init.
-        s.defaultReadObject();
-        init(getMask(actions));
-    }
-}
-
-/**
- * A FilePermissionCollection stores a set of FilePermission permissions.
- * FilePermission objects
- * must be stored in a manner that allows them to be inserted in any
- * order, but enable the implies function to evaluate the implies
- * method.
- * For example, if you have two FilePermissions:
- * <OL>
- * <LI> "/tmp/-", "read"
- * <LI> "/tmp/scratch/foo", "write"
- * </OL>
- * And you are calling the implies function with the FilePermission:
- * "/tmp/scratch/foo", "read,write", then the implies function must
- * take into account both the /tmp/- and /tmp/scratch/foo
- * permissions, so the effective permission is "read,write".
- *
- * @see java.security.Permission
- * @see java.security.Permissions
- * @see java.security.PermissionCollection
- *
- *
- * @author Marianne Mueller
- * @author Roland Schemers
- *
- * @serial include
- *
- */
-
-final class FilePermissionCollection extends PermissionCollection
-implements Serializable {
-
-    // Not serialized; see serialization section at end of class
-    private transient List<Permission> perms;
-
-    /**
-     * Create an empty FilePermissions object.
-     *
-     */
-
-    public FilePermissionCollection() {
-        perms = new ArrayList<Permission>();
-    }
-
-    /**
-     * Adds a permission to the FilePermissions. The key for the hash is
-     * permission.path.
-     *
-     * @param permission the Permission object to add.
-     *
-     * @exception IllegalArgumentException - if the permission is not a
-     *                                       FilePermission
-     *
-     * @exception SecurityException - if this FilePermissionCollection object
-     *                                has been marked readonly
-     */
-
-    public void add(Permission permission)
-    {
-        if (! (permission instanceof FilePermission))
-            throw new IllegalArgumentException("invalid permission: "+
-                                               permission);
-        if (isReadOnly())
-            throw new SecurityException(
-                "attempt to add a Permission to a readonly PermissionCollection");
-
-        synchronized (this) {
-            perms.add(permission);
-        }
-    }
-
-    /**
-     * Check and see if this set of permissions implies the permissions
-     * expressed in "permission".
-     *
-     * @param p the Permission object to compare
-     *
-     * @return true if "permission" is a proper subset of a permission in
-     * the set, false if not.
-     */
-
-    public boolean implies(Permission permission)
-    {
-        if (! (permission instanceof FilePermission))
-                return false;
-
-        FilePermission fp = (FilePermission) permission;
-
-        int desired = fp.getMask();
-        int effective = 0;
-        int needed = desired;
-
-        synchronized (this) {
-            int len = perms.size();
-            for (int i = 0; i < len; i++) {
-                FilePermission x = (FilePermission) perms.get(i);
-                if (((needed & x.getMask()) != 0) && x.impliesIgnoreMask(fp)) {
-                    effective |=  x.getMask();
-                    if ((effective & desired) == desired)
-                        return true;
-                    needed = (desired ^ effective);
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Returns an enumeration of all the FilePermission objects in the
-     * container.
-     *
-     * @return an enumeration of all the FilePermission objects.
-     */
-
-    public Enumeration elements() {
-        // Convert Iterator into Enumeration
-        synchronized (this) {
-            return Collections.enumeration(perms);
-        }
-    }
-
-    private static final long serialVersionUID = 2202956749081564585L;
-
-    // Need to maintain serialization interoperability with earlier releases,
-    // which had the serializable field:
-    //    private Vector permissions;
-
-    /**
-     * @serialField permissions java.util.Vector
-     *     A list of FilePermission objects.
-     */
-    private static final ObjectStreamField[] serialPersistentFields = {
-        new ObjectStreamField("permissions", Vector.class),
-    };
-
-    /**
-     * @serialData "permissions" field (a Vector containing the FilePermissions).
-     */
-    /*
-     * Writes the contents of the perms field out as a Vector for
-     * serialization compatibility with earlier releases.
-     */
-    private void writeObject(ObjectOutputStream out) throws IOException {
-        // Don't call out.defaultWriteObject()
-
-        // Write out Vector
-        Vector<Permission> permissions = new Vector<Permission>(perms.size());
-        synchronized (this) {
-            permissions.addAll(perms);
-        }
-
-        ObjectOutputStream.PutField pfields = out.putFields();
-        pfields.put("permissions", permissions);
-        out.writeFields();
-    }
-
-    /*
-     * Reads in a Vector of FilePermissions and saves them in the perms field.
-     */
-    @SuppressWarnings("unchecked")
-    private void readObject(ObjectInputStream in) throws IOException,
-    ClassNotFoundException {
-        // Don't call defaultReadObject()
-
-        // Read in serialized fields
-        ObjectInputStream.GetField gfields = in.readFields();
-
-        // Get the one we want
-        Vector<Permission> permissions = (Vector<Permission>)gfields.get("permissions", null);
-        perms = new ArrayList<Permission>(permissions.size());
-        perms.addAll(permissions);
-    }
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/io/Inputs.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/io/Inputs.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,5 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +23,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.io;
+package java.io;
 
 import java.io.Closeable;
 import java.io.FileInputStream;
@@ -41,11 +40,11 @@
 import java.util.List;
 
 
-import org.classpath.icedtea.java.nio.file.FileRef;
+import java.nio.file.FileRef;
 
-import org.classpath.icedtea.java.nio.file.attribute.Attributes;
+import java.nio.file.attribute.Attributes;
 
-import org.classpath.icedtea.java.util.Scanner;
+import java.util.Scanner;
 
 /**
  * {@note experimental}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/io/Outputs.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/io/Outputs.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,5 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +23,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.io;
+package java.io;
 
 import java.io.BufferedWriter;
 import java.io.FileOutputStream;
@@ -40,11 +39,11 @@
 import java.util.Arrays;
 import java.util.List;
 
-import org.classpath.icedtea.java.nio.file.FileRef;
+import java.nio.file.FileRef;
 
-import static org.classpath.icedtea.java.nio.file.StandardOpenOption.CREATE;
-import static org.classpath.icedtea.java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
-import static org.classpath.icedtea.java.nio.file.StandardOpenOption.WRITE;
+import static java.nio.file.StandardOpenOption.CREATE;
+import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
+import static java.nio.file.StandardOpenOption.WRITE;
 
 /**
  * {@note experimental}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/net/ProtocolFamily.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.net;
-
-/**
- * Represents a family of communication protocols.
- *
- * @since 1.7
- */
-
-public interface ProtocolFamily {
-    /**
-     * Returns the name of the protocol family.
-     */
-    String name();
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/net/SocketOption.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-/*
- * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.net;
-
-/**
- * A socket option associated with a socket.
- *
- * <p> In the {@link java.nio.channels channels} package, the {@link
- * java.nio.channels.NetworkChannel} interface defines the {@link
- * java.nio.channels.NetworkChannel#setOption(SocketOption,Object) setOption}
- * and {@link java.nio.channels.NetworkChannel#getOption(SocketOption) getOption}
- * methods to set and query the channel's socket options.
- *
- * @param   <T>     The type of the socket option value.
- *
- * @since 1.7
- *
- * @see StandardSocketOption
- */
-
-public interface SocketOption<T> {
-
-    /**
-     * Returns the name of the socket option.
-     */
-    String name();
-
-    /**
-     * Returns the type of the socket option value.
-     */
-    Class<T> type();
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/net/StandardProtocolFamily.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.net;
-
-/**
- * Defines the standard families of communication protocols.
- *
- * @since 1.7
- */
-
-public enum StandardProtocolFamily implements ProtocolFamily {
-
-    /**
-     * Internet Protocol Version 4 (IPv4)
-     */
-    INET,
-
-    /**
-     * Internet Protocol Version 6 (IPv6)
-     */
-    INET6
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/net/StandardSocketOption.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,370 +0,0 @@
-/*
- * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.net;
-
-import java.net.NetworkInterface;
-
-/**
- * Defines the <em>standard</em> socket options.
- *
- * <p> The {@link SocketOption#name name} of each socket option defined by this
- * class is its field name.
- *
- * <p> In this release, the socket options defined here are used by {@link
- * java.nio.channels.NetworkChannel network} channels in the {@link
- * java.nio.channels channels} package.
- *
- * @since 1.7
- */
-
-public final class StandardSocketOption {
-    private StandardSocketOption() { }
-
-    // -- SOL_SOCKET --
-
-    /**
-     * Allow transmission of broadcast datagrams.
-     *
-     * <p> The value of this socket option is a {@code Boolean} that represents
-     * whether the option is enabled or disabled. The option is specific to
-     * datagram-oriented sockets sending to {@link java.net.Inet4Address IPv4}
-     * broadcast addresses. When the socket option is enabled then the socket
-     * can be used to send <em>broadcast datagrams</em>.
-     *
-     * <p> The initial value of this socket option is {@code FALSE}. The socket
-     * option may be enabled or disabled at any time. Some operating systems may
-     * require that the Java virtual machine be started with implementation
-     * specific privileges to enable this option or send broadcast datagrams.
-     *
-     * @see <a href="http://www.ietf.org/rfc/rfc919.txt">RFC&nbsp;929:
-     * Broadcasting Internet Datagrams</a>
-     * @see DatagramSocket#setBroadcast
-     */
-    public static final SocketOption<Boolean> SO_BROADCAST =
-        new StdSocketOption<Boolean>("SO_BROADCAST", Boolean.class);
-
-    /**
-     * Keep connection alive.
-     *
-     * <p> The value of this socket option is a {@code Boolean} that represents
-     * whether the option is enabled or disabled. When the {@code SO_KEEPALIVE}
-     * option is enabled the operating system may use a <em>keep-alive</em>
-     * mechanism to periodically probe the other end of a connection when the
-     * connection is otherwise idle. The exact semantics of the keep alive
-     * mechanism is system dependent and therefore unspecified.
-     *
-     * <p> The initial value of this socket option is {@code FALSE}. The socket
-     * option may be enabled or disabled at any time.
-     *
-     * @see <a href="http://www.ietf.org/rfc/rfc1122.txt">RFC&nbsp;1122
-     * Requirements for Internet Hosts -- Communication Layers</a>
-     * @see Socket#setKeepAlive
-     */
-    public static final SocketOption<Boolean> SO_KEEPALIVE =
-        new StdSocketOption<Boolean>("SO_KEEPALIVE", Boolean.class);
-
-    /**
-     * The size of the socket send buffer.
-     *
-     * <p> The value of this socket option is an {@code Integer} that is the
-     * size of the socket send buffer in bytes. The socket send buffer is an
-     * output buffer used by the networking implementation. It may need to be
-     * increased for high-volume connections. The value of the socket option is
-     * a <em>hint</em> to the implementation to size the buffer and the actual
-     * size may differ. The socket option can be queried to retrieve the actual
-     * size.
-     *
-     * <p> For datagram-oriented sockets, the size of the send buffer may limit
-     * the size of the datagrams that may be sent by the socket. Whether
-     * datagrams larger than the buffer size are sent or discarded is system
-     * dependent.
-     *
-     * <p> The initial/default size of the socket send buffer and the range of
-     * allowable values is system dependent although a negative size is not
-     * allowed. An attempt to set the socket send buffer to larger than its
-     * maximum size causes it to be set to its maximum size.
-     *
-     * <p> An implementation allows this socket option to be set before the
-     * socket is bound or connected. Whether an implementation allows the
-     * socket send buffer to be changed after the socket is bound is system
-     * dependent.
-     *
-     * @see Socket#setSendBufferSize
-     */
-    public static final SocketOption<Integer> SO_SNDBUF =
-        new StdSocketOption<Integer>("SO_SNDBUF", Integer.class);
-
-
-    /**
-     * The size of the socket receive buffer.
-     *
-     * <p> The value of this socket option is an {@code Integer} that is the
-     * size of the socket receive buffer in bytes. The socket receive buffer is
-     * an input buffer used by the networking implementation. It may need to be
-     * increased for high-volume connections or decreased to limit the possible
-     * backlog of incoming data. The value of the socket option is a
-     * <em>hint</em> to the implementation to size the buffer and the actual
-     * size may differ.
-     *
-     * <p> For datagram-oriented sockets, the size of the receive buffer may
-     * limit the size of the datagrams that can be received. Whether datagrams
-     * larger than the buffer size can be received is system dependent.
-     * Increasing the socket receive buffer may be important for cases where
-     * datagrams arrive in bursts faster than they can be processed.
-     *
-     * <p> In the case of stream-oriented sockets and the TCP/IP protocol, the
-     * size of the socket receive buffer may be used when advertising the size
-     * of the TCP receive window to the remote peer.
-     *
-     * <p> The initial/default size of the socket receive buffer and the range
-     * of allowable values is system dependent although a negative size is not
-     * allowed. An attempt to set the socket receive buffer to larger than its
-     * maximum size causes it to be set to its maximum size.
-     *
-     * <p> An implementation allows this socket option to be set before the
-     * socket is bound or connected. Whether an implementation allows the
-     * socket receive buffer to be changed after the socket is bound is system
-     * dependent.
-     *
-     * @see <a href="http://www.ietf.org/rfc/rfc1323.txt">RFC&nbsp;1323: TCP
-     * Extensions for High Performance</a>
-     * @see Socket#setReceiveBufferSize
-     * @see ServerSocket#setReceiveBufferSize
-     */
-    public static final SocketOption<Integer> SO_RCVBUF =
-        new StdSocketOption<Integer>("SO_RCVBUF", Integer.class);
-
-    /**
-     * Re-use address.
-     *
-     * <p> The value of this socket option is a {@code Boolean} that represents
-     * whether the option is enabled or disabled. The exact semantics of this
-     * socket option are socket type and system dependent.
-     *
-     * <p> In the case of stream-oriented sockets, this socket option will
-     * usually determine whether the socket can be bound to a socket address
-     * when a previous connection involving that socket address is in the
-     * <em>TIME_WAIT</em> state. On implementations where the semantics differ,
-     * and the socket option is not required to be enabled in order to bind the
-     * socket when a previous connection is in this state, then the
-     * implementation may choose to ignore this option.
-     *
-     * <p> For datagram-oriented sockets the socket option is used to allow
-     * multiple programs bind to the same address. This option should be enabled
-     * when the socket is to be used for Internet Protocol (IP) multicasting.
-     *
-     * <p> An implementation allows this socket option to be set before the
-     * socket is bound or connected. Changing the value of this socket option
-     * after the socket is bound has no effect. The default value of this
-     * socket option is system dependent.
-     *
-     * @see <a href="http://www.ietf.org/rfc/rfc793.txt">RFC&nbsp;793: Transmission
-     * Control Protocol</a>
-     * @see ServerSocket#setReuseAddress
-     */
-    public static final SocketOption<Boolean> SO_REUSEADDR =
-        new StdSocketOption<Boolean>("SO_REUSEADDR", Boolean.class);
-
-    /**
-     * Linger on close if data is present.
-     *
-     * <p> The value of this socket option is an {@code Integer} that controls
-     * the action taken when unsent data is queued on the socket and a method
-     * to close the socket is invoked. If the value of the socket option is zero
-     * or greater, then it represents a timeout value, in seconds, known as the
-     * <em>linger interval</em>. The linger interval is the timeout for the
-     * {@code close} method to block while the operating system attempts to
-     * transmit the unsent data or it decides that it is unable to transmit the
-     * data. If the value of the socket option is less than zero then the option
-     * is disabled. In that case the {@code close} method does not wait until
-     * unsent data is transmitted; if possible the operating system will transmit
-     * any unsent data before the connection is closed.
-     *
-     * <p> This socket option is intended for use with sockets that are configured
-     * in {@link java.nio.channels.SelectableChannel#isBlocking() blocking} mode
-     * only. The behavior of the {@code close} method when this option is
-     * enabled on a non-blocking socket is not defined.
-     *
-     * <p> The initial value of this socket option is a negative value, meaning
-     * that the option is disabled. The option may be enabled, or the linger
-     * interval changed, at any time. The maximum value of the linger interval
-     * is system dependent. Setting the linger interval to a value that is
-     * greater than its maximum value causes the linger interval to be set to
-     * its maximum value.
-     *
-     * @see Socket#setSoLinger
-     */
-    public static final SocketOption<Integer> SO_LINGER =
-        new StdSocketOption<Integer>("SO_LINGER", Integer.class);
-
-
-    // -- IPPROTO_IP --
-
-    /**
-     * The Type of Service (ToS) octet in the Internet Protocol (IP) header.
-     *
-     * <p> The value of this socket option is an {@code Integer} representing
-     * the value of the ToS octet in IP packets sent by sockets to an {@link
-     * StandardProtocolFamily#INET IPv4} socket. The interpretation of the ToS
-     * octet is network specific and is not defined by this class. Further
-     * information on the ToS octet can be found in <a
-     * href="http://www.ietf.org/rfc/rfc1349.txt">RFC&nbsp;1349</a> and <a
-     * href="http://www.ietf.org/rfc/rfc2474.txt">RFC&nbsp;2474</a>. The value
-     * of the socket option is a <em>hint</em>. An implementation may ignore the
-     * value, or ignore specific values.
-     *
-     * <p> The initial/default value of the TOS field in the ToS octet is
-     * implementation specific but will typically be {@code 0}. For
-     * datagram-oriented sockets the option may be configured at any time after
-     * the socket has been bound. The new value of the octet is used when sending
-     * subsequent datagrams. It is system dependent whether this option can be
-     * queried or changed prior to binding the socket.
-     *
-     * <p> The behavior of this socket option on a stream-oriented socket, or an
-     * {@link StandardProtocolFamily#INET6 IPv6} socket, is not defined in this
-     * release.
-     *
-     * @see DatagramSocket#setTrafficClass
-     */
-    public static final SocketOption<Integer> IP_TOS =
-        new StdSocketOption<Integer>("IP_TOS", Integer.class);
-
-    /**
-     * The network interface for Internet Protocol (IP) multicast datagrams.
-     *
-     * <p> The value of this socket option is a {@link NetworkInterface} that
-     * represents the outgoing interface for multicast datagrams sent by the
-     * datagram-oriented socket. For {@link StandardProtocolFamily#INET6 IPv6}
-     * sockets then it is system dependent whether setting this option also
-     * sets the outgoing interface for multlicast datagrams sent to IPv4
-     * addresses.
-     *
-     * <p> The initial/default value of this socket option may be {@code null}
-     * to indicate that outgoing interface will be selected by the operating
-     * system, typically based on the network routing tables. An implementation
-     * allows this socket option to be set after the socket is bound. Whether
-     * the socket option can be queried or changed prior to binding the socket
-     * is system dependent.
-     *
-     * @see java.nio.channels.MulticastChannel
-     * @see MulticastSocket#setInterface
-     */
-    public static final SocketOption<NetworkInterface> IP_MULTICAST_IF =
-        new StdSocketOption<NetworkInterface>("IP_MULTICAST_IF", NetworkInterface.class);
-
-    /**
-     * The <em>time-to-live</em> for Internet Protocol (IP) multicast datagrams.
-     *
-     * <p> The value of this socket option is an {@code Integer} in the range
-     * <tt>0&nbsp;<=&nbsp;value&nbsp;<=&nbsp;255</tt>. It is used to control
-     * the scope of multicast datagrams sent by the datagram-oriented socket.
-     * In the case of an {@link StandardProtocolFamily#INET IPv4} socket
-     * the option is the time-to-live (TTL) on multicast datagrams sent by the
-     * socket. Datagrams with a TTL of zero are not transmitted on the network
-     * but may be delivered locally. In the case of an {@link
-     * StandardProtocolFamily#INET6 IPv6} socket the option is the
-     * <em>hop limit</em> which is number of <em>hops</em> that the datagram can
-     * pass through before expiring on the network. For IPv6 sockets it is
-     * system dependent whether the option also sets the <em>time-to-live</em>
-     * on multicast datagrams sent to IPv4 addresses.
-     *
-     * <p> The initial/default value of the time-to-live setting is typically
-     * {@code 1}. An implementation allows this socket option to be set after
-     * the socket is bound. Whether the socket option can be queried or changed
-     * prior to binding the socket is system dependent.
-     *
-     * @see java.nio.channels.MulticastChannel
-     * @see MulticastSocket#setTimeToLive
-     */
-    public static final SocketOption<Integer> IP_MULTICAST_TTL =
-        new StdSocketOption<Integer>("IP_MULTICAST_TTL", Integer.class);
-
-    /**
-     * Loopback for Internet Protocol (IP) multicast datagrams.
-     *
-     * <p> The value of this socket option is a {@code Boolean} that controls
-     * the <em>loopback</em> of multicast datagrams. The value of the socket
-     * option represents if the option is enabled or disabled.
-     *
-     * <p> The exact semantics of this socket options are system dependent.
-     * In particular, it is system dependent whether the loopback applies to
-     * multicast datagrams sent from the socket or received by the socket.
-     * For {@link StandardProtocolFamily#INET6 IPv6} sockets then it is
-     * system dependent whether the option also applies to multicast datagrams
-     * sent to IPv4 addresses.
-     *
-     * <p> The initial/default value of this socket option is {@code TRUE}. An
-     * implementation allows this socket option to be set after the socket is
-     * bound. Whether the socket option can be queried or changed prior to
-     * binding the socket is system dependent.
-     *
-     * @see java.nio.channels.MulticastChannel
-     *  @see MulticastSocket#setLoopbackMode
-     */
-    public static final SocketOption<Boolean> IP_MULTICAST_LOOP =
-        new StdSocketOption<Boolean>("IP_MULTICAST_LOOP", Boolean.class);
-
-
-    // -- IPPROTO_TCP --
-
-    /**
-     * Disable the Nagle algorithm.
-     *
-     * <p> The value of this socket option is a {@code Boolean} that represents
-     * whether the option is enabled or disabled. The socket option is specific to
-     * stream-oriented sockets using the TCP/IP protocol. TCP/IP uses an algorithm
-     * known as <em>The Nagle Algorithm</em> to coalesce short segments and
-     * improve network efficiency.
-     *
-     * <p> The default value of this socket option is {@code FALSE}. The
-     * socket option should only be enabled in cases where it is known that the
-     * coalescing impacts performance. The socket option may be enabled at any
-     * time. In other words, the Nagle Algorithm can be disabled. Once the option
-     * is enabled, it is system dependent whether it can be subsequently
-     * disabled. If it cannot, then invoking the {@code setOption} method to
-     * disable the option has no effect.
-     *
-     * @see <a href="http://www.ietf.org/rfc/rfc1122.txt">RFC&nbsp;1122:
-     * Requirements for Internet Hosts -- Communication Layers</a>
-     * @see Socket#setTcpNoDelay
-     */
-    public static final SocketOption<Boolean> TCP_NODELAY =
-        new StdSocketOption<Boolean>("TCP_NODELAY", Boolean.class);
-
-
-    private static class StdSocketOption<T> implements SocketOption<T> {
-        private final String name;
-        private final Class<T> type;
-        StdSocketOption(String name, Class<T> type) {
-            this.name = name;
-            this.type = type;
-        }
- public String name() { return name; }
- public Class<T> type() { return type; }
- public String toString() { return name; }
-    }
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousByteChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousByteChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.nio.ByteBuffer;
 import java.util.concurrent.Future;

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.io.IOException;
 import java.nio.channels.Channel;

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannelGroup.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousChannelGroup.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,12 +24,12 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.io.IOException;
 import java.util.concurrent.*;
 
-import org.classpath.icedtea.java.nio.channels.spi.AsynchronousChannelProvider;
+import java.nio.channels.spi.AsynchronousChannelProvider;
 
 /**
  * A grouping of asynchronous channels for the purpose of resource sharing.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousDatagramChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousDatagramChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.Future;
@@ -32,10 +32,10 @@
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
 
-import org.classpath.icedtea.java.net.ProtocolFamily;
-import org.classpath.icedtea.java.net.SocketOption;
+import java.net.ProtocolFamily;
+import java.net.SocketOption;
 
-import org.classpath.icedtea.java.nio.channels.spi.AsynchronousChannelProvider;
+import java.nio.channels.spi.AsynchronousChannelProvider;
 
 /**
  * An asynchronous channel for datagram-oriented sockets.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousFileChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousFileChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.nio.ByteBuffer;
 import java.io.IOException;
@@ -34,10 +34,10 @@
 import java.util.HashSet;
 import java.util.Collections;
 
-import org.classpath.icedtea.java.nio.file.OpenOption;
-import org.classpath.icedtea.java.nio.file.Path;
-import org.classpath.icedtea.java.nio.file.attribute.FileAttribute;
-import org.classpath.icedtea.java.nio.file.spi.FileSystemProvider;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+import java.nio.file.attribute.FileAttribute;
+import java.nio.file.spi.FileSystemProvider;
 
 /**
  * An asynchronous channel for reading, writing, and manipulating a file.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,14 +24,14 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.net.SocketAddress;
 import java.util.concurrent.Future;
 import java.io.IOException;
 
-import org.classpath.icedtea.java.net.SocketOption;
-import org.classpath.icedtea.java.nio.channels.spi.AsynchronousChannelProvider;
+import java.net.SocketOption;
+import java.nio.channels.spi.AsynchronousChannelProvider;
 
 /**
  * An asynchronous channel for stream-oriented listening sockets.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/AsynchronousSocketChannel.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.Future;
@@ -32,8 +32,8 @@
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
 
-import org.classpath.icedtea.java.net.SocketOption;
-import org.classpath.icedtea.java.nio.channels.spi.AsynchronousChannelProvider;
+import java.net.SocketOption;
+import java.nio.channels.spi.AsynchronousChannelProvider;
 
 /**
  * An asynchronous channel for stream-oriented connecting sockets.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/Channels.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,214 +0,0 @@
-/*
- * Copyright 2000-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.nio.channels;
-
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.io.Writer;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.nio.charset.CharsetDecoder;
-import java.nio.charset.CharsetEncoder;
-import java.nio.charset.UnsupportedCharsetException;
-import java.nio.channels.spi.AbstractInterruptibleChannel;
-import java.util.concurrent.ExecutionException;
-import sun.nio.ch.ChannelInputStream;
-import sun.nio.cs.StreamDecoder;
-import sun.nio.cs.StreamEncoder;
-
-
-/**
- * Utility methods for channels and streams.
- *
- * <p> This class defines static methods that support the interoperation of the
- * stream classes of the <tt>{@link java.io}</tt> package with the channel
- * classes of this package.  </p>
- *
- *
- * @author Mark Reinhold
- * @author Mike McCloskey
- * @author JSR-51 Expert Group
- * @since 1.4
- */
-
-public final class Channels {
-
-    private Channels() { }              // No instantiation
-
-    /**
-     * {@note new}
-     * Constructs a stream that reads bytes from the given channel.
-     *
-     * <p> The stream will not be buffered, and it will not support the {@link
-     * InputStream#mark mark} or {@link InputStream#reset reset} methods.  The
-     * stream will be safe for access by multiple concurrent threads.  Closing
-     * the stream will in turn cause the channel to be closed.  </p>
-     *
-     * @param  ch
-     *         The channel from which bytes will be read
-     *
-     * @return  A new input stream
-     *
-     * @since 1.7
-     */
-    public static InputStream newInputStream(final AsynchronousByteChannel ch) {
-        return new InputStream() {
-
-            private ByteBuffer bb = null;
-            private byte[] bs = null;           // Invoker's previous array
-            private byte[] b1 = null;
-
-
-            public synchronized int read() throws IOException {
-                if (b1 == null)
-                    b1 = new byte[1];
-                int n = this.read(b1);
-                if (n == 1)
-                    return b1[0] & 0xff;
-                return -1;
-            }
-
-
-            public synchronized int read(byte[] bs, int off, int len)
-                throws IOException
-            {
-                if ((off < 0) || (off > bs.length) || (len < 0) ||
-                    ((off + len) > bs.length) || ((off + len) < 0)) {
-                    throw new IndexOutOfBoundsException();
-                } else if (len == 0)
-                    return 0;
-
-                ByteBuffer bb = ((this.bs == bs)
-                                 ? this.bb
-                                 : ByteBuffer.wrap(bs));
-                bb.position(off);
-                bb.limit(Math.min(off + len, bb.capacity()));
-                this.bb = bb;
-                this.bs = bs;
-
-                boolean interrupted = false;
-                try {
-                    for (;;) {
-                        try {
-                            return ch.read(bb).get();
-                        } catch (ExecutionException ee) {
-                            throw new IOException(ee.getCause());
-                        } catch (InterruptedException ie) {
-                            interrupted = true;
-                        }
-                    }
-                } finally {
-                    if (interrupted)
-                        Thread.currentThread().interrupt();
-                }
-            }
-
-
-            public void close() throws IOException {
-                ch.close();
-            }
-        };
-    }
-
-    /**
-     * {@note new}
-     * Constructs a stream that writes bytes to the given channel.
-     *
-     * <p> The stream will not be buffered. The stream will be safe for access
-     * by multiple concurrent threads.  Closing the stream will in turn cause
-     * the channel to be closed.  </p>
-     *
-     * @param  ch
-     *         The channel to which bytes will be written
-     *
-     * @return  A new output stream
-     *
-     * @since 1.7
-     */
-    public static OutputStream newOutputStream(final AsynchronousByteChannel ch) {
-        return new OutputStream() {
-
-            private ByteBuffer bb = null;
-            private byte[] bs = null;   // Invoker's previous array
-            private byte[] b1 = null;
-
-
-            public synchronized void write(int b) throws IOException {
-               if (b1 == null)
-                    b1 = new byte[1];
-                b1[0] = (byte)b;
-                this.write(b1);
-            }
-
-
-            public synchronized void write(byte[] bs, int off, int len)
-                throws IOException
-            {
-                if ((off < 0) || (off > bs.length) || (len < 0) ||
-                    ((off + len) > bs.length) || ((off + len) < 0)) {
-                    throw new IndexOutOfBoundsException();
-                } else if (len == 0) {
-                    return;
-                }
-                ByteBuffer bb = ((this.bs == bs)
-                                 ? this.bb
-                                 : ByteBuffer.wrap(bs));
-                bb.limit(Math.min(off + len, bb.capacity()));
-                bb.position(off);
-                this.bb = bb;
-                this.bs = bs;
-
-                boolean interrupted = false;
-                try {
-                    while (bb.remaining() > 0) {
-                        try {
-                            ch.write(bb).get();
-                        } catch (ExecutionException ee) {
-                            throw new IOException(ee.getCause());
-                        } catch (InterruptedException ie) {
-                            interrupted = true;
-                        }
-                    }
-                } finally {
-                    if (interrupted)
-                        Thread.currentThread().interrupt();
-                }
-            }
-
-
-            public void close() throws IOException {
-                ch.close();
-            }
-        };
-    }
-
-
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/CompletionHandler.java	Fri Feb 13 20:38:41 2009 +0000
+++ b/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/CompletionHandler.java	Fri Feb 20 14:50:00 2009 +0000
@@ -1,6 +1,6 @@
 /*
  * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
+ * 
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,7 +24,7 @@
  * have any questions.
  */
 
-package org.classpath.icedtea.java.nio.channels;
+package java.nio.channels;
 
 /**
  * A handler for consuming the result of an asynchronous I/O operation.

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/DatagramChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,223 +0,0 @@
-/*
- * Copyright 2000-2008 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.nio.channels;
-
-import java.io.IOException;
-import java.net.DatagramSocket;
-import java.net.SocketAddress;
-import java.nio.ByteBuffer;
-
-import org.classpath.icedtea.java.net.ProtocolFamily;
-import org.classpath.icedtea.java.net.SocketOption;
-
-import org.classpath.icedtea.java.nio.channels.spi.SelectorProvider;
-
-/**
- * A selectable channel for datagram-oriented sockets.
- *
- * <p> {@note revised} A datagram channel is created by invoking one of the {@link #open open} methods
- * of this class. It is not possible to create a channel for an arbitrary,
- * pre-existing datagram socket. A newly-created datagram channel is open but not
- * connected. A datagram channel need not be connected in order for the {@link #send
- * send} and {@link #receive receive} methods to be used.  A datagram channel may be
- * connected, by invoking its {@link #connect connect} method, in order to
- * avoid the overhead of the security checks are otherwise performed as part of
- * every send and receive operation.  A datagram channel must be connected in
- * order to use the {@link #read(java.nio.ByteBuffer) read} and {@link
- * #write(java.nio.ByteBuffer) write} methods, since those methods do not
- * accept or return socket addresses.
- *
- * <p> Once connected, a datagram channel remains connected until it is
- * disconnected or closed.  Whether or not a datagram channel is connected may
- * be determined by invoking its {@link #isConnected isConnected} method.
- *
- * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
- * setOption} method. A datagram channel to an Internet Protocol socket supports
- * the following options:
- * <blockquote>
- * <table border>
- *   <tr>
- *     <th>Option Name</th>
- *     <th>Description</th>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_SNDBUF SO_SNDBUF} </td>
- *     <td> The size of the socket send buffer </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_RCVBUF SO_RCVBUF} </td>
- *     <td> The size of the socket receive buffer </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_REUSEADDR SO_REUSEADDR} </td>
- *     <td> Re-use address </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#SO_BROADCAST SO_BROADCAST} </td>
- *     <td> Allow transmission of broadcast datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_TOS IP_TOS} </td>
- *     <td> The Type of Service (ToS) octet in the Internet Protocol (IP) header </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_IF IP_MULTICAST_IF} </td>
- *     <td> The network interface for Internet Protocol (IP) multicast datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_TTL
- *       IP_MULTICAST_TTL} </td>
- *     <td> The <em>time-to-live</em> for Internet Protocol (IP) multicast
- *       datagrams </td>
- *   </tr>
- *   <tr>
- *     <td> {@link java.net.StandardSocketOption#IP_MULTICAST_LOOP
- *       IP_MULTICAST_LOOP} </td>
- *     <td> Loopback for Internet Protocol (IP) multicast datagrams </td>
- *   </tr>
- * </table>
- * </blockquote>
- * Additional (implementation specific) options may also be supported.
- *
- * <p> Datagram channels are safe for use by multiple concurrent threads.  They
- * support concurrent reading and writing, though at most one thread may be
- * reading and at most one thread may be writing at any given time.  </p>
- *
- * @author Mark Reinhold
- * @author JSR-51 Expert Group
- * @since 1.4
- * @updated 1.7
- */
-
-public abstract class DatagramChannel
-    extends java.nio.channels.DatagramChannel
-    implements MulticastChannel
-{
-
-    /**
-     * Initializes a new instance of this class.
-     */
-    protected DatagramChannel(SelectorProvider provider) {
-        super(provider);
-    }
-
-    /**
-     * Opens a datagram channel.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * java.nio.channels.spi.SelectorProvider#openDatagramChannel()
-     * openDatagramChannel} method of the system-wide default {@link
-     * java.nio.channels.spi.SelectorProvider} object.  The channel will not be
-     * connected.  </p>
-     *
-     * @return  A new datagram channel
-     *
-     * @throws  IOException
-     *          If an I/O error occurs
-     */
-    public static DatagramChannel open() throws IOException {
-        return SelectorProvider.provider().openDatagramChannel();
-    }
-
-    /**
-     * Opens a datagram channel.
-     *
-     * <p> The {@code family} parameter is used to specify the {@link
-     * ProtocolFamily}. If the datagram channel is to be used for IP multicasing
-     * then this should correspond to the address type of the multicast groups
-     * that this channel will join.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * java.nio.channels.spi.SelectorProvider#openDatagramChannel(ProtocolFamily)
-     * openDatagramChannel} method of the system-wide default {@link
-     * java.nio.channels.spi.SelectorProvider} object.  The channel will not be
-     * connected.
-     *
-     * @param   family
-     *          The protocol family
-     *
-     * @return  A new datagram channel
-     *
-     * @throws  UnsupportedOperationException
-     *          If the specified protocol family is not supported. For example,
-     *          suppose the parameter is specified as {@link
-     *          java.net.StandardProtocolFamily#INET6 StandardProtocolFamily.INET6}
-     *          but IPv6 is not enabled on the platform.
-     * @throws  IOException
-     *          If an I/O error occurs
-     *
-     * @since   1.7
-     */
-    public static DatagramChannel open(ProtocolFamily family) throws IOException {
-        return SelectorProvider.provider().openDatagramChannel(family);
-    }
-
-
-    // -- Socket-specific operations --
-
-    /**
-     * @throws  AlreadyBoundException               {@inheritDoc}
-     * @throws  UnsupportedAddressTypeException     {@inheritDoc}
-     * @throws  ClosedChannelException              {@inheritDoc}
-     * @throws  IOException                         {@inheritDoc}
-     * @throws  SecurityException
-     *          If a security manager has been installed and its {@link
-     *          SecurityManager#checkListen checkListen} method denies the
-     *          operation
-     *
-     * @since 1.7
-     */
-    public abstract DatagramChannel bind(SocketAddress local)
-        throws IOException;
-
-    /**
-     * @throws  IllegalArgumentException                {@inheritDoc}
-     * @throws  ClosedChannelException                  {@inheritDoc}
-     * @throws  IOException                             {@inheritDoc}
-     *
-     * @since 1.7
-     */
-    public abstract <T> DatagramChannel setOption(SocketOption<T> name, T value)
-        throws IOException;
-
-    /**
-     * {@note new}
-     * Returns the remote address to which this channel's socket is connected.
-     *
-     * @return  The remote address; {@code null} if the channel's socket is not
-     *          connected
-     *
-     * @throws  ClosedChannelException
-     *          If the channel is closed
-     * @throws  IOException
-     *          If an I/O error occurs
-     *
-     * @since 1.7
-     */
-    public abstract SocketAddress getRemoteAddress() throws IOException;
-
-}

--- a/overlays/nio2/openjdk/jdk/src/share/classes/java/nio/channels/FileChannel.java	Fri Feb 13 20:38:41 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,404 +0,0 @@
-/*
- * Copyright 2000-2005 Sun Microsystems, Inc.  All Rights Reserved.
- * Copyright 2009 Red Hat, Inc.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Sun designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Sun in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- */
-
-package org.classpath.icedtea.java.nio.channels;
-
-import java.io.*;
-import java.nio.ByteBuffer;
-import java.nio.MappedByteBuffer;
-import java.nio.channels.GatheringByteChannel;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.channels.ScatteringByteChannel;
-import java.nio.channels.WritableByteChannel;
-import java.nio.channels.spi.AbstractInterruptibleChannel;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Collections;
-
-import org.classpath.icedtea.java.nio.file.OpenOption;
-import org.classpath.icedtea.java.nio.file.Path;
-import org.classpath.icedtea.java.nio.file.attribute.FileAttribute;
-import org.classpath.icedtea.java.nio.file.spi.FileSystemProvider;
-
-/**
- * A channel for reading, writing, mapping, and manipulating a file.
- *
- * <p> {@note revised}
- * A file channel is a {@link SeekableByteChannel} that is connected to
- * a file. It has a current <i>position</i> within its file which can
- * be both {@link #position() <i>queried</i>} and {@link #position(long)
- * <i>modified</i>}.  The file itself contains a variable-length sequence
- * of bytes that can be read and written and whose current {@link #size
- * <i>size</i>} can be queried.  The size of the file increases
- * when bytes are written beyond its current size; the size of the file
- * decreases when it is {@link #truncate </code><i>truncated</i><code>}.  The
- * file may also have some associated <i>metadata</i> such as access
- * permissions, content type, and last-modification time; this class does not
- * define methods for metadata access.
- *
- * <p> In addition to the familiar read, write, and close operations of byte
- * channels, this class defines the following file-specific operations: </p>
- *
- * <ul>
- *
- *   <li><p> Bytes may be {@link #read(ByteBuffer, long) read} or
- *   {@link #write(ByteBuffer, long) <i>written</i>} at an absolute
- *   position in a file in a way that does not affect the channel's current
- *   position.  </p></li>
- *
- *   <li><p> A region of a file may be {@link #map <i>mapped</i>}
- *   directly into memory; for large files this is often much more efficient
- *   than invoking the usual <tt>read</tt> or <tt>write</tt> methods.
- *   </p></li>
- *
- *   <li><p> Updates made to a file may be {@link #force <i>forced
- *   out</i>} to the underlying storage device, ensuring that data are not
- *   lost in the event of a system crash.  </p></li>
- *
- *   <li><p> Bytes can be transferred from a file {@link #transferTo <i>to
- *   some other channel</i>}, and {@link #transferFrom <i>vice
- *   versa</i>}, in a way that can be optimized by many operating systems
- *   into a very fast transfer directly to or from the filesystem cache.
- *   </p></li>
- *
- *   <li><p> A region of a file may be {@link FileLock <i>locked</i>}
- *   against access by other programs.  </p></li>
- *
- * </ul>
- *
- * <p> File channels are safe for use by multiple concurrent threads.  The
- * {@link Channel#close close} method may be invoked at any time, as specified
- * by the {@link Channel} interface.  Only one operation that involves the
- * channel's position or can change its file's size may be in progress at any
- * given time; attempts to initiate a second such operation while the first is
- * still in progress will block until the first operation completes.  Other
- * operations, in particular those that take an explicit position, may proceed
- * concurrently; whether they in fact do so is dependent upon the underlying
- * implementation and is therefore unspecified.
- *
- * <p> The view of a file provided by an instance of this class is guaranteed
- * to be consistent with other views of the same file provided by other
- * instances in the same program.  The view provided by an instance of this
- * class may or may not, however, be consistent with the views seen by other
- * concurrently-running programs due to caching performed by the underlying
- * operating system and delays induced by network-filesystem protocols.  This
- * is true regardless of the language in which these other programs are
- * written, and whether they are running on the same machine or on some other
- * machine.  The exact nature of any such inconsistencies are system-dependent
- * and are therefore unspecified.
- *
- * <p> A file channel is created by invoking one of the {@link #open open}
- * methods defined by this class. A file channel can also be obtained from an
- * existing {@link java.io.FileInputStream#getChannel FileInputStream}, {@link
- * java.io.FileOutputStream#getChannel FileOutputStream}, or {@link
- * java.io.RandomAccessFile#getChannel RandomAccessFile} object by invoking
- * that object's <tt>getChannel</tt> method, which returns a file channel that
- * is connected to the same underlying file. Where the file channel is obtained
- * from an existing stream or random access file then the state of the file
- * channel is intimately connected to that of the object whose <tt>getChannel</tt>
- * method returned the channel.  Changing the channel's position, whether
- * explicitly or by reading or writing bytes, will change the file position of
- * the originating object, and vice versa. Changing the file's length via the
- * file channel will change the length seen via the originating object, and vice
- * versa.  Changing the file's content by writing bytes will change the content
- * seen by the originating object, and vice versa.
- *
- * <a name="open-mode"></a> <p> At various points this class specifies that an
- * instance that is "open for reading," "open for writing," or "open for
- * reading and writing" is required.  A channel obtained via the {@link
- * java.io.FileInputStream#getChannel getChannel} method of a {@link
- * java.io.FileInputStream} instance will be open for reading.  A channel
- * obtained via the {@link java.io.FileOutputStream#getChannel getChannel}
- * method of a {@link java.io.FileOutputStream} instance will be open for
- * writing.  Finally, a channel obtained via the {@link
- * java.io.RandomAccessFile#getChannel getChannel} method of a {@link
- * java.io.RandomAccessFile} instance will be open for reading if the instance
- * was created with mode <tt>"r"</tt> and will be open for reading and writing
- * if the instance was created with mode <tt>"rw"</tt>.
- *
- * <a name="append-mode"></a><p> A file channel that is open for writing may be in
- * <i>append mode</i>, for example if it was obtained from a file-output stream
- * that was created by invoking the {@link
- * java.io.FileOutputStream#FileOutputStream(java.io.File,boolean)
- * FileOutputStream(File,boolean)} constructor and passing <tt>true</tt> for
- * the second parameter.  In this mode each invocation of a relative write
- * operation first advances the position to the end of the file and then writes
- * the requested data.  Whether the advancement of the position and the writing
- * of the data are done in a single atomic operation is system-dependent and
- * therefore unspecified.
- *
- * @see java.io.FileInputStream#getChannel()
- * @see java.io.FileOutputStream#getChannel()
- * @see java.io.RandomAccessFile#getChannel()
- *
- * @author Mark Reinhold
- * @author Mike McCloskey
- * @author JSR-51 Expert Group
- * @since 1.4
- * @updated 1.7
- */
-
-public abstract class FileChannel
-    extends java.nio.channels.FileChannel
-    implements SeekableByteChannel
-{
-    /**
-     * Initializes a new instance of this class.
-     */
-    protected FileChannel() { }
-
-    /**
-     * {@note new}
-     * Opens or creates a file, returning a file channel to access the file.
-     *
-     * <p> The {@code options} parameter determines how the file is opened.
-     * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE
-     * WRITE} options determine if the file should be opened for reading and/or
-     * writing. If neither option (or the {@link StandardOpenOption#APPEND APPEND}
-     * option) is contained in the array then the file is opened for reading.
-     * By default reading or writing commences at the beginning of the file.
-     *
-     * <p> In the addition to {@code READ} and {@code WRITE}, the following
-     * options may be present:
-     *
-     * <table border=1 cellpadding=5 summary="">
-     * <tr> <th>Option</th> <th>Description</th> </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#APPEND APPEND} </td>
-     *   <td> If this option is present then the file is opened for writing and
-     *     each invocation of the channel's {@code write} method first advances
-     *     the position to the end of the file and then writes the requested
-     *     data. Whether the advancement of the position and the writing of the
-     *     data are done in a single atomic operation is system-dependent and
-     *     therefore unspecified. This option may not be used in conjunction
-     *     with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td>
-     * </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>
-     *   <td> If this option is present then the existing file is truncated to
-     *   a size of 0 bytes. This option is ignored when the file is opened only
-     *   for reading. </td>
-     * </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>
-     *   <td> If this option is present then a new file is created, failing if
-     *   the file already exists. When creating a file the check for the
-     *   existence of the file and the creation of the file if it does not exist
-     *   is atomic with respect to other file system operations. This option is
-     *   ignored when the file is opened only for reading. </td>
-     * </tr>
-     * <tr>
-     *   <td > {@link StandardOpenOption#CREATE CREATE} </td>
-     *   <td> If this option is present then an existing file is opened if it
-     *   exists, otherwise a new file is created. When creating a file the check
-     *   for the existence of the file and the creation of the file if it does
-     *   not exist is atomic with respect to other file system operations. This
-     *   option is ignored if the {@code CREATE_NEW} option is also present or
-     *   the file is opened only for reading. </td>
-     * </tr>
-     * <tr>
-     *   <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>
-     *   <td> When this option is present then the implementation makes a
-     *   <em>best effort</em> attempt to delete the file when closed by the
-     *   the {@link #close close} method. If the {@code close} method is not
-     *   invoked then a <em>best effort</em> attempt is made to delete the file
-     *   when the Java virtual machine terminates. </td>
-     * </tr>
-     * <tr>
-     *   <td>{@link StandardOpenOption#SPARSE SPARSE} </td>
-     *   <td> When creating a new file this option is a <em>hint</em> that the
-     *   new file will be sparse. This option is ignored when not creating
-     *   a new file. </td>
-     * </tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#SYNC SYNC} </td>
-     *   <td> Requires that every update to the file's content or metadata be
-     *   written synchronously to the underlying storage device. (see <a
-     *   href="../file/package-summary.html#integrity"> Synchronized I/O file
-     *   integrity</a>). </td>
-     * <tr>
-     * <tr>
-     *   <td> {@link StandardOpenOption#DSYNC DSYNC} </td>
-     *   <td> Requires that every update to the file's content be written
-     *   synchronously to the underlying storage device. (see <a
-     *   href="../file/package-summary.html#integrity"> Synchronized I/O file
-     *   integrity</a>). </td>
-     * </tr>
-     * </table>
-     *
-     * <p> An implementation may also support additional options.
-     *
-     * <p> The {@code attrs} parameter is an optional array of file {@link
-     * FileAttribute file-attributes} to set atomically when creating the file.
-     *
-     * <p> The new channel is created by invoking the {@link
-     * FileSystemProvider#newFileChannel newFileChannel} method on the
-     * provider that created the {@code Path}.
-     *
-     * @param   file
-     *          The path of the file to open or create
-     * @param   options
-     *          Options specifying how the file is opened
-     * @param   attrs
-     *          An optional list of file attributes to set atomically when
-     *          creating the file
-     *
-     * @return  A new file channel
-     *
-     * @throws  IllegalArgumentException
-     *          If the set contains an invalid combination of options
-     * @throws  UnsupportedOperationException
-     *          If the {@code file} is associated with a provider that does not
-     *          support creating file channels, or an unsupported open option is
-     *          specified, or the array contains an attribute that cannot be set
-     *          atomically when creating the file
-     * @throws  IOException
-     *          If an I/O error occurs
-     * @throws  SecurityException
-     *          If a security manager is installed and it denies an
-     *          unspecified permission required by the implementation.
-     *          In the case of the default provider, the {@link
-     *          SecurityManager#checkRead(String)} method is invoked to check
-     *          read access if the file is opened for reading. The {@link
-     *          SecurityManager#checkWrite(String)} method is invoked to check
-     *          write access if the file is opened for writing
-     *
-     * @since   1.7
-     */
-    public static FileChannel open(Path file,
-				   Set<? extends OpenOption> options,
-				   FileAttribute<?>... attrs)
-        throws IOException
-    {
-        FileSystemProvider provider = file.getFileSystem().provider();
-        return provider.newFileChannel(file, options, attrs);
-    }
-
-    private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0];
-
-    /**
-     * {@note new}
-     * Opens or creates a file, returning a file channel to access the file.
-     *
-     * <p> An invocation of this method behaves in exactly the same way as the
-     * invocation
-     * <pre>
-     *     fc.{@link #open(Path,Set,FileAttribute[]) open}(file, options, new FileAttribute&lt;?&gt;[0]);
-     * </pre>
-     *
-     * @param   file
-     *          The path of the file to open or create
-     * @param   options
-     *          Options specifying how the file is opened
-     *
-     * @return  A new file channel
-     *
-     * @throws  IllegalArgumentException
-     *          If the set contains an invalid combination of options
-     * @throws  UnsupportedOperationException
-     *          If the {@code file} is associated with a provider that does not
-     *          support creating file channels, or an unsupported open option is
-     *          specified
-     * @throws  IOException
-     *          If an I/O error occurs
-     * @throws  SecurityException
-     *          If a security manager is installed and it denies an
-     *          unspecified permission required by the implementation.
-     *          In the case of the default provider, the {@link
-     *          SecurityManager#checkRead(String)} method is invoked to check
-     *          read access if the file is opened for reading. The {@link
-     *          SecurityManager#checkWrite(String)} method is invoked to check
-     *          write access if the file is opened for writing
-     *
-     * @since   1.7
-     */
-    public static FileChannel open(Path file, OpenOption... options)
-        throws IOException
-    {
-        Set<OpenOption> set = new HashSet<OpenOption>(options.length);
-        Collections.addAll(set, options);
-        return open(file, set, NO_ATTRIBUTES);
-    }
-
-    /**
-     * Sets this channel's file position.
-     *
-     * <p> Setting the position to a value that is greater than the file's
-     * current size is legal but does not change the size of the file.  A later
-     * attempt to read bytes at such a position will immediately return an
-     * end-of-file indication.  A later attempt to write bytes at such a
-     * position will cause the file to be grown to accommodate the new bytes;
-     * the values of any bytes between the previous end-of-file and the
-     * newly-written bytes are unspecified.  </p>
-     *
-     * @param  newPosition
-     *         The new position, a non-negative integer counting
-     *         the number of bytes from the beginning of the file
-     *
-     * @return  This file channel
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     *
-     * @throws  IllegalArgumentException
-     *          If the new position is negative
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract FileChannel positionSBC(long newPosition) throws IOException;
-
-    /**
-     * Truncates this channel's file to the given size.
-     *
-     * <p> If the given size is less than the file's current size then the file
-     * is truncated, discarding any bytes beyond the new end of the file.  If
-     * the given size is greater than or equal to the file's current size then
-     * the file is not modified.  In either case, if this channel's file
-     * position is greater than the given size then it is set to that size.
-     * </p>
-     *
-     * @param  size
-     *         The new size, a non-negative byte count
-     *
-     * @return  This file channel
-     *
-     * @throws  NonWritableChannelException
-     *          If this channel was not opened for writing
-     *
-     * @throws  ClosedChannelException
-     *          If this channel is closed
-     *
-     * @throws  IllegalArgumentException
-     *          If the new size is negative
-     *
-     * @throws  IOException
-     *          If some other I/O error occurs
-     */
-    public abstract FileChannel truncateSBC(long size) throws IOException;
-
-
-}