External library with modifications. fat32-lib.
Signed-off-by: Dan Galpin <dgalpin@google.com>
Change-Id: Ie59bda0c04d629c4b2723f77478957105761e5cf
diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..45f9615
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,23 @@
+# Copyright (C) 2010 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+# Build a host-side library
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src/main/java)
+LOCAL_MODULE := fat32lib
+
+include $(BUILD_HOST_JAVA_LIBRARY)
+
diff --git a/CleanSpec.mk b/CleanSpec.mk
new file mode 100644
index 0000000..b84e1b6
--- /dev/null
+++ b/CleanSpec.mk
@@ -0,0 +1,49 @@
+# Copyright (C) 2007 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# If you don't need to do a full clean build but would like to touch
+# a file or delete some intermediate files, add a clean step to the end
+# of the list. These steps will only be run once, if they haven't been
+# run before.
+#
+# E.g.:
+# $(call add-clean-step, touch -c external/sqlite/sqlite3.h)
+# $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates)
+#
+# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with
+# files that are missing or have been moved.
+#
+# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory.
+# Use $(OUT_DIR) to refer to the "out" directory.
+#
+# If you need to re-do something that's already mentioned, just copy
+# the command and add it to the bottom of the list. E.g., if a change
+# that you made last week required touching a file and a change you
+# made today requires touching the same file, just copy the old
+# touch step and add it to the end of the list.
+#
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+
+# For example:
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates)
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates)
+#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
+#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
+
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
diff --git a/src/main/java/de/waldheinz/fs/AbstractFileSystem.java b/src/main/java/de/waldheinz/fs/AbstractFileSystem.java
new file mode 100644
index 0000000..85be4db
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/AbstractFileSystem.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+
+/**
+ * Abstract class with common things in different FileSystem implementations.
+ *
+ * @author Fabien DUMINY
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public abstract class AbstractFileSystem implements FileSystem {
+ private final boolean readOnly;
+ private boolean closed;
+
+ /**
+ * Creates a new {@code AbstractFileSystem}.
+ *
+ * @param readOnly if the file system should be read-only
+ */
+ public AbstractFileSystem(boolean readOnly) {
+ this.closed = false;
+ this.readOnly = readOnly;
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (!isClosed()) {
+ if (!isReadOnly()) {
+ flush();
+ }
+
+ closed = true;
+ }
+ }
+
+ @Override
+ public final boolean isClosed() {
+ return closed;
+ }
+
+ @Override
+ public final boolean isReadOnly() {
+ return readOnly;
+ }
+
+ /**
+ * Checks if this {@code FileSystem} was already closed, and throws an
+ * exception if it was.
+ *
+ * @throws IllegalStateException if this {@code FileSystem} was
+ * already closed
+ * @see #isClosed()
+ * @see #close()
+ */
+ protected final void checkClosed() throws IllegalStateException {
+ if (isClosed()) {
+ throw new IllegalStateException("file system was already closed");
+ }
+ }
+
+ /**
+ * Checks if this {@code FileSystem} is read-only, and throws an
+ * exception if it is.
+ *
+ * @throws ReadOnlyException if this {@code FileSystem} is read-only
+ * @see #isReadOnly()
+ */
+ protected final void checkReadOnly() throws ReadOnlyException {
+ if (isReadOnly()) {
+ throw new ReadOnlyException();
+ }
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/AbstractFsObject.java b/src/main/java/de/waldheinz/fs/AbstractFsObject.java
new file mode 100644
index 0000000..fea022a
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/AbstractFsObject.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+/**
+ * A base class that helps to implement the {@code FsObject} interface.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @since 0.6
+ */
+public class AbstractFsObject implements FsObject {
+
+ /**
+ * Holds the read-only state of this object.
+ */
+ private final boolean readOnly;
+
+ /**
+ * Remembers if this object still valid.
+ */
+ private boolean valid;
+
+ /**
+ * Creates a new instance of {@code AbstractFsObject} which will be valid
+ * and have the specified read-only state.
+ *
+ * @param readOnly if the new object will be read-only
+ */
+ protected AbstractFsObject(boolean readOnly) {
+ this.valid = true;
+ this.readOnly = readOnly;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @return {@inheritDoc}
+ * @see #checkValid()
+ * @see #invalidate()
+ */
+ @Override
+ public final boolean isValid() {
+ return this.valid;
+ }
+
+ /**
+ * Marks this object as invalid.
+ *
+ * @see #isValid()
+ * @see #checkValid()
+ */
+ protected final void invalidate() {
+ this.valid = false;
+ }
+
+ /**
+ * Convience method to check if this object is still valid and throw an
+ * {@code IllegalStateException} if it is not.
+ *
+ * @throws IllegalStateException if this object was invalidated
+ * @since 0.6
+ * @see #isValid()
+ * @see #invalidate()
+ */
+ protected final void checkValid() throws IllegalStateException {
+ if (!isValid()) throw new IllegalStateException(
+ this + " is not valid");
+ }
+
+ /**
+ * Convience method to check if this object is writable. An object is
+ * writable if it is both, valid and not read-only.
+ *
+ * @throws IllegalStateException if this object was invalidated
+ * @throws ReadOnlyException if this object was created with the read-only
+ * flag set
+ * @since 0.6
+ */
+ protected final void checkWritable()
+ throws IllegalStateException, ReadOnlyException {
+
+ checkValid();
+
+ if (isReadOnly()) {
+ throw new ReadOnlyException();
+ }
+ }
+
+ @Override
+ public final boolean isReadOnly() {
+ return this.readOnly;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/BlockDevice.java b/src/main/java/de/waldheinz/fs/BlockDevice.java
new file mode 100644
index 0000000..88f05c9
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/BlockDevice.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * This is the abstraction used for a device that can hold a {@link FileSystem}.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public interface BlockDevice {
+
+ /**
+ * Gets the total length of this device in bytes.
+ *
+ * @return the total number of bytes on this device
+ * @throws IOException on error getting the size of this device
+ */
+ public abstract long getSize() throws IOException;
+
+ /**
+ * Read a block of data from this device.
+ *
+ * @param devOffset the byte offset where to read the data from
+ * @param dest the destination buffer where to store the data read
+ * @throws IOException on read error
+ */
+ public abstract void read(long devOffset, ByteBuffer dest)
+ throws IOException;
+
+ /**
+ * Writes a block of data to this device.
+ *
+ * @param devOffset the byte offset where to store the data
+ * @param src the source {@code ByteBuffer} to write to the device
+ * @throws ReadOnlyException if this {@code BlockDevice} is read-only
+ * @throws IOException on write error
+ * @throws IllegalArgumentException if the {@code devOffset} is negative
+ * or the write would go beyond the end of the device
+ * @see #isReadOnly()
+ */
+ public abstract void write(long devOffset, ByteBuffer src)
+ throws ReadOnlyException, IOException,
+ IllegalArgumentException;
+
+ /**
+ * Flushes data in caches to the actual storage.
+ *
+ * @throws IOException on write error
+ */
+ public abstract void flush() throws IOException;
+
+ /**
+ * Returns the size of a sector on this device.
+ *
+ * @return the sector size in bytes
+ * @throws IOException on error determining the sector size
+ */
+ public int getSectorSize() throws IOException;
+
+ /**
+ * Closes this {@code BlockDevice}. No methods of this device may be
+ * accesses after this method was called.
+ *
+ * @throws IOException on error closing this device
+ * @see #isClosed()
+ */
+ public void close() throws IOException;
+
+ /**
+ * Checks if this device was already closed. No methods may be called
+ * on a closed device (except this method).
+ *
+ * @return if this device is closed
+ */
+ public boolean isClosed();
+
+ /**
+ * Checks if this {@code BlockDevice} is read-only.
+ *
+ * @return if this {@code BlockDevice} is read-only
+ */
+ public boolean isReadOnly();
+
+}
diff --git a/src/main/java/de/waldheinz/fs/FileSystem.java b/src/main/java/de/waldheinz/fs/FileSystem.java
new file mode 100644
index 0000000..f84baae
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FileSystem.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+
+/**
+ * The interface common to all file system implementations.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public interface FileSystem {
+
+ /**
+ * Gets the root entry of this filesystem. This is usually a directory, but
+ * this is not required.
+ *
+ * @return the file system's root entry
+ * @throws IOException on read error
+ */
+ public FsDirectory getRoot() throws IOException;
+
+ /**
+ * Returns if this {@code FileSystem} is in read-only mode.
+ *
+ * @return if this {@code FileSystem} is read-only
+ */
+ public boolean isReadOnly();
+
+ /**
+ * Close this file system. After a close, all invocations of methods of
+ * this file system or objects created by this file system will throw an
+ * {@link IllegalStateException}.
+ *
+ * @throws IOException on error closing the file system
+ */
+ public void close() throws IOException;
+
+ /**
+ * Returns {@code true} if this file system is closed. If the file system
+ * is closed, no more operations may be performed on it.
+ *
+ * @return if this file system is closed
+ */
+ public boolean isClosed();
+
+ /**
+ * The total size of this file system.
+ *
+ * @return if -1 this feature is unsupported
+ * @throws IOException if an I/O error occurs
+ */
+ public long getTotalSpace() throws IOException;
+
+ /**
+ * The free space of this file system.
+ *
+ * @return if -1 this feature is unsupported
+ * @throws IOException if an I/O error occurs
+ */
+ public long getFreeSpace() throws IOException;
+
+ /**
+ * The usable space of this file system.
+ *
+ * @return if -1 this feature is unsupported
+ * @throws IOException if an I/O error occurs
+ */
+ public long getUsableSpace() throws IOException;
+
+ /**
+ * Flushes any modified file system structures to the underlying storage.
+ *
+ * @throws IOException
+ */
+ public void flush() throws IOException;
+}
diff --git a/src/main/java/de/waldheinz/fs/FileSystemFactory.java b/src/main/java/de/waldheinz/fs/FileSystemFactory.java
new file mode 100644
index 0000000..47cc438
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FileSystemFactory.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import de.waldheinz.fs.fat.FatFileSystem;
+import java.io.IOException;
+
+/**
+ * Factory for {@link FileSystem} instances.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public class FileSystemFactory {
+
+ private FileSystemFactory() { }
+
+ /**
+ * <p>
+ * Creates a new {@link FileSystem} for the specified {@code device}. When
+ * using this method, care must be taken that there is only one
+ * {@code FileSystems} accessing the specified {@link BlockDevice}.
+ * Otherwise severe file system corruption may occur.
+ * </p>
+ *
+ * @param device the device to create the file system for
+ * @param readOnly if the file system should be openend read-only
+ * @return a new {@code FileSystem} instance for the specified device
+ * @throws UnknownFileSystemException if the file system type could
+ * not be determined
+ * @throws IOException on read error
+ */
+ public static FileSystem create(BlockDevice device, boolean readOnly)
+ throws UnknownFileSystemException, IOException {
+
+ return FatFileSystem.read(device, readOnly);
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/FsDirectory.java b/src/main/java/de/waldheinz/fs/FsDirectory.java
new file mode 100644
index 0000000..c3d9b94
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FsDirectory.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+/**
+ * Base class for all {@link FileSystem} directories.
+ *
+ * @author Ewout Prangsma < epr at jnode.org>
+ * @author Matthias Treydte
+ */
+public interface FsDirectory extends Iterable<FsDirectoryEntry>, FsObject {
+
+ /**
+ * Gets an iterator to iterate over the entries of this directory.
+ *
+ * @return the directory iterator
+ */
+ @Override
+ public Iterator<FsDirectoryEntry> iterator();
+
+ /**
+ * Gets the entry with the given name.
+ *
+ * @param name the name of the entry to get
+ * @return the entry, if it existed
+ * @throws IOException on error retrieving the entry
+ */
+ public FsDirectoryEntry getEntry(String name) throws IOException;
+
+ /**
+ * Add a new file with a given name to this directory.
+ *
+ * @param name the name of the file to add
+ * @return the entry pointing to the new file
+ * @throws IOException on error creating the file
+ */
+ public FsDirectoryEntry addFile(String name) throws IOException;
+
+ /**
+ * Add a new (sub-)directory with a given name to this directory.
+ *
+ * @param name the name of the sub-directory to add
+ * @return the entry pointing to the new directory
+ * @throws IOException on error creating the directory
+ */
+ public FsDirectoryEntry addDirectory(String name) throws IOException;
+
+ /**
+ * Remove the entry with the given name from this directory.
+ *
+ * @param name name of the entry to remove
+ * @throws IOException on error deleting the entry
+ */
+ public void remove(String name) throws IOException;
+
+ /**
+ * Save all dirty (unsaved) data to the device.
+ *
+ * @throws IOException on write error
+ */
+ public void flush() throws IOException;
+
+}
diff --git a/src/main/java/de/waldheinz/fs/FsDirectoryEntry.java b/src/main/java/de/waldheinz/fs/FsDirectoryEntry.java
new file mode 100644
index 0000000..c071bfe
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FsDirectoryEntry.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+import java.util.Comparator;
+
+/**
+ * Represents one entry in a {@link FsDirectory}.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public interface FsDirectoryEntry extends FsObject {
+
+ /**
+ * Compares directory entries alphabetically, with all directories coming
+ * before all files.
+ */
+ public final static Comparator<FsDirectoryEntry> DIRECTORY_ENTRY_COMPARATOR =
+ new Comparator<FsDirectoryEntry>() {
+
+ @Override
+ public int compare(FsDirectoryEntry e1, FsDirectoryEntry e2) {
+ if (e2.isDirectory() == e1.isDirectory()) {
+ /* compare names */
+ return e1.getName().compareTo(e2.getName());
+ } else {
+ if (e2.isDirectory()) return 1;
+ else return -1;
+ }
+ }
+ };
+
+ /**
+ * Gets the name of this entry.
+ *
+ * @return this entrys name
+ */
+ public String getName();
+
+ /**
+ * Gets the last modification time of this entry.
+ *
+ * @return the last modification time of the entry as milliseconds
+ * since 1970, or {@code 0} if this filesystem does not support
+ * getting the last modification time
+ * @throws IOException if an error occurs retrieving the time stamp
+ */
+ public long getLastModified() throws IOException;
+
+ /**
+ * Returns the time when this entry was created as ms since 1970.
+ *
+ * @return the creation time, or 0 if this feature is not supported
+ * @throws IOException on error retrieving the time stamp
+ */
+ public long getCreated() throws IOException;
+
+ /**
+ * Returns the time when this entry was last accessed as ms since 1970.
+ *
+ * @return the last access time, or 0 if this feature is not supported
+ * @throws IOException on error retrieving the last access time
+ */
+ public long getLastAccessed() throws IOException;
+
+ /**
+ * Is this entry refering to a file?
+ *
+ * @return if this entry refers to a file
+ */
+ public boolean isFile();
+
+ /**
+ * Is this entry refering to a (sub-)directory?
+ *
+ * @return if this entry refers to a directory
+ */
+ public boolean isDirectory();
+
+ /**
+ * Sets the name of this entry.
+ *
+ * @param newName the new name of this entry
+ * @throws IOException on error setting the new name
+ */
+ public void setName(String newName) throws IOException;
+
+ /**
+ * Sets the last modification time of this entry.
+ *
+ * @param lastModified the new last modification time of this entry
+ * @throws IOException on write error
+ */
+ public void setLastModified(long lastModified) throws IOException;
+
+ /**
+ * Gets the file this entry refers to. This method can only be called if
+ * {@code isFile} returns {@code true}.
+ *
+ * @return the file described by this entry
+ * @throws IOException on error accessing the file
+ * @throws UnsupportedOperationException if this entry is a directory
+ */
+ public FsFile getFile()
+ throws IOException, UnsupportedOperationException;
+
+ /**
+ * Gets the directory this entry refers to. This method can only be called
+ * if <code>isDirectory</code> returns true.
+ *
+ * @return The directory described by this entry
+ * @throws IOException on read error
+ * @throws UnsupportedOperationException if this entry is a file
+ */
+ public FsDirectory getDirectory()
+ throws IOException, UnsupportedOperationException;
+
+ /**
+ * Indicate if the entry has been modified in memory (ie need to be saved)
+ *
+ * @return true if the entry needs to be saved
+ */
+ public boolean isDirty();
+}
diff --git a/src/main/java/de/waldheinz/fs/FsFile.java b/src/main/java/de/waldheinz/fs/FsFile.java
new file mode 100644
index 0000000..dfaa998
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FsFile.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * A FsFile is a representation of a single block of bytes on a filesystem. It
+ * is comparable to an inode in Unix.
+ *
+ * An FsFile does not have any knowledge of who is using this file. It is also
+ * possible that the system uses a single FsFile instance to create two
+ * inputstream's for two different principals.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ */
+public interface FsFile extends FsObject {
+
+ /**
+ * Gets the length (in bytes) of this file.
+ *
+ * @return the file size
+ */
+ public long getLength();
+
+ /**
+ * Sets the length of this file.
+ *
+ * @param length the new length of this file
+ * @throws IOException on error updating the file size
+ */
+ public void setLength(long length) throws IOException;
+
+ /**
+ * Reads from this file into the specified {@code ByteBuffer}. The
+ * first byte read will be put into the buffer at it's
+ * {@link ByteBuffer#position() position}, and the number of bytes read
+ * will equal the buffer's {@link ByteBuffer#remaining() remaining} bytes.
+ *
+ * @param offset the offset into the file where to start reading
+ * @param dest the destination buffer where to put the bytes that were read
+ * @throws IOException on read error
+ */
+ public void read(long offset, ByteBuffer dest) throws IOException;
+
+ /**
+ * Writes to this file taking the data to write from the specified
+ * {@code ByteBuffer}. This method will read the buffer's
+ * {@link ByteBuffer#remaining() remaining} bytes starting at it's
+ * {@link ByteBuffer#position() position}.
+ *
+ * @param offset the offset into the file where the first byte will be
+ * written
+ * @param src the source buffer to read the data from
+ * @throws ReadOnlyException if the file is read-only
+ * @throws IOException on write error
+ */
+ public void write(long offset, ByteBuffer src)
+ throws ReadOnlyException, IOException;
+
+ /**
+ * Flush any possibly cached data to the disk.
+ *
+ * @throws IOException on error flushing
+ */
+ public void flush() throws IOException;
+}
diff --git a/src/main/java/de/waldheinz/fs/FsObject.java b/src/main/java/de/waldheinz/fs/FsObject.java
new file mode 100644
index 0000000..72d7d50
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/FsObject.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+/**
+ * This interface is the base interface for objects that are part of a
+ * {@link FileSystem}.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public interface FsObject {
+
+ /**
+ * Checks if this {@code FsObject} is still valid.
+ *
+ * An object is not valid anymore if it has been removed from the
+ * filesystem. All invocations on methods (except this method and the
+ * methods inherited from {@link java.lang.Object}) of
+ * invalid objects must throw an {@link IllegalStateException}.
+ *
+ * @return if this {@code FsObject} is still valid
+ */
+ public boolean isValid();
+
+ /**
+ * Checks if this {@code FsObject} is read-only. Any attempt to modify a
+ * read-only {@code FsObject} must result in a {@link ReadOnlyException}
+ * being thrown, and the modification must not be performed.
+ *
+ * @return if this {@code FsObject} is read-only
+ * @since 0.6
+ */
+ public boolean isReadOnly();
+
+}
diff --git a/src/main/java/de/waldheinz/fs/ReadOnlyException.java b/src/main/java/de/waldheinz/fs/ReadOnlyException.java
new file mode 100644
index 0000000..f786d64
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/ReadOnlyException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+/**
+ * This exception is thrown when an attempt is made to write to a read-only
+ * {@link BlockDevice}, {@link FileSystem} or other file system object. This is
+ * an unchecked exception, as it should always be possible to query the object
+ * about it's read-only state using it's {@code isReadOnly()} method.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @see FileSystem#isReadOnly()
+ * @see BlockDevice#isReadOnly()
+ */
+public final class ReadOnlyException extends RuntimeException {
+
+ private final static long serialVersionUID = 1;
+
+ /**
+ * Creates a new instance of {@code ReadOnlyException}.
+ *
+ */
+ public ReadOnlyException() {
+ super("read-only");
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/UnknownFileSystemException.java b/src/main/java/de/waldheinz/fs/UnknownFileSystemException.java
new file mode 100644
index 0000000..0e27baf
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/UnknownFileSystemException.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs;
+
+import java.io.IOException;
+
+/**
+ * Indicates that it was not possible to determine the type of the file
+ * system being used on a block device.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public final class UnknownFileSystemException extends IOException {
+ private final static long serialVersionUID = 1;
+
+ private final BlockDevice device;
+
+ /**
+ * Creates a new instance of {@code UnknownFileSystemException}.
+ *
+ * @param device the {@code BlockDevice} whose file system could not
+ * be determined
+ */
+ public UnknownFileSystemException(BlockDevice device) {
+ super("can not determin file system type"); //NOI18N
+ this.device = device;
+ }
+
+ /**
+ * Returns the {@code BlockDevice} whose file system could not be
+ * determined.
+ *
+ * @return the {@code BlockDevice} with an unknown file system
+ */
+ public BlockDevice getDevice() {
+ return this.device;
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/AbstractDirectory.java b/src/main/java/de/waldheinz/fs/fat/AbstractDirectory.java
new file mode 100644
index 0000000..d3445b7
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/AbstractDirectory.java
@@ -0,0 +1,384 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * This is the abstract base class for all directory implementations.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+abstract class AbstractDirectory {
+
+ /**
+ * The maximum length of the volume label.
+ *
+ * @see #setLabel(java.lang.String)
+ */
+ public static final int MAX_LABEL_LENGTH = 11;
+
+ private final List<FatDirectoryEntry> entries;
+ private final boolean readOnly;
+ private final boolean isRoot;
+
+ private boolean dirty;
+ private int capacity;
+ private String volumeLabel;
+
+ /**
+ * Creates a new instance of {@code AbstractDirectory}.
+ *
+ * @param capacity the initial capacity of the new instance
+ * @param readOnly if the instance should be read-only
+ * @param isRoot if the new {@code AbstractDirectory} represents a root
+ * directory
+ */
+ protected AbstractDirectory(
+ int capacity, boolean readOnly, boolean isRoot) {
+
+ this.entries = new ArrayList<FatDirectoryEntry>();
+ this.capacity = capacity;
+ this.readOnly = readOnly;
+ this.isRoot = isRoot;
+ }
+
+ /**
+ * Gets called when the {@code AbstractDirectory} must read it's content
+ * off the backing storage. This method must always fill the buffer's
+ * remaining space with the bytes making up this directory, beginning with
+ * the first byte.
+ *
+ * @param data the {@code ByteBuffer} to fill
+ * @throws IOException on read error
+ */
+ protected abstract void read(ByteBuffer data) throws IOException;
+
+ /**
+ * Gets called when the {@code AbstractDirectory} wants to write it's
+ * contents to the backing storage. This method is expected to write the
+ * buffer's remaining data to the storage, beginning with the first byte.
+ *
+ * @param data the {@code ByteBuffer} to write
+ * @throws IOException on write error
+ */
+ protected abstract void write(ByteBuffer data) throws IOException;
+
+ /**
+ * Returns the number of the cluster where this directory is stored. This
+ * is important when creating the ".." entry in a sub-directory, as this
+ * entry must poing to the storage cluster of it's parent.
+ *
+ * @return this directory's storage cluster
+ */
+ protected abstract long getStorageCluster();
+
+ /**
+ * Gets called by the {@code AbstractDirectory} when it has determined that
+ * it should resize because the number of entries has changed.
+ *
+ * @param entryCount the new number of entries this directory needs to store
+ * @throws IOException on write error
+ * @throws DirectoryFullException if the FAT12/16 root directory is full
+ * @see #sizeChanged(long)
+ * @see #checkEntryCount(int)
+ */
+ protected abstract void changeSize(int entryCount)
+ throws DirectoryFullException, IOException;
+
+ /**
+ * Replaces all entries in this directory.
+ *
+ * @param newEntries the new directory entries
+ */
+ public void setEntries(List<FatDirectoryEntry> newEntries) {
+ if (newEntries.size() > capacity)
+ throw new IllegalArgumentException("too many entries");
+
+ this.entries.clear();
+ this.entries.addAll(newEntries);
+ }
+
+ /**
+ *
+ *
+ * @param newSize the new storage space for the directory in bytes
+ * @see #changeSize(int)
+ */
+ protected final void sizeChanged(long newSize) throws IOException {
+ final long newCount = newSize / FatDirectoryEntry.SIZE;
+ if (newCount > Integer.MAX_VALUE)
+ throw new IOException("directory too large");
+
+ this.capacity = (int) newCount;
+ }
+
+ public final FatDirectoryEntry getEntry(int idx) {
+ return this.entries.get(idx);
+ }
+
+ /**
+ * Returns the current capacity of this {@code AbstractDirectory}.
+ *
+ * @return the number of entries this directory can hold in its current
+ * storage space
+ * @see #changeSize(int)
+ */
+ public final int getCapacity() {
+ return this.capacity;
+ }
+
+ /**
+ * The number of entries that are currently stored in this
+ * {@code AbstractDirectory}.
+ *
+ * @return the current number of directory entries
+ */
+ public final int getEntryCount() {
+ return this.entries.size();
+ }
+
+ public boolean isReadOnly() {
+ return readOnly;
+ }
+
+ public final boolean isRoot() {
+ return this.isRoot;
+ }
+
+ /**
+ * Gets the number of directory entries in this directory. This is the
+ * number of "real" entries in this directory, possibly plus one if a
+ * volume label is set.
+ *
+ * @return the number of entries in this directory
+ */
+ public int getSize() {
+ return entries.size() + ((this.volumeLabel != null) ? 1 : 0);
+ }
+
+ /**
+ * Mark this directory as dirty.
+ */
+ protected final void setDirty() {
+ this.dirty = true;
+ }
+
+ /**
+ * Checks if this {@code AbstractDirectory} is a root directory.
+ *
+ * @throws UnsupportedOperationException if this is not a root directory
+ * @see #isRoot()
+ */
+ private void checkRoot() throws UnsupportedOperationException {
+ if (!isRoot()) {
+ throw new UnsupportedOperationException(
+ "only supported on root directories");
+ }
+ }
+
+ /**
+ * Mark this directory as not dirty.
+ */
+ private void resetDirty() {
+ this.dirty = false;
+ }
+
+ /**
+ * Flush the contents of this directory to the persistent storage
+ */
+ public void flush() throws IOException {
+
+ final ByteBuffer data = ByteBuffer.allocate(
+ getCapacity() * FatDirectoryEntry.SIZE);
+
+ for (int i=0; i < entries.size(); i++) {
+ final FatDirectoryEntry entry = entries.get(i);
+
+ if (entry != null) {
+ entry.write(data);
+ }
+ }
+
+ /* TODO: the label could be placed directly the dot entries */
+
+ if (this.volumeLabel != null) {
+ final FatDirectoryEntry labelEntry =
+ FatDirectoryEntry.createVolumeLabel(volumeLabel);
+
+ labelEntry.write(data);
+ }
+
+ if (data.hasRemaining()) {
+ FatDirectoryEntry.writeNullEntry(data);
+ }
+
+ data.flip();
+
+ write(data);
+ resetDirty();
+ }
+
+ protected final void read() throws IOException {
+ final ByteBuffer data = ByteBuffer.allocate(
+ getCapacity() * FatDirectoryEntry.SIZE);
+
+ read(data);
+ data.flip();
+
+ for (int i=0; i < getCapacity(); i++) {
+ final FatDirectoryEntry e =
+ FatDirectoryEntry.read(data, isReadOnly());
+
+ if (e == null) break;
+
+ if (e.isVolumeLabel()) {
+ if (!this.isRoot) throw new IOException(
+ "volume label in non-root directory");
+
+ this.volumeLabel = e.getVolumeLabel();
+ } else {
+ entries.add(e);
+ }
+ }
+ }
+
+ public void addEntry(FatDirectoryEntry e) throws IOException {
+ assert (e != null);
+
+ if (getSize() == getCapacity()) {
+ changeSize(getCapacity() + 1);
+ }
+
+ entries.add(e);
+ }
+
+ public void addEntries(FatDirectoryEntry[] entries)
+ throws IOException {
+
+ if (getSize() + entries.length > getCapacity()) {
+ changeSize(getSize() + entries.length);
+ }
+
+ this.entries.addAll(Arrays.asList(entries));
+ }
+
+ public void removeEntry(FatDirectoryEntry entry) throws IOException {
+ assert (entry != null);
+
+ this.entries.remove(entry);
+ changeSize(getSize());
+ }
+
+ /**
+ * Returns the volume label that is stored in this directory. Reading the
+ * volume label is only supported for the root directory.
+ *
+ * @return the volume label stored in this directory, or {@code null}
+ * @throws UnsupportedOperationException if this is not a root directory
+ * @see #isRoot()
+ */
+ public String getLabel() throws UnsupportedOperationException {
+ checkRoot();
+
+ return volumeLabel;
+ }
+
+ public FatDirectoryEntry createSub(Fat fat) throws IOException {
+ final ClusterChain chain = new ClusterChain(fat, false);
+ chain.setChainLength(1);
+
+ final FatDirectoryEntry entry = FatDirectoryEntry.create(true);
+ entry.setStartCluster(chain.getStartCluster());
+
+ final ClusterChainDirectory dir =
+ new ClusterChainDirectory(chain, false);
+
+ /* add "." entry */
+
+ final FatDirectoryEntry dot = FatDirectoryEntry.create(true);
+ dot.setShortName(ShortName.DOT);
+ dot.setStartCluster(dir.getStorageCluster());
+ copyDateTimeFields(entry, dot);
+ dir.addEntry(dot);
+
+ /* add ".." entry */
+
+ final FatDirectoryEntry dotDot = FatDirectoryEntry.create(true);
+ dotDot.setShortName(ShortName.DOT_DOT);
+ dotDot.setStartCluster(getStorageCluster());
+ copyDateTimeFields(entry, dotDot);
+ dir.addEntry(dotDot);
+
+ dir.flush();
+
+ return entry;
+ }
+
+ private static void copyDateTimeFields(
+ FatDirectoryEntry src, FatDirectoryEntry dst) {
+
+ dst.setCreated(src.getCreated());
+ dst.setLastAccessed(src.getLastAccessed());
+ dst.setLastModified(src.getLastModified());
+ }
+
+ /**
+ * Sets the volume label that is stored in this directory. Setting the
+ * volume label is supported on the root directory only.
+ *
+ * @param label the new volume label
+ * @throws IllegalArgumentException if the label is too long
+ * @throws UnsupportedOperationException if this is not a root directory
+ * @see #isRoot()
+ */
+ public void setLabel(String label) throws IllegalArgumentException,
+ UnsupportedOperationException, IOException {
+
+ checkRoot();
+
+ if (label.length() > MAX_LABEL_LENGTH) throw new
+ IllegalArgumentException("label too long");
+
+ if (this.volumeLabel != null) {
+ if (label == null) {
+ changeSize(getSize() - 1);
+ this.volumeLabel = null;
+ } else {
+ ShortName.checkValidChars(label.toCharArray());
+ this.volumeLabel = label;
+ }
+ } else {
+ if (label != null) {
+ changeSize(getSize() + 1);
+ ShortName.checkValidChars(label.toCharArray());
+ this.volumeLabel = label;
+ }
+ }
+
+ this.dirty = true;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/BootSector.java b/src/main/java/de/waldheinz/fs/fat/BootSector.java
new file mode 100644
index 0000000..d1aa398
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/BootSector.java
@@ -0,0 +1,517 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * The boot sector.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public abstract class BootSector extends Sector {
+
+ /**
+ * Offset to the byte specifying the number of FATs.
+ *
+ * @see #getNrFats()
+ * @see #setNrFats(int)
+ */
+ public static final int FAT_COUNT_OFFSET = 16;
+ public static final int RESERVED_SECTORS_OFFSET = 14;
+
+ public static final int TOTAL_SECTORS_16_OFFSET = 19;
+ public static final int TOTAL_SECTORS_32_OFFSET = 32;
+
+ /**
+ * The length of the file system type string.
+ *
+ * @see #getFileSystemType()
+ */
+ public static final int FILE_SYSTEM_TYPE_LENGTH = 8;
+
+ /**
+ * The offset to the sectors per cluster value stored in a boot sector.
+ *
+ * @see #getSectorsPerCluster()
+ * @see #setSectorsPerCluster(int)
+ */
+ public static final int SECTORS_PER_CLUSTER_OFFSET = 0x0d;
+
+ public static final int EXTENDED_BOOT_SIGNATURE = 0x29;
+
+ /**
+ * The size of a boot sector in bytes.
+ */
+ public final static int SIZE = 512;
+
+ protected BootSector(BlockDevice device) {
+ super(device, 0, SIZE);
+ markDirty();
+ }
+
+ public static BootSector read(BlockDevice device) throws IOException {
+ final ByteBuffer bb = ByteBuffer.allocate(512);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+ device.read(0, bb);
+
+ if ((bb.get(510) & 0xff) != 0x55 ||
+ (bb.get(511) & 0xff) != 0xaa) throw new IOException(
+ "missing boot sector signature");
+
+ final byte sectorsPerCluster = bb.get(SECTORS_PER_CLUSTER_OFFSET);
+
+ if (sectorsPerCluster <= 0) throw new IOException(
+ "suspicious sectors per cluster count " + sectorsPerCluster);
+
+ final int rootDirEntries = bb.getShort(
+ Fat16BootSector.ROOT_DIR_ENTRIES_OFFSET);
+ final int rootDirSectors = ((rootDirEntries * 32) +
+ (device.getSectorSize() - 1)) / device.getSectorSize();
+
+ final int total16 =
+ bb.getShort(TOTAL_SECTORS_16_OFFSET) & 0xffff;
+ final long total32 =
+ bb.getInt(TOTAL_SECTORS_32_OFFSET) & 0xffffffffl;
+
+ final long totalSectors = total16 == 0 ? total32 : total16;
+
+ final int fatSz16 =
+ bb.getShort(Fat16BootSector.SECTORS_PER_FAT_OFFSET) & 0xffff;
+ final long fatSz32 =
+ bb.getInt(Fat32BootSector.SECTORS_PER_FAT_OFFSET) & 0xffffffffl;
+
+ final long fatSz = fatSz16 == 0 ? fatSz32 : fatSz16;
+ final int reservedSectors = bb.getShort(RESERVED_SECTORS_OFFSET);
+ final int fatCount = bb.get(FAT_COUNT_OFFSET);
+ final long dataSectors = totalSectors - (reservedSectors +
+ (fatCount * fatSz) + rootDirSectors);
+
+ final long clusterCount = dataSectors / sectorsPerCluster;
+
+ final BootSector result =
+ (clusterCount > Fat16BootSector.MAX_FAT16_CLUSTERS) ?
+ new Fat32BootSector(device) : new Fat16BootSector(device);
+
+ result.read();
+ return result;
+ }
+
+ public abstract FatType getFatType();
+
+ /**
+ * Gets the number of sectors per FAT.
+ *
+ * @return the sectors per FAT
+ */
+ public abstract long getSectorsPerFat();
+
+ /**
+ * Sets the number of sectors/fat
+ *
+ * @param v the new number of sectors per fat
+ */
+ public abstract void setSectorsPerFat(long v);
+
+ public abstract void setSectorCount(long count);
+
+ public abstract int getRootDirEntryCount();
+
+ public abstract long getSectorCount();
+
+ /**
+ * Returns the offset to the file system type label, as this differs
+ * between FAT12/16 and FAT32.
+ *
+ * @return the offset to the file system type label
+ */
+ public abstract int getFileSystemTypeLabelOffset();
+
+ public abstract int getExtendedBootSignatureOffset();
+
+ public void init() throws IOException {
+ setBytesPerSector(getDevice().getSectorSize());
+ setSectorCount(getDevice().getSize() / getDevice().getSectorSize());
+ set8(getExtendedBootSignatureOffset(), EXTENDED_BOOT_SIGNATURE);
+
+ /* magic bytes needed by some windows versions to recognize a boot
+ * sector. these are x86 jump instructions which lead into
+ * nirvana when executed, but we're currently unable to produce really
+ * bootable images anyway. So... */
+ set8(0x00, 0xeb);
+ set8(0x01, 0x3c);
+ set8(0x02, 0x90);
+
+ /* the boot sector signature */
+ set8(0x1fe, 0x55);
+ set8(0x1ff, 0xaa);
+ }
+
+ /**
+ * Returns the file system type label string.
+ *
+ * @return the file system type string
+ * @see #setFileSystemTypeLabel(java.lang.String)
+ * @see #getFileSystemTypeLabelOffset()
+ * @see #FILE_SYSTEM_TYPE_LENGTH
+ */
+ public String getFileSystemTypeLabel() {
+ final StringBuilder sb = new StringBuilder(FILE_SYSTEM_TYPE_LENGTH);
+
+ for (int i=0; i < FILE_SYSTEM_TYPE_LENGTH; i++) {
+ sb.append ((char) get8(getFileSystemTypeLabelOffset() + i));
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ *
+ *
+ * @param fsType the
+ * @throws IllegalArgumentException if the length of the specified string
+ * does not equal {@link #FILE_SYSTEM_TYPE_LENGTH}
+ */
+ public void setFileSystemTypeLabel(String fsType)
+ throws IllegalArgumentException {
+
+ if (fsType.length() != FILE_SYSTEM_TYPE_LENGTH) {
+ throw new IllegalArgumentException();
+ }
+
+ for (int i=0; i < FILE_SYSTEM_TYPE_LENGTH; i++) {
+ set8(getFileSystemTypeLabelOffset() + i, fsType.charAt(i));
+ }
+ }
+
+ /**
+ * Returns the number of clusters that are really needed to cover the
+ * data-caontaining portion of the file system.
+ *
+ * @return the number of clusters usable for user data
+ * @see #getDataSize()
+ */
+ public final long getDataClusterCount() {
+ return getDataSize() / getBytesPerCluster();
+ }
+
+ /**
+ * Returns the size of the data-containing portion of the file system.
+ *
+ * @return the number of bytes usable for storing user data
+ */
+ private long getDataSize() {
+ return (getSectorCount() * getBytesPerSector()) -
+ FatUtils.getFilesOffset(this);
+ }
+
+ /**
+ * Gets the OEM name
+ *
+ * @return String
+ */
+ public String getOemName() {
+ StringBuilder b = new StringBuilder(8);
+
+ for (int i = 0; i < 8; i++) {
+ int v = get8(0x3 + i);
+ if (v == 0) break;
+ b.append((char) v);
+ }
+
+ return b.toString();
+ }
+
+
+ /**
+ * Sets the OEM name, must be at most 8 characters long.
+ *
+ * @param name the new OEM name
+ */
+ public void setOemName(String name) {
+ if (name.length() > 8) throw new IllegalArgumentException(
+ "only 8 characters are allowed");
+
+ for (int i = 0; i < 8; i++) {
+ char ch;
+ if (i < name.length()) {
+ ch = name.charAt(i);
+ } else {
+ ch = (char) 0;
+ }
+
+ set8(0x3 + i, ch);
+ }
+ }
+
+ /**
+ * Gets the number of bytes/sector
+ *
+ * @return int
+ */
+ public int getBytesPerSector() {
+ return get16(0x0b);
+ }
+
+ /**
+ * Sets the number of bytes/sector
+ *
+ * @param v the new value for bytes per sector
+ */
+ public void setBytesPerSector(int v) {
+ if (v == getBytesPerSector()) return;
+
+ switch (v) {
+ case 512: case 1024: case 2048: case 4096:
+ set16(0x0b, v);
+ break;
+
+ default:
+ throw new IllegalArgumentException();
+ }
+ }
+
+ private static boolean isPowerOfTwo(int n) {
+ return ((n!=0) && (n&(n-1))==0);
+ }
+
+ /**
+ * Returns the number of bytes per cluster, which is calculated from the
+ * {@link #getSectorsPerCluster() sectors per cluster} and the
+ * {@link #getBytesPerSector() bytes per sector}.
+ *
+ * @return the number of bytes per cluster
+ */
+ public int getBytesPerCluster() {
+ return this.getSectorsPerCluster() * this.getBytesPerSector();
+ }
+
+ /**
+ * Gets the number of sectors/cluster
+ *
+ * @return int
+ */
+ public int getSectorsPerCluster() {
+ return get8(SECTORS_PER_CLUSTER_OFFSET);
+ }
+
+ /**
+ * Sets the number of sectors/cluster
+ *
+ * @param v the new number of sectors per cluster
+ */
+ public void setSectorsPerCluster(int v) {
+ if (v == getSectorsPerCluster()) return;
+ if (!isPowerOfTwo(v)) throw new IllegalArgumentException(
+ "value must be a power of two");
+
+ set8(SECTORS_PER_CLUSTER_OFFSET, v);
+ }
+
+ /**
+ * Gets the number of reserved (for bootrecord) sectors
+ *
+ * @return int
+ */
+ public int getNrReservedSectors() {
+ return get16(RESERVED_SECTORS_OFFSET);
+ }
+
+ /**
+ * Sets the number of reserved (for bootrecord) sectors
+ *
+ * @param v the new number of reserved sectors
+ */
+ public void setNrReservedSectors(int v) {
+ if (v == getNrReservedSectors()) return;
+ if (v < 1) throw new IllegalArgumentException(
+ "there must be >= 1 reserved sectors");
+ set16(RESERVED_SECTORS_OFFSET, v);
+ }
+
+ /**
+ * Gets the number of fats
+ *
+ * @return int
+ */
+ public final int getNrFats() {
+ return get8(FAT_COUNT_OFFSET);
+ }
+
+ /**
+ * Sets the number of fats
+ *
+ * @param v the new number of fats
+ */
+ public final void setNrFats(int v) {
+ if (v == getNrFats()) return;
+
+ set8(FAT_COUNT_OFFSET, v);
+ }
+
+ /**
+ * Gets the number of logical sectors
+ *
+ * @return int
+ */
+ protected int getNrLogicalSectors() {
+ return get16(TOTAL_SECTORS_16_OFFSET);
+ }
+
+ /**
+ * Sets the number of logical sectors
+ *
+ * @param v the new number of logical sectors
+ */
+ protected void setNrLogicalSectors(int v) {
+ if (v == getNrLogicalSectors()) return;
+
+ set16(TOTAL_SECTORS_16_OFFSET, v);
+ }
+
+ protected void setNrTotalSectors(long v) {
+ set32(TOTAL_SECTORS_32_OFFSET, v);
+ }
+
+ protected long getNrTotalSectors() {
+ return get32(TOTAL_SECTORS_32_OFFSET);
+ }
+
+ /**
+ * Gets the medium descriptor byte
+ *
+ * @return int
+ */
+ public int getMediumDescriptor() {
+ return get8(0x15);
+ }
+
+ /**
+ * Sets the medium descriptor byte
+ *
+ * @param v the new medium descriptor
+ */
+ public void setMediumDescriptor(int v) {
+ set8(0x15, v);
+ }
+
+ /**
+ * Gets the number of sectors/track
+ *
+ * @return int
+ */
+ public int getSectorsPerTrack() {
+ return get16(0x18);
+ }
+
+ /**
+ * Sets the number of sectors/track
+ *
+ * @param v the new number of sectors per track
+ */
+ public void setSectorsPerTrack(int v) {
+ if (v == getSectorsPerTrack()) return;
+
+ set16(0x18, v);
+ }
+
+ /**
+ * Gets the number of heads
+ *
+ * @return int
+ */
+ public int getNrHeads() {
+ return get16(0x1a);
+ }
+
+ /**
+ * Sets the number of heads
+ *
+ * @param v the new number of heads
+ */
+ public void setNrHeads(int v) {
+ if (v == getNrHeads()) return;
+
+ set16(0x1a, v);
+ }
+
+ /**
+ * Gets the number of hidden sectors
+ *
+ * @return int
+ */
+ public long getNrHiddenSectors() {
+ return get32(0x1c);
+ }
+
+ /**
+ * Sets the number of hidden sectors
+ *
+ * @param v the new number of hidden sectors
+ */
+ public void setNrHiddenSectors(long v) {
+ if (v == getNrHiddenSectors()) return;
+
+ set32(0x1c, v);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder res = new StringBuilder(1024);
+ res.append("Bootsector :\n");
+ res.append("oemName=");
+ res.append(getOemName());
+ res.append('\n');
+ res.append("medium descriptor = ");
+ res.append(getMediumDescriptor());
+ res.append('\n');
+ res.append("Nr heads = ");
+ res.append(getNrHeads());
+ res.append('\n');
+ res.append("Sectors per track = ");
+ res.append(getSectorsPerTrack());
+ res.append('\n');
+ res.append("Sector per cluster = ");
+ res.append(getSectorsPerCluster());
+ res.append('\n');
+ res.append("byte per sector = ");
+ res.append(getBytesPerSector());
+ res.append('\n');
+ res.append("Nr fats = ");
+ res.append(getNrFats());
+ res.append('\n');
+ res.append("Nr hidden sectors = ");
+ res.append(getNrHiddenSectors());
+ res.append('\n');
+ res.append("Nr logical sectors = ");
+ res.append(getNrLogicalSectors());
+ res.append('\n');
+ res.append("Nr reserved sector = ");
+ res.append(getNrReservedSectors());
+ res.append('\n');
+
+ return res.toString();
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/ClusterChain.java b/src/main/java/de/waldheinz/fs/fat/ClusterChain.java
new file mode 100644
index 0000000..e296092
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/ClusterChain.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFsObject;
+import de.waldheinz.fs.BlockDevice;
+import java.io.EOFException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * A chain of clusters as stored in a {@link Fat}.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+final class ClusterChain extends AbstractFsObject {
+ protected final Fat fat;
+ private final BlockDevice device;
+ private final int clusterSize;
+ protected final long dataOffset;
+
+ private long startCluster;
+
+ /**
+ * Creates a new {@code ClusterChain} that contains no clusters.
+ *
+ * @param fat the {@code Fat} that holds the new chain
+ * @param readOnly if the chain should be created read-only
+ */
+ public ClusterChain(Fat fat, boolean readOnly) {
+ this(fat, 0, readOnly);
+ }
+
+ public ClusterChain(Fat fat, long startCluster, boolean readOnly) {
+ super(readOnly);
+
+ this.fat = fat;
+
+ if (startCluster != 0) {
+ this.fat.testCluster(startCluster);
+
+ if (this.fat.isFreeCluster(startCluster))
+ throw new IllegalArgumentException(
+ "cluster " + startCluster + " is free");
+ }
+
+ this.device = fat.getDevice();
+ this.dataOffset = FatUtils.getFilesOffset(fat.getBootSector());
+ this.startCluster = startCluster;
+ this.clusterSize = fat.getBootSector().getBytesPerCluster();
+ }
+
+ public int getClusterSize() {
+ return clusterSize;
+ }
+
+ public Fat getFat() {
+ return fat;
+ }
+
+ public BlockDevice getDevice() {
+ return device;
+ }
+
+ /**
+ * Returns the first cluster of this chain.
+ *
+ * @return the chain's first cluster, which may be 0 if this chain does
+ * not contain any clusters
+ */
+ public long getStartCluster() {
+ return startCluster;
+ }
+
+ /**
+ * Calculates the device offset (0-based) for the given cluster and offset
+ * within the cluster.
+ *
+ * @param cluster
+ * @param clusterOffset
+ * @return long
+ * @throws FileSystemException
+ */
+ private long getDevOffset(long cluster, int clusterOffset) {
+ return dataOffset + clusterOffset +
+ ((cluster - Fat.FIRST_CLUSTER) * clusterSize);
+ }
+
+ /**
+ * Returns the size this {@code ClusterChain} occupies on the device.
+ *
+ * @return the size this chain occupies on the device in bytes
+ */
+ public long getLengthOnDisk() {
+ if (getStartCluster() == 0) return 0;
+
+ return getChainLength() * clusterSize;
+ }
+
+ /**
+ * Sets the length of this {@code ClusterChain} in bytes. Because a
+ * {@code ClusterChain} can only contain full clusters, the new size
+ * will always be a multiple of the cluster size.
+ *
+ * @param size the desired number of bytes the can be stored in
+ * this {@code ClusterChain}
+ * @return the true number of bytes this {@code ClusterChain} can contain
+ * @throws IOException on error setting the new size
+ * @see #setChainLength(int)
+ */
+ public long setSize(long size) throws IOException {
+ final long nrClusters = ((size + clusterSize - 1) / clusterSize);
+ if (nrClusters > Integer.MAX_VALUE)
+ throw new IOException("too many clusters");
+
+ setChainLength((int) nrClusters);
+
+ return clusterSize * nrClusters;
+ }
+
+ /**
+ * Determines the length of this {@code ClusterChain} in clusters.
+ *
+ * @return the length of this chain
+ */
+ public int getChainLength() {
+ if (getStartCluster() == 0) return 0;
+
+ final long[] chain = getFat().getChain(getStartCluster());
+ return chain.length;
+ }
+
+ /**
+ * Sets the length of this cluster chain in clusters.
+ *
+ * @param nrClusters the new number of clusters this chain should contain,
+ * must be {@code >= 0}
+ * @throws IOException on error updating the chain length
+ * @see #setSize(long)
+ */
+ public void setChainLength(int nrClusters) throws IOException {
+ if (nrClusters < 0) throw new IllegalArgumentException(
+ "negative cluster count"); //NOI18N
+
+ if ((this.startCluster == 0) && (nrClusters == 0)) {
+ /* nothing to do */
+ } else if ((this.startCluster == 0) && (nrClusters > 0)) {
+ final long[] chain = fat.allocNew(nrClusters);
+ this.startCluster = chain[0];
+ } else {
+ final long[] chain = fat.getChain(startCluster);
+
+ if (nrClusters != chain.length) {
+ if (nrClusters > chain.length) {
+ /* grow the chain */
+ int count = nrClusters - chain.length;
+
+ while (count > 0) {
+ fat.allocAppend(getStartCluster());
+ count--;
+ }
+ } else {
+ /* shrink the chain */
+ if (nrClusters > 0) {
+ fat.setEof(chain[nrClusters - 1]);
+ for (int i = nrClusters; i < chain.length; i++) {
+ fat.setFree(chain[i]);
+ }
+ } else {
+ for (int i=0; i < chain.length; i++) {
+ fat.setFree(chain[i]);
+ }
+
+ this.startCluster = 0;
+ }
+ }
+ }
+ }
+ }
+
+ public void readData(long offset, ByteBuffer dest)
+ throws IOException {
+
+ int len = dest.remaining();
+
+ if ((startCluster == 0 && len > 0)) throw new EOFException();
+
+ final long[] chain = getFat().getChain(startCluster);
+ final BlockDevice dev = getDevice();
+
+ int chainIdx = (int) (offset / clusterSize);
+ if (offset % clusterSize != 0) {
+ int clusOfs = (int) (offset % clusterSize);
+ int size = Math.min(len,
+ (int) (clusterSize - (offset % clusterSize) - 1));
+ dest.limit(dest.position() + size);
+
+ dev.read(getDevOffset(chain[chainIdx], clusOfs), dest);
+
+ offset += size;
+ len -= size;
+ chainIdx++;
+ }
+
+ while (len > 0) {
+ int size = Math.min(clusterSize, len);
+ dest.limit(dest.position() + size);
+
+ dev.read(getDevOffset(chain[chainIdx], 0), dest);
+
+ len -= size;
+ chainIdx++;
+ }
+ }
+
+ /**
+ * Writes data to this cluster chain, possibly growing the chain so it
+ * can store the additional data. When this method returns without throwing
+ * an exception, the buffer's {@link ByteBuffer#position() position} will
+ * equal it's {@link ByteBuffer#limit() limit}, and the limit will not
+ * have changed. This is not guaranteed if writing fails.
+ *
+ * @param offset the offset where to write the first byte from the buffer
+ * @param srcBuf the buffer to write to this {@code ClusterChain}
+ * @throws IOException on write error
+ */
+ public void writeData(long offset, ByteBuffer srcBuf) throws IOException {
+
+ int len = srcBuf.remaining();
+
+ if (len == 0) return;
+
+ final long minSize = offset + len;
+ if (getLengthOnDisk() < minSize) {
+ setSize(minSize);
+ }
+
+ final long[] chain = fat.getChain(getStartCluster());
+
+ int chainIdx = (int) (offset / clusterSize);
+ if (offset % clusterSize != 0) {
+ int clusOfs = (int) (offset % clusterSize);
+ int size = Math.min(len,
+ (int) (clusterSize - (offset % clusterSize)));
+ srcBuf.limit(srcBuf.position() + size);
+
+ device.write(getDevOffset(chain[chainIdx], clusOfs), srcBuf);
+
+ offset += size;
+ len -= size;
+ chainIdx++;
+ }
+
+ while (len > 0) {
+ int size = Math.min(clusterSize, len);
+ srcBuf.limit(srcBuf.position() + size);
+
+ device.write(getDevOffset(chain[chainIdx], 0), srcBuf);
+
+ len -= size;
+ chainIdx++;
+ }
+
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null) return false;
+ if (!(obj instanceof ClusterChain)) return false;
+
+ final ClusterChain other = (ClusterChain) obj;
+
+ if (this.fat != other.fat &&
+ (this.fat == null || !this.fat.equals(other.fat))) {
+
+ return false;
+ }
+
+ if (this.startCluster != other.startCluster) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 3;
+ hash = 79 * hash +
+ (this.fat != null ? this.fat.hashCode() : 0);
+ hash = 79 * hash +
+ (int) (this.startCluster ^ (this.startCluster >>> 32));
+ return hash;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/ClusterChainDirectory.java b/src/main/java/de/waldheinz/fs/fat/ClusterChainDirectory.java
new file mode 100644
index 0000000..fa3e9df
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/ClusterChainDirectory.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * A directory that is stored in a cluster chain.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+class ClusterChainDirectory extends AbstractDirectory {
+
+ /**
+ * According to the FAT specification, this is the maximum size a FAT
+ * directory may occupy on disk. The {@code ClusterChainDirectory} takes
+ * care not to grow beyond this limit.
+ *
+ * @see #changeSize(int)
+ */
+ public final static int MAX_SIZE = 65536 * 32;
+
+ /**
+ * The {@code ClusterChain} that stores this directory. Package-visible
+ * for testing.
+ */
+ final ClusterChain chain;
+
+ protected ClusterChainDirectory(ClusterChain chain, boolean isRoot) {
+
+ super((int)(chain.getLengthOnDisk() / FatDirectoryEntry.SIZE),
+ chain.isReadOnly(), isRoot);
+
+ this.chain = chain;
+ }
+
+ public static ClusterChainDirectory readRoot(
+ ClusterChain chain) throws IOException {
+
+ final ClusterChainDirectory result =
+ new ClusterChainDirectory(chain, true);
+
+ result.read();
+ return result;
+ }
+
+ public static ClusterChainDirectory createRoot(Fat fat) throws IOException {
+
+ if (fat.getFatType() != FatType.FAT32) {
+ throw new IllegalArgumentException(
+ "only FAT32 stores root directory in a cluster chain");
+ }
+
+ final Fat32BootSector bs = (Fat32BootSector) fat.getBootSector();
+ final ClusterChain cc = new ClusterChain(fat, false);
+ cc.setChainLength(1);
+
+ bs.setRootDirFirstCluster(cc.getStartCluster());
+
+ final ClusterChainDirectory result =
+ new ClusterChainDirectory(cc, true);
+
+ result.flush();
+ return result;
+ }
+
+ @Override
+ protected final void read(ByteBuffer data) throws IOException {
+ this.chain.readData(0, data);
+ }
+
+ @Override
+ protected final void write(ByteBuffer data) throws IOException {
+ final int toWrite = data.remaining();
+ chain.writeData(0, data);
+ final long trueSize = chain.getLengthOnDisk();
+
+ /* TODO: check if the code below is really needed */
+ if (trueSize > toWrite) {
+ final int rest = (int) (trueSize - toWrite);
+ final ByteBuffer fill = ByteBuffer.allocate(rest);
+ chain.writeData(toWrite, fill);
+ }
+ }
+
+ /**
+ * Returns the first cluster of the chain that stores this directory for
+ * non-root instances or 0 if this is the root directory.
+ *
+ * @return the first storage cluster of this directory
+ * @see #isRoot()
+ */
+ @Override
+ protected final long getStorageCluster() {
+ return isRoot() ? 0 : chain.getStartCluster();
+ }
+
+ public final void delete() throws IOException {
+ chain.setChainLength(0);
+ }
+
+ @Override
+ protected final void changeSize(int entryCount)
+ throws IOException, IllegalArgumentException {
+
+ assert (entryCount >= 0);
+
+ final int size = entryCount * FatDirectoryEntry.SIZE;
+
+ if (size > MAX_SIZE) throw new DirectoryFullException(
+ "directory would grow beyond " + MAX_SIZE + " bytes",
+ getCapacity(), entryCount);
+
+ sizeChanged(chain.setSize(Math.max(size, chain.getClusterSize())));
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/DirectoryFullException.java b/src/main/java/de/waldheinz/fs/fat/DirectoryFullException.java
new file mode 100644
index 0000000..5f9770c
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/DirectoryFullException.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.io.IOException;
+
+/**
+ * Gets thrown when either
+ * <ul>
+ * <li>a {@link Fat16RootDirectory} becomes full or</li>
+ * <li>a {@link ClusterChainDirectory} grows beyond it's
+ * {@link ClusterChainDirectory#MAX_SIZE maximum size}
+ * </ul>
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public final class DirectoryFullException extends IOException {
+ private final static long serialVersionUID = 2;
+ private final int currentCapacity;
+ private final int requestedCapacity;
+
+ DirectoryFullException(int currentCapacity, int requestedCapacity) {
+ this("directory is full", currentCapacity, requestedCapacity);
+ }
+
+ DirectoryFullException(String message,
+ int currentCapacity, int requestedCapacity) {
+
+ super(message);
+
+ this.currentCapacity = currentCapacity;
+ this.requestedCapacity = requestedCapacity;
+ }
+
+ /**
+ * Returns the current capacity of the directory.
+ *
+ * @return the current capacity
+ */
+ public int getCurrentCapacity() {
+ return currentCapacity;
+ }
+
+ /**
+ * Returns the capacity the directory tried to grow, which did not succeed.
+ *
+ * @return the requested capacity
+ */
+ public int getRequestedCapacity() {
+ return requestedCapacity;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/DosUtils.java b/src/main/java/de/waldheinz/fs/fat/DosUtils.java
new file mode 100644
index 0000000..09e1ebb
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/DosUtils.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.util.Calendar;
+
+/**
+ * This class contains some methods for date and time conversions between Java
+ * and the format known from DOS filesystems (e.g. fat)
+ *
+ * @author Ewout Prangsma < epr at jnode.org>
+ */
+final class DosUtils {
+
+ private DosUtils() { /* no instances */ }
+
+ /**
+ * Decode a 16-bit encoded DOS date/time into a java date/time.
+ *
+ * @param dosDate
+ * @param dosTime
+ * @return long
+ */
+ public static long decodeDateTime(int dosDate, int dosTime) {
+ final Calendar cal = Calendar.getInstance();
+
+ cal.set(Calendar.MILLISECOND, 0);
+ cal.set(Calendar.SECOND, (dosTime & 0x1f) * 2);
+ cal.set(Calendar.MINUTE, (dosTime >> 5) & 0x3f);
+ cal.set(Calendar.HOUR_OF_DAY, dosTime >> 11);
+
+ cal.set(Calendar.DATE, dosDate & 0x1f);
+ cal.set(Calendar.MONTH, ((dosDate >> 5) & 0x0f) - 1);
+ cal.set(Calendar.YEAR, 1980 + (dosDate >> 9));
+
+ return cal.getTimeInMillis();
+ }
+
+ /**
+ * Encode a java date/time into a 16-bit encoded DOS time
+ *
+ * @param javaDateTime
+ * @return long
+ */
+ public static int encodeTime(long javaDateTime) {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(javaDateTime);
+ return 2048 * cal.get(Calendar.HOUR_OF_DAY) + 32 * cal.get(Calendar.MINUTE) +
+ cal.get(Calendar.SECOND) / 2;
+ }
+
+ /**
+ * Encode a java date/time into a 16-bit encoded DOS date
+ *
+ * @param javaDateTime
+ * @return long
+ */
+ public static int encodeDate(long javaDateTime) {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(javaDateTime);
+ return 512 * (cal.get(Calendar.YEAR) - 1980) + 32 * (cal.get(Calendar.MONTH) + 1) +
+ cal.get(Calendar.DATE);
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Dummy83BufferGenerator.java b/src/main/java/de/waldheinz/fs/fat/Dummy83BufferGenerator.java
new file mode 100644
index 0000000..d9848cc
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Dummy83BufferGenerator.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2012 Google, Inc.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.security.SecureRandom;
+
+/**
+ * Generates dummy 8.3 buffers that are associated with the long names.
+ *
+ * @author Daniel Galpin <dgalpin@google.com> based upon the work of
+ * Andrew Tridgell <tridge@samba.org>
+ */
+final class Dummy83BufferGenerator {
+ final SecureRandom mRandom;
+
+ /**
+ * Creates a new instance of {@code Dummy83BufferGenerator} that uses
+ * randomness only to avoid short name collisions.
+ */
+ public Dummy83BufferGenerator() {
+ mRandom = new SecureRandom();
+ }
+
+ /*
+ * Its in the DOS manual!(DOS 5: page 72) Valid: A..Z 0..9 _ ^ $ ~ ! # % & - {} () @ ' `
+ *
+ * Invalid: spaces/periods,
+ */
+ public static boolean validChar(char toTest) {
+ if (toTest >= 'A' && toTest <= 'Z') return true;
+ if (toTest >= 'a' && toTest <= 'z') return true;
+ if (toTest >= '0' && toTest <= '9') return true;
+ if (toTest == '_' || toTest == '^' || toTest == '$' || toTest == '~' ||
+ toTest == '!' || toTest == '#' || toTest == '%' || toTest == '&' ||
+ toTest == '-' || toTest == '{' || toTest == '}' || toTest == '(' ||
+ toTest == ')' || toTest == '@' || toTest == '\'' || toTest == '`')
+ return true;
+
+ return false;
+ }
+
+ public static boolean isSkipChar(char c) {
+ return (c == '.') || (c == ' ');
+ }
+
+ public static String tidyString(String dirty) {
+ final StringBuilder result = new StringBuilder();
+
+ /* epurate it from alien characters */
+ for (int src=0; src < dirty.length(); src++) {
+ final char toTest = Character.toUpperCase(dirty.charAt(src));
+ if (isSkipChar(toTest)) continue;
+
+ if (validChar(toTest)) {
+ result.append(toTest);
+ } else {
+ result.append('_');
+ }
+ }
+
+ return result.toString();
+ }
+
+ public static boolean cleanString(String s) {
+ for (int i=0; i < s.length(); i++) {
+ if (isSkipChar(s.charAt(i))) return false;
+ if (!validChar(s.charAt(i))) return false;
+ }
+
+ return true;
+ }
+
+ public static String stripLeadingPeriods(String str) {
+ final StringBuilder sb = new StringBuilder(str.length());
+
+ for (int i=0; i < str.length(); i++) {
+ if (str.charAt(i) != '.') { //NOI18N
+ sb.append(str.substring(i));
+ break;
+ }
+ }
+
+ return sb.toString();
+ } /*
+ * These characters are all invalid in 8.3 names, plus have been shown to be
+ * harmless on all tested devices
+ */
+ static final private char[] invalidchar = {
+ (char) 0x01, (char) 0x02, (char) 0x03, (char) 0x04, (char) 0x05, (char) 0x06,
+ (char) 0x0B,
+ (char) 0x0C, (char) 0x0E, (char) 0x0F, (char) 0x10, (char) 0x11, (char) 0x12,
+ (char) 0x13,
+ (char) 0x14, (char) 0x15, (char) 0x16, (char) 0x17, (char) 0x18, (char) 0x19,
+ (char) 0x1A,
+ (char) 0x1B, (char) 0x1C, (char) 0x1D, (char) 0x1E, (char) 0x1F, (char) 0x22,
+ (char) 0x2a,
+ (char) 0x3a, (char) 0x3c, (char) 0x3e, (char) 0x3f, (char) 0x5b, (char) 0x5d,
+ (char) 0x7c
+ };
+
+ /**
+ * See original C Linux patch by Andrew Tridgell <tridge@samba.org>
+ * build a 11 byte 8.3 buffer which is not a short filename. We want 11
+ * bytes which: - will be seen as a constant string to all APIs on Linux and
+ * Windows - cannot be matched with wildcard patterns - cannot be used to
+ * access the file - has a low probability of collision within a directory -
+ * has an invalid 3 byte extension - contains at least one non-space and
+ * non-nul byte
+ *
+ * @param longFullName the long file name to generate the buffer for
+ * @return the generated 8.3 buffer
+ */
+ public ShortName generate83BufferNew(String longFullName)
+ throws IllegalStateException {
+
+ char[] retBuffer = new char[11];
+
+ boolean hasRealShortName = false;// getRealShortNameInstead(longFullName,
+ // retBuffer);
+ if (!hasRealShortName) {
+ int i, tilde_pos, slash_pos;
+ int randomNumber = Math.abs(mRandom.nextInt());
+
+ /*
+ * the '/' makes sure that even unpatched Linux systems can't get at
+ * files by the 8.3 entry.
+ */
+
+ slash_pos = randomNumber % 8;
+ randomNumber >>= 3;
+
+ /*
+ * fill in the first 8 bytes with invalid characters. Note that we
+ * need to be careful not to run out of randomness. We use the same
+ * extension for all buffers.
+ */
+ for (i = 0; i < 8; i++) {
+ if (i == slash_pos)
+ retBuffer[i] = '/';
+ else {
+ retBuffer[i] =
+ invalidchar[randomNumber % invalidchar.length];
+ randomNumber /= invalidchar.length;
+ if (randomNumber < invalidchar.length)
+ randomNumber = Math.abs(mRandom.nextInt());
+ }
+ }
+
+ for ( i = 0; i < 8; i ++ ) {
+ if (retBuffer[i] == 0xe5) {
+ throw new RuntimeException();
+ }
+ }
+
+ retBuffer[8] = 'i';
+ retBuffer[9] = 'f';
+ retBuffer[10] = 'l';
+ }
+ ShortName retName = new ShortName(retBuffer);
+ retName.setHasShortNameOnly(hasRealShortName);
+ return retName;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Fat.java b/src/main/java/de/waldheinz/fs/fat/Fat.java
new file mode 100644
index 0000000..3f3ab43
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Fat.java
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+/**
+ *
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public final class Fat {
+
+ /**
+ * The first cluster that really holds user data in a FAT.
+ */
+ public final static int FIRST_CLUSTER = 2;
+
+ private final long[] entries;
+ private final FatType fatType;
+ private final int sectorCount;
+ private final int sectorSize;
+ private final BlockDevice device;
+ private final BootSector bs;
+ private final long offset;
+ private final int lastClusterIndex;
+
+ private int lastAllocatedCluster;
+
+ /**
+ * Reads a {@code Fat} as specified by a {@code BootSector}.
+ *
+ * @param bs the boot sector specifying the {@code Fat} layout
+ * @param fatNr the number of the {@code Fat} to read
+ * @return the {@code Fat} that was read
+ * @throws IOException on read error
+ * @throws IllegalArgumentException if {@code fatNr} is greater than
+ * {@link BootSector#getNrFats()}
+ */
+ public static Fat read(BootSector bs, int fatNr)
+ throws IOException, IllegalArgumentException {
+
+ if (fatNr > bs.getNrFats()) {
+ throw new IllegalArgumentException(
+ "boot sector says there are only " + bs.getNrFats() +
+ " FATs when reading FAT #" + fatNr);
+ }
+
+ final long fatOffset = FatUtils.getFatOffset(bs, fatNr);
+ final Fat result = new Fat(bs, fatOffset);
+ result.read();
+ return result;
+ }
+
+ /**
+ * Creates a new {@code Fat} as specified by a {@code BootSector}.
+ *
+ * @param bs the boot sector specifying the {@code Fat} layout
+ * @param fatNr the number of the {@code Fat} to create
+ * @return the {@code Fat} that was created
+ * @throws IOException on write error
+ * @throws IllegalArgumentException if {@code fatNr} is greater than
+ * {@link BootSector#getNrFats()}
+ */
+ public static Fat create(BootSector bs, int fatNr)
+ throws IOException, IllegalArgumentException {
+
+ if (fatNr > bs.getNrFats()) {
+ throw new IllegalArgumentException(
+ "boot sector says there are only " + bs.getNrFats() +
+ " FATs when creating FAT #" + fatNr);
+ }
+
+ final long fatOffset = FatUtils.getFatOffset(bs, fatNr);
+ final Fat result = new Fat(bs, fatOffset);
+
+ if (bs.getDataClusterCount() > result.entries.length)
+ throw new IOException("FAT too small for device");
+
+ result.init(bs.getMediumDescriptor());
+ result.write();
+ return result;
+ }
+
+ private Fat(BootSector bs, long offset) throws IOException {
+ this.bs = bs;
+ this.fatType = bs.getFatType();
+ if (bs.getSectorsPerFat() > Integer.MAX_VALUE)
+ throw new IllegalArgumentException("FAT too large");
+
+ if (bs.getSectorsPerFat() <= 0) throw new IOException(
+ "boot sector says there are " + bs.getSectorsPerFat() +
+ " sectors per FAT");
+
+ if (bs.getBytesPerSector() <= 0) throw new IOException(
+ "boot sector says there are " + bs.getBytesPerSector() +
+ " bytes per sector");
+
+ this.sectorCount = (int) bs.getSectorsPerFat();
+ this.sectorSize = bs.getBytesPerSector();
+ this.device = bs.getDevice();
+ this.offset = offset;
+ this.lastAllocatedCluster = FIRST_CLUSTER;
+
+ if (bs.getDataClusterCount() > Integer.MAX_VALUE) throw
+ new IOException("too many data clusters");
+
+ if (bs.getDataClusterCount() == 0) throw
+ new IOException("no data clusters");
+
+ this.lastClusterIndex = (int) bs.getDataClusterCount() + FIRST_CLUSTER;
+
+ entries = new long[(int) ((sectorCount * sectorSize) /
+ fatType.getEntrySize())];
+
+ if (lastClusterIndex > entries.length) throw new IOException(
+ "file system has " + lastClusterIndex +
+ "clusters but only " + entries.length + " FAT entries");
+ }
+
+ public FatType getFatType() {
+ return fatType;
+ }
+
+ /**
+ * Returns the {@code BootSector} that specifies this {@code Fat}.
+ *
+ * @return this {@code Fat}'s {@code BootSector}
+ */
+ public BootSector getBootSector() {
+ return this.bs;
+ }
+
+ /**
+ * Returns the {@code BlockDevice} where this {@code Fat} is stored.
+ *
+ * @return the device holding this FAT
+ */
+ public BlockDevice getDevice() {
+ return device;
+ }
+
+ private void init(int mediumDescriptor) {
+ entries[0] =
+ (mediumDescriptor & 0xFF) |
+ (0xFFFFF00L & fatType.getBitMask());
+ entries[1] = fatType.getEofMarker();
+ }
+
+ /**
+ * Read the contents of this FAT from the given device at the given offset.
+ *
+ * @param offset the byte offset where to read the FAT from the device
+ * @throws IOException on read error
+ */
+ private void read() throws IOException {
+ final byte[] data = new byte[sectorCount * sectorSize];
+ device.read(offset, ByteBuffer.wrap(data));
+
+ for (int i = 0; i < entries.length; i++)
+ entries[i] = fatType.readEntry(data, i);
+ }
+
+ public void write() throws IOException {
+ this.writeCopy(offset);
+ }
+
+ /**
+ * Write the contents of this FAT to the given device at the given offset.
+ *
+ * @param offset the device offset where to write the FAT copy
+ * @throws IOException on write error
+ */
+ public void writeCopy(long offset) throws IOException {
+ final byte[] data = new byte[sectorCount * sectorSize];
+
+ for (int index = 0; index < entries.length; index++) {
+ fatType.writeEntry(data, index, entries[index]);
+ }
+
+ device.write(offset, ByteBuffer.wrap(data));
+ }
+
+ /**
+ * Gets the medium descriptor byte
+ *
+ * @return int
+ */
+ public int getMediumDescriptor() {
+ return (int) (entries[0] & 0xFF);
+ }
+
+ /**
+ * Gets the entry at a given offset
+ *
+ * @param index
+ * @return long
+ */
+ public long getEntry(int index) {
+ return entries[index];
+ }
+
+ /**
+ * Returns the last free cluster that was accessed in this FAT.
+ *
+ * @return the last seen free cluster
+ */
+ public int getLastFreeCluster() {
+ return this.lastAllocatedCluster;
+ }
+
+ public long[] getChain(long startCluster) {
+ testCluster(startCluster);
+ // Count the chain first
+ int count = 1;
+ long cluster = startCluster;
+ while (!isEofCluster(entries[(int) cluster])) {
+ count++;
+ cluster = entries[(int) cluster];
+ }
+ // Now create the chain
+ long[] chain = new long[count];
+ chain[0] = startCluster;
+ cluster = startCluster;
+ int i = 0;
+ while (!isEofCluster(entries[(int) cluster])) {
+ cluster = entries[(int) cluster];
+ chain[++i] = cluster;
+ }
+ return chain;
+ }
+
+ /**
+ * Gets the cluster after the given cluster
+ *
+ * @param cluster
+ * @return long The next cluster number or -1 which means eof.
+ */
+ public long getNextCluster(long cluster) {
+ testCluster(cluster);
+ long entry = entries[(int) cluster];
+ if (isEofCluster(entry)) {
+ return -1;
+ } else {
+ return entry;
+ }
+ }
+
+ /**
+ * Allocate a cluster for a new file
+ *
+ * @return long the number of the newly allocated cluster
+ * @throws IOException if there are no free clusters
+ */
+ public long allocNew() throws IOException {
+
+ int i;
+ int entryIndex = -1;
+
+ for (i = lastAllocatedCluster; i < lastClusterIndex; i++) {
+ if (isFreeCluster(i)) {
+ entryIndex = i;
+ break;
+ }
+ }
+
+ if (entryIndex < 0) {
+ for (i = FIRST_CLUSTER; i < lastAllocatedCluster; i++) {
+ if (isFreeCluster(i)) {
+ entryIndex = i;
+ break;
+ }
+ }
+ }
+
+ if (entryIndex < 0) {
+ throw new IOException(
+ "FAT Full (" + (lastClusterIndex - FIRST_CLUSTER)
+ + ", " + i + ")"); //NOI18N
+ }
+
+ entries[entryIndex] = fatType.getEofMarker();
+ lastAllocatedCluster = entryIndex % lastClusterIndex;
+ if (lastAllocatedCluster < FIRST_CLUSTER)
+ lastAllocatedCluster = FIRST_CLUSTER;
+
+ return entryIndex;
+ }
+
+ /**
+ * Returns the number of clusters that are currently not in use by this FAT.
+ * This estimate does only account for clusters that are really available in
+ * the data portion of the file system, not for clusters that might only
+ * theoretically be stored in the {@code Fat}.
+ *
+ * @return the free cluster count
+ * @see FsInfoSector#setFreeClusterCount(long)
+ * @see FsInfoSector#getFreeClusterCount()
+ * @see BootSector#getDataClusterCount()
+ */
+ public int getFreeClusterCount() {
+ int result = 0;
+
+ for (int i=FIRST_CLUSTER; i < lastClusterIndex; i++) {
+ if (isFreeCluster(i)) result++;
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns the cluster number that was last allocated in this fat.
+ *
+ * @return
+ */
+ public int getLastAllocatedCluster() {
+ return this.lastAllocatedCluster;
+ }
+
+ /**
+ * Allocate a series of clusters for a new file.
+ *
+ * @param nrClusters when number of clusters to allocate
+ * @return long
+ * @throws IOException if there are no free clusters
+ */
+ public long[] allocNew(int nrClusters) throws IOException {
+ final long rc[] = new long[nrClusters];
+
+ rc[0] = allocNew();
+ for (int i = 1; i < nrClusters; i++) {
+ rc[i] = allocAppend(rc[i - 1]);
+ }
+
+ return rc;
+ }
+
+ /**
+ * Allocate a cluster to append to a new file
+ *
+ * @param cluster a cluster from a chain where the new cluster should be
+ * appended
+ * @return long the newly allocated and appended cluster number
+ * @throws IOException if there are no free clusters
+ */
+ public long allocAppend(long cluster)
+ throws IOException {
+
+ testCluster(cluster);
+
+ while (!isEofCluster(entries[(int) cluster])) {
+ cluster = entries[(int) cluster];
+ }
+
+ long newCluster = allocNew();
+ entries[(int) cluster] = newCluster;
+
+ return newCluster;
+ }
+
+ public void setEof(long cluster) {
+ testCluster(cluster);
+ entries[(int) cluster] = fatType.getEofMarker();
+ }
+
+ public void setFree(long cluster) {
+ testCluster(cluster);
+ entries[(int) cluster] = 0;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof Fat)) return false;
+
+ final Fat other = (Fat) obj;
+ if (this.fatType != other.fatType) return false;
+ if (this.sectorCount != other.sectorCount) return false;
+ if (this.sectorSize != other.sectorSize) return false;
+ if (this.lastClusterIndex != other.lastClusterIndex) return false;
+ if (!Arrays.equals(this.entries, other.entries)) return false;
+ if (this.getMediumDescriptor() != other.getMediumDescriptor())
+ return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 7;
+ hash = 23 * hash + Arrays.hashCode(this.entries);
+ hash = 23 * hash + this.fatType.hashCode();
+ hash = 23 * hash + this.sectorCount;
+ hash = 23 * hash + this.sectorSize;
+ hash = 23 * hash + this.lastClusterIndex;
+ return hash;
+ }
+
+ /**
+ * Is the given entry a free cluster?
+ *
+ * @param entry
+ * @return boolean
+ */
+ protected boolean isFreeCluster(long entry) {
+ if (entry > Integer.MAX_VALUE) throw new IllegalArgumentException();
+ return (entries[(int) entry] == 0);
+ }
+
+ /**
+ * Is the given entry a reserved cluster?
+ *
+ * @param entry
+ * @return boolean
+ */
+ protected boolean isReservedCluster(long entry) {
+ return fatType.isReservedCluster(entry);
+ }
+
+ /**
+ * Is the given entry an EOF marker
+ *
+ * @param entry
+ * @return boolean
+ */
+ protected boolean isEofCluster(long entry) {
+ return fatType.isEofCluster(entry);
+ }
+
+ protected void testCluster(long cluster) throws IllegalArgumentException {
+ if ((cluster < FIRST_CLUSTER) || (cluster >= entries.length)) {
+ throw new IllegalArgumentException(
+ "invalid cluster value " + cluster);
+ }
+ }
+
+ @Override
+ public String toString() {
+ final StringBuilder sb = new StringBuilder();
+
+ sb.append(this.getClass().getSimpleName());
+ sb.append("[type=");
+ sb.append(fatType);
+ sb.append(", mediumDescriptor=0x");
+ sb.append(Integer.toHexString(getMediumDescriptor()));
+ sb.append(", sectorCount=");
+ sb.append(sectorCount);
+ sb.append(", sectorSize=");
+ sb.append(sectorSize);
+ sb.append(", freeClusters=");
+ sb.append(getFreeClusterCount());
+ sb.append("]");
+
+ return sb.toString();
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Fat16BootSector.java b/src/main/java/de/waldheinz/fs/fat/Fat16BootSector.java
new file mode 100644
index 0000000..38bdc2e
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Fat16BootSector.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+
+/**
+ * The boot sector layout as used by the FAT12 / FAT16 variants.
+ *
+ * @author Matthias Treydte <matthias.treydte at meetwise.com>
+ */
+final class Fat16BootSector extends BootSector {
+
+ /**
+ * The default number of entries for the root directory.
+ *
+ * @see #getRootDirEntryCount()
+ * @see #setRootDirEntryCount(int)
+ */
+ public static final int DEFAULT_ROOT_DIR_ENTRY_COUNT = 512;
+
+ /**
+ * The default volume label.
+ */
+ public static final String DEFAULT_VOLUME_LABEL = "NO NAME"; //NOI18N
+
+ /**
+ * The maximum number of clusters for a FAT12 file system. This is actually
+ * the number of clusters where mkdosfs stop complaining about a FAT16
+ * partition having not enough sectors, so it would be misinterpreted
+ * as FAT12 without special handling.
+ *
+ * @see #getNrLogicalSectors()
+ */
+ public static final int MAX_FAT12_CLUSTERS = 4084;
+
+ public static final int MAX_FAT16_CLUSTERS = 65524;
+
+ /**
+ * The offset to the sectors per FAT value.
+ */
+ public static final int SECTORS_PER_FAT_OFFSET = 0x16;
+
+ /**
+ * The offset to the root directory entry count value.
+ *
+ * @see #getRootDirEntryCount()
+ * @see #setRootDirEntryCount(int)
+ */
+ public static final int ROOT_DIR_ENTRIES_OFFSET = 0x11;
+
+ /**
+ * The offset to the first byte of the volume label.
+ */
+ public static final int VOLUME_LABEL_OFFSET = 0x2b;
+
+ /**
+ * Offset to the FAT file system type string.
+ *
+ * @see #getFileSystemType()
+ */
+ public static final int FILE_SYSTEM_TYPE_OFFSET = 0x36;
+
+ /**
+ * The maximum length of the volume label.
+ */
+ public static final int MAX_VOLUME_LABEL_LENGTH = 11;
+
+ public static final int EXTENDED_BOOT_SIGNATURE_OFFSET = 0x26;
+
+ /**
+ * Creates a new {@code Fat16BootSector} for the specified device.
+ *
+ * @param device the {@code BlockDevice} holding the boot sector
+ */
+ public Fat16BootSector(BlockDevice device) {
+ super(device);
+ }
+
+ /**
+ * Returns the volume label that is stored in this boot sector.
+ *
+ * @return the volume label
+ */
+ public String getVolumeLabel() {
+ final StringBuilder sb = new StringBuilder();
+
+ for (int i=0; i < MAX_VOLUME_LABEL_LENGTH; i++) {
+ final char c = (char) get8(VOLUME_LABEL_OFFSET + i);
+
+ if (c != 0) {
+ sb.append(c);
+ } else {
+ break;
+ }
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Sets the volume label that is stored in this boot sector.
+ *
+ * @param label the new volume label
+ * @throws IllegalArgumentException if the specified label is longer
+ * than {@link #MAX_VOLUME_LABEL_LENGTH}
+ */
+ public void setVolumeLabel(String label) throws IllegalArgumentException {
+ if (label.length() > MAX_VOLUME_LABEL_LENGTH)
+ throw new IllegalArgumentException("volume label too long");
+
+ for (int i = 0; i < MAX_VOLUME_LABEL_LENGTH; i++) {
+ set8(VOLUME_LABEL_OFFSET + i,
+ i < label.length() ? label.charAt(i) : 0);
+ }
+ }
+
+ /**
+ * Gets the number of sectors/fat for FAT 12/16.
+ *
+ * @return int
+ */
+ @Override
+ public long getSectorsPerFat() {
+ return get16(SECTORS_PER_FAT_OFFSET);
+ }
+
+ /**
+ * Sets the number of sectors/fat
+ *
+ * @param v the new number of sectors per fat
+ */
+ @Override
+ public void setSectorsPerFat(long v) {
+ if (v == getSectorsPerFat()) return;
+ if (v > 0x7FFF) throw new IllegalArgumentException(
+ "too many sectors for a FAT12/16");
+
+ set16(SECTORS_PER_FAT_OFFSET, (int)v);
+ }
+
+ @Override
+ public FatType getFatType() {
+ final long rootDirSectors = ((getRootDirEntryCount() * 32) +
+ (getBytesPerSector() - 1)) / getBytesPerSector();
+ final long dataSectors = getSectorCount() -
+ (getNrReservedSectors() + (getNrFats() * getSectorsPerFat()) +
+ rootDirSectors);
+ final long clusterCount = dataSectors / getSectorsPerCluster();
+
+ if (clusterCount > MAX_FAT16_CLUSTERS) throw new IllegalStateException(
+ "too many clusters for FAT12/16: " + clusterCount);
+
+ return clusterCount > MAX_FAT12_CLUSTERS ?
+ FatType.FAT16 : FatType.FAT12;
+ }
+
+ @Override
+ public void setSectorCount(long count) {
+ if (count > 65535) {
+ setNrLogicalSectors(0);
+ setNrTotalSectors(count);
+ } else {
+ setNrLogicalSectors((int) count);
+ setNrTotalSectors(count);
+ }
+ }
+
+ @Override
+ public long getSectorCount() {
+ if (getNrLogicalSectors() == 0) return getNrTotalSectors();
+ else return getNrLogicalSectors();
+ }
+
+ /**
+ * Gets the number of entries in the root directory.
+ *
+ * @return int the root directory entry count
+ */
+ @Override
+ public int getRootDirEntryCount() {
+ return get16(ROOT_DIR_ENTRIES_OFFSET);
+ }
+
+ /**
+ * Sets the number of entries in the root directory
+ *
+ * @param v the new number of entries in the root directory
+ * @throws IllegalArgumentException for negative values
+ */
+ public void setRootDirEntryCount(int v) throws IllegalArgumentException {
+ if (v < 0) throw new IllegalArgumentException();
+ if (v == getRootDirEntryCount()) return;
+
+ set16(ROOT_DIR_ENTRIES_OFFSET, v);
+ }
+
+ @Override
+ public void init() throws IOException {
+ super.init();
+
+ setRootDirEntryCount(DEFAULT_ROOT_DIR_ENTRY_COUNT);
+ setVolumeLabel(DEFAULT_VOLUME_LABEL);
+ }
+
+ @Override
+ public int getFileSystemTypeLabelOffset() {
+ return FILE_SYSTEM_TYPE_OFFSET;
+ }
+
+ @Override
+ public int getExtendedBootSignatureOffset() {
+ return EXTENDED_BOOT_SIGNATURE_OFFSET;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Fat16RootDirectory.java b/src/main/java/de/waldheinz/fs/fat/Fat16RootDirectory.java
new file mode 100644
index 0000000..958e8a0
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Fat16RootDirectory.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * The root directory of a FAT12/16 partition.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+final class Fat16RootDirectory extends AbstractDirectory {
+ private final BlockDevice device;
+ private final long deviceOffset;
+
+ private Fat16RootDirectory(Fat16BootSector bs, boolean readOnly) {
+ super(bs.getRootDirEntryCount(), readOnly, true);
+
+ if (bs.getRootDirEntryCount() <= 0) throw new IllegalArgumentException(
+ "root directory size is " + bs.getRootDirEntryCount());
+
+ this.deviceOffset = FatUtils.getRootDirOffset(bs);
+ this.device = bs.getDevice();
+ }
+
+ /**
+ * Reads a {@code Fat16RootDirectory} as indicated by the specified
+ * {@code Fat16BootSector}.
+ *
+ * @param bs the boot sector that describes the root directory to read
+ * @param readOnly if the directory shold be created read-only
+ * @return the directory that was read
+ * @throws IOException on read error
+ */
+ public static Fat16RootDirectory read(
+ Fat16BootSector bs, boolean readOnly) throws IOException {
+
+ final Fat16RootDirectory result = new Fat16RootDirectory(bs, readOnly);
+ result.read();
+ return result;
+ }
+
+ /**
+ * Creates a new {@code Fat16RootDirectory} as indicated by the specified
+ * {@code Fat16BootSector}. The directory will always be created in
+ * read-write mode.
+ *
+ * @param bs the boot sector that describes the root directory to create
+ * @return the directory that was created
+ * @throws IOException on write error
+ */
+ public static Fat16RootDirectory create(
+ Fat16BootSector bs) throws IOException {
+
+ final Fat16RootDirectory result = new Fat16RootDirectory(bs, false);
+ result.flush();
+ return result;
+ }
+
+ @Override
+ protected void read(ByteBuffer data) throws IOException {
+ this.device.read(deviceOffset, data);
+ }
+
+ @Override
+ protected void write(ByteBuffer data) throws IOException {
+ this.device.write(deviceOffset, data);
+ }
+
+ /**
+ * By convention always returns 0, as the FAT12/16 root directory is not
+ * stored in a cluster chain.
+ *
+ * @return always 0
+ */
+ @Override
+ protected long getStorageCluster() {
+ return 0;
+ }
+
+ /**
+ * As a FAT12/16 root directory can not change it's size, this method
+ * throws a {@code DirectoryFullException} if the requested size is
+ * larger than {@link #getCapacity()} and does nothing else.
+ *
+ * @param entryCount {@inheritDoc}
+ */
+ @Override
+ protected void changeSize(int entryCount) throws DirectoryFullException {
+ if (getCapacity() < entryCount) {
+ throw new DirectoryFullException(getCapacity(), entryCount);
+ }
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Fat32BootSector.java b/src/main/java/de/waldheinz/fs/fat/Fat32BootSector.java
new file mode 100644
index 0000000..eded7ee
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Fat32BootSector.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+
+/**
+ * Contains the FAT32 specific parts of the boot sector.
+ *
+ * @author Matthias Treydte <matthias.treydte at meetwise.com>
+ */
+final class Fat32BootSector extends BootSector {
+
+ /**
+ * The offset to the entry specifying the first cluster of the FAT32
+ * root directory.
+ */
+ public final static int ROOT_DIR_FIRST_CLUSTER_OFFSET = 0x2c;
+
+ /**
+ * The offset to the 4 bytes specifying the sectors per FAT value.
+ */
+ public static final int SECTORS_PER_FAT_OFFSET = 0x24;
+
+ /**
+ * Offset to the file system type label.
+ */
+ public static final int FILE_SYSTEM_TYPE_OFFSET = 0x52;
+
+ public static final int VERSION_OFFSET = 0x2a;
+ public static final int VERSION = 0;
+
+ public static final int FS_INFO_SECTOR_OFFSET = 0x30;
+ public static final int BOOT_SECTOR_COPY_OFFSET = 0x32;
+ public static final int EXTENDED_BOOT_SIGNATURE_OFFSET = 0x42;
+
+ /*
+ * TODO: make this constructor private
+ */
+ public Fat32BootSector(BlockDevice device) throws IOException {
+ super(device);
+ }
+
+ @Override
+ public void init() throws IOException {
+ super.init();
+
+ set16(VERSION_OFFSET, VERSION);
+
+ setBootSectorCopySector(6); /* as suggested by M$ */
+ }
+
+ /**
+ * Returns the first cluster in the FAT that contains the root directory.
+ *
+ * @return the root directory's first cluster
+ */
+ public long getRootDirFirstCluster() {
+ return get32(ROOT_DIR_FIRST_CLUSTER_OFFSET);
+ }
+
+ /**
+ * Sets the first cluster of the root directory.
+ *
+ * @param value the root directory's first cluster
+ */
+ public void setRootDirFirstCluster(long value) {
+ if (getRootDirFirstCluster() == value) return;
+
+ set32(ROOT_DIR_FIRST_CLUSTER_OFFSET, value);
+ }
+
+ /**
+ * Sets the sectur number that contains a copy of the boot sector.
+ *
+ * @param sectNr the sector that contains a boot sector copy
+ */
+ public void setBootSectorCopySector(int sectNr) {
+ if (getBootSectorCopySector() == sectNr) return;
+ if (sectNr < 0) throw new IllegalArgumentException(
+ "boot sector copy sector must be >= 0");
+
+ set16(BOOT_SECTOR_COPY_OFFSET, sectNr);
+ }
+
+ /**
+ * Returns the sector that contains a copy of the boot sector, or 0 if
+ * there is no copy.
+ *
+ * @return the sector number of the boot sector copy
+ */
+ public int getBootSectorCopySector() {
+ return get16(BOOT_SECTOR_COPY_OFFSET);
+ }
+
+ /**
+ * Sets the 11-byte volume label stored at offset 0x47.
+ *
+ * @param label the new volume label, may be {@code null}
+ */
+ public void setVolumeLabel(String label) {
+ for (int i=0; i < 11; i++) {
+ final byte c =
+ (label == null) ? 0 :
+ (label.length() > i) ? (byte) label.charAt(i) : 0x20;
+
+ set8(0x47 + i, c);
+ }
+ }
+
+ public int getFsInfoSectorNr() {
+ return get16(FS_INFO_SECTOR_OFFSET);
+ }
+
+ public void setFsInfoSectorNr(int offset) {
+ if (getFsInfoSectorNr() == offset) return;
+
+ set16(FS_INFO_SECTOR_OFFSET, offset);
+ }
+
+ @Override
+ public void setSectorsPerFat(long v) {
+ if (getSectorsPerFat() == v) return;
+
+ set32(SECTORS_PER_FAT_OFFSET, v);
+ }
+
+ @Override
+ public long getSectorsPerFat() {
+ return get32(SECTORS_PER_FAT_OFFSET);
+ }
+
+ @Override
+ public FatType getFatType() {
+ return FatType.FAT32;
+ }
+
+ @Override
+ public void setSectorCount(long count) {
+ super.setNrTotalSectors(count);
+ }
+
+ @Override
+ public long getSectorCount() {
+ return super.getNrTotalSectors();
+ }
+
+ /**
+ * This is always 0 for FAT32.
+ *
+ * @return always 0
+ */
+ @Override
+ public int getRootDirEntryCount() {
+ return 0;
+ }
+
+ public void setFileSystemId(int id) {
+ super.set32(0x43, id);
+ }
+
+ public int getFileSystemId() {
+ return (int) super.get32(0x43);
+ }
+
+ /**
+ * Writes a copy of this boot sector to the specified device, if a copy
+ * is requested.
+ *
+ * @param device the device to write the boot sector copy to
+ * @throws IOException on write error
+ * @see #getBootSectorCopySector()
+ */
+ public void writeCopy(BlockDevice device) throws IOException {
+ if (getBootSectorCopySector() > 0) {
+ final long offset = getBootSectorCopySector() * SIZE;
+ buffer.rewind();
+ buffer.limit(buffer.capacity());
+ device.write(offset, buffer);
+ }
+ }
+
+ @Override
+ public int getFileSystemTypeLabelOffset() {
+ return FILE_SYSTEM_TYPE_OFFSET;
+ }
+
+ @Override
+ public int getExtendedBootSignatureOffset() {
+ return EXTENDED_BOOT_SIGNATURE_OFFSET;
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatDirectoryEntry.java b/src/main/java/de/waldheinz/fs/fat/FatDirectoryEntry.java
new file mode 100644
index 0000000..b7a3611
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatDirectoryEntry.java
@@ -0,0 +1,431 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFsObject;
+import java.nio.ByteBuffer;
+
+/**
+ *
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+final class FatDirectoryEntry extends AbstractFsObject {
+
+ /**
+ * The size in bytes of an FAT directory entry.
+ */
+ public final static int SIZE = 32;
+
+ /**
+ * The offset to the attributes byte.
+ */
+ private static final int OFFSET_ATTRIBUTES = 0x0b;
+
+ /**
+ * The offset to the file size dword.
+ */
+ private static final int OFFSET_FILE_SIZE = 0x1c;
+
+ private static final int F_READONLY = 0x01;
+ private static final int F_HIDDEN = 0x02;
+ private static final int F_SYSTEM = 0x04;
+ private static final int F_VOLUME_ID = 0x08;
+ private static final int F_DIRECTORY = 0x10;
+ private static final int F_ARCHIVE = 0x20;
+
+ private static final int MAX_CLUSTER = 0xFFFF;
+
+ /**
+ * The magic byte denoting that this entry was deleted and is free
+ * for reuse.
+ *
+ * @see #isDeleted()
+ */
+ public static final int ENTRY_DELETED_MAGIC = 0xe5;
+
+ private final byte[] data;
+ private boolean dirty;
+ boolean hasShortNameOnly;
+
+ FatDirectoryEntry(byte[] data, boolean readOnly) {
+ super(readOnly);
+
+ this.data = data;
+ }
+
+ private FatDirectoryEntry() {
+ this(new byte[SIZE], false);
+
+ }
+
+ /**
+ * Reads a {@code FatDirectoryEntry} from the specified {@code ByteBuffer}.
+ * The buffer must have at least {@link #SIZE} bytes remaining. The entry
+ * is read from the buffer's current position, and if this method returns
+ * non-null the position will have advanced by {@link #SIZE} bytes,
+ * otherwise the position will remain unchanged.
+ *
+ * @param buff the buffer to read the entry from
+ * @param readOnly if the resulting {@code FatDirecoryEntry} should be
+ * read-only
+ * @return the directory entry that was read from the buffer or {@code null}
+ * if there was no entry to read from the specified position (first
+ * byte was 0)
+ */
+ public static FatDirectoryEntry read(ByteBuffer buff, boolean readOnly) {
+ assert (buff.remaining() >= SIZE);
+
+ /* peek into the buffer to see if we're done with reading */
+
+ if (buff.get(buff.position()) == 0) return null;
+
+ /* read the directory entry */
+
+ final byte[] data = new byte[SIZE];
+ buff.get(data);
+ return new FatDirectoryEntry(data, readOnly);
+ }
+
+ public static void writeNullEntry(ByteBuffer buff) {
+ for (int i=0; i < SIZE; i++) {
+ buff.put((byte) 0);
+ }
+ }
+
+ /**
+ * Decides if this entry is a "volume label" entry according to the FAT
+ * specification.
+ *
+ * @return if this is a volume label entry
+ */
+ public boolean isVolumeLabel() {
+ if (isLfnEntry()) return false;
+ else return ((getFlags() & (F_DIRECTORY | F_VOLUME_ID)) == F_VOLUME_ID);
+ }
+
+ private void setFlag(int mask, boolean set) {
+ final int oldFlags = getFlags();
+
+ if (((oldFlags & mask) != 0) == set) return;
+
+ if (set) {
+ setFlags(oldFlags | mask);
+ } else {
+ setFlags(oldFlags & ~mask);
+ }
+
+ this.dirty = true;
+ }
+
+ public boolean isSystemFlag() {
+ return ((getFlags() & F_SYSTEM) != 0);
+ }
+
+ public void setSystemFlag(boolean isSystem) {
+ setFlag(F_SYSTEM, isSystem);
+ }
+
+ public boolean isArchiveFlag() {
+ return ((getFlags() & F_ARCHIVE) != 0);
+ }
+
+ public void setArchiveFlag(boolean isArchive) {
+ setFlag(F_ARCHIVE, isArchive);
+ }
+
+ public boolean isHiddenFlag() {
+ return ((getFlags() & F_HIDDEN) != 0);
+ }
+
+ public void setHiddenFlag(boolean isHidden) {
+ setFlag(F_HIDDEN, isHidden);
+ }
+
+ public boolean isVolumeIdFlag() {
+ return ((getFlags() & F_VOLUME_ID) != 0);
+ }
+
+ public boolean isLfnEntry() {
+ return isReadonlyFlag() && isSystemFlag() &&
+ isHiddenFlag() && isVolumeIdFlag();
+ }
+
+ public boolean isDirty() {
+ return dirty;
+ }
+
+ private int getFlags() {
+ return LittleEndian.getUInt8(data, OFFSET_ATTRIBUTES);
+ }
+
+ private void setFlags(int flags) {
+ LittleEndian.setInt8(data, OFFSET_ATTRIBUTES, flags);
+ }
+
+ public boolean isDirectory() {
+ return ((getFlags() & (F_DIRECTORY | F_VOLUME_ID)) == F_DIRECTORY);
+ }
+
+ public static FatDirectoryEntry create(boolean directory) {
+ final FatDirectoryEntry result = new FatDirectoryEntry();
+
+ if (directory) {
+ result.setFlags(F_DIRECTORY);
+ }
+
+ /* initialize date and time fields */
+
+ final long now = System.currentTimeMillis();
+ result.setCreated(now);
+ result.setLastAccessed(now);
+ result.setLastModified(now);
+
+ return result;
+ }
+
+ public static FatDirectoryEntry createVolumeLabel(String volumeLabel) {
+ assert(volumeLabel != null);
+
+ final byte[] data = new byte[SIZE];
+
+ System.arraycopy(
+ volumeLabel.getBytes(), 0,
+ data, 0,
+ volumeLabel.length());
+
+ final FatDirectoryEntry result = new FatDirectoryEntry(data, false);
+ result.setFlags(FatDirectoryEntry.F_VOLUME_ID);
+ return result;
+ }
+
+ public String getVolumeLabel() {
+ if (!isVolumeLabel())
+ throw new UnsupportedOperationException("not a volume label");
+
+ final StringBuilder sb = new StringBuilder();
+
+ for (int i=0; i < AbstractDirectory.MAX_LABEL_LENGTH; i++) {
+ final byte b = this.data[i];
+
+ if (b != 0) {
+ sb.append((char) b);
+ } else {
+ break;
+ }
+ }
+
+ return sb.toString();
+ }
+
+ public long getCreated() {
+ return DosUtils.decodeDateTime(
+ LittleEndian.getUInt16(data, 0x10),
+ LittleEndian.getUInt16(data, 0x0e));
+ }
+
+ public void setCreated(long created) {
+ LittleEndian.setInt16(data, 0x0e,
+ DosUtils.encodeTime(created));
+ LittleEndian.setInt16(data, 0x10,
+ DosUtils.encodeDate(created));
+
+ this.dirty = true;
+ }
+
+ public long getLastModified() {
+ return DosUtils.decodeDateTime(
+ LittleEndian.getUInt16(data, 0x18),
+ LittleEndian.getUInt16(data, 0x16));
+ }
+
+ public void setLastModified(long lastModified) {
+ LittleEndian.setInt16(data, 0x16,
+ DosUtils.encodeTime(lastModified));
+ LittleEndian.setInt16(data, 0x18,
+ DosUtils.encodeDate(lastModified));
+
+ this.dirty = true;
+ }
+
+ public long getLastAccessed() {
+ return DosUtils.decodeDateTime(
+ LittleEndian.getUInt16(data, 0x12),
+ 0); /* time is not recorded */
+ }
+
+ public void setLastAccessed(long lastAccessed) {
+ LittleEndian.setInt16(data, 0x12,
+ DosUtils.encodeDate(lastAccessed));
+
+ this.dirty = true;
+ }
+
+ /**
+ * Returns if this entry has been marked as deleted. A deleted entry has
+ * its first byte set to the magic {@link #ENTRY_DELETED_MAGIC} value.
+ *
+ * @return if this entry is marked as deleted
+ */
+ public boolean isDeleted() {
+ return (LittleEndian.getUInt8(data, 0) == ENTRY_DELETED_MAGIC);
+ }
+
+ /**
+ * Returns the size of this entry as stored at {@link #OFFSET_FILE_SIZE}.
+ *
+ * @return the size of the file represented by this entry
+ */
+ public long getLength() {
+ return LittleEndian.getUInt32(data, OFFSET_FILE_SIZE);
+ }
+
+ /**
+ * Sets the size of this entry stored at {@link #OFFSET_FILE_SIZE}.
+ *
+ * @param length the new size of the file represented by this entry
+ * @throws IllegalArgumentException if {@code length} is out of range
+ */
+ public void setLength(long length) throws IllegalArgumentException {
+ LittleEndian.setInt32(data, OFFSET_FILE_SIZE, length);
+ }
+
+ /**
+ * Returns the {@code ShortName} that is stored in this directory entry or
+ * {@code null} if this entry has not been initialized.
+ *
+ * @return the {@code ShortName} stored in this entry or {@code null}
+ */
+ public ShortName getShortName() {
+ if (this.data[0] == 0) {
+ return null;
+ } else {
+ return ShortName.parse(this.data);
+ }
+ }
+
+ /**
+ * Does this entry refer to a file?
+ *
+ * @return
+ * @see org.jnode.fs.FSDirectoryEntry#isFile()
+ */
+ public boolean isFile() {
+ return ((getFlags() & (F_DIRECTORY | F_VOLUME_ID)) == 0);
+ }
+
+ public void setShortName(ShortName sn) {
+ if (sn.equals(this.getShortName())) return;
+
+ sn.write(this.data);
+ this.hasShortNameOnly = sn.hasShortNameOnly();
+ this.dirty = true;
+ }
+
+ /**
+ * Returns the startCluster.
+ *
+ * @return int
+ */
+ public long getStartCluster() {
+ int lowBytes = LittleEndian.getUInt16(data, 0x1a);
+ long highBytes = LittleEndian.getUInt16(data, 0x14);
+ return ( highBytes << 16 | lowBytes );
+ }
+
+ /**
+ * Sets the startCluster.
+ *
+ * @param startCluster The startCluster to set
+ */
+ void setStartCluster(long startCluster) {
+ if ( startCluster > Integer.MAX_VALUE ) throw new AssertionError();
+
+ LittleEndian.setInt16(data, 0x1a, (int) startCluster);
+ LittleEndian.setInt16(data, 0x14, (int)(startCluster >>> 16));
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() +
+ " [name=" + getShortName() + "]"; //NOI18N
+ }
+
+ /**
+ * Writes this directory entry into the specified buffer.
+ *
+ * @param buff the buffer to write this entry to
+ */
+ void write(ByteBuffer buff) {
+ buff.put(data);
+ this.dirty = false;
+ }
+
+ /**
+ * Returns if the read-only flag is set for this entry. Do not confuse
+ * this with {@link #isReadOnly()}.
+ *
+ * @return if the read only file system flag is set on this entry
+ * @see #F_READONLY
+ * @see #setReadonlyFlag(boolean)
+ */
+ public boolean isReadonlyFlag() {
+ return ((getFlags() & F_READONLY) != 0);
+ }
+
+ /**
+ * Updates the read-only file system flag for this entry.
+ *
+ * @param isReadonly the new value for the read-only flag
+ * @see #F_READONLY
+ * @see #isReadonlyFlag()
+ */
+ public void setReadonlyFlag(boolean isReadonly) {
+ setFlag(F_READONLY, isReadonly);
+ }
+
+ String getLfnPart() {
+ final char[] unicodechar = new char[13];
+
+ unicodechar[0] = (char) LittleEndian.getUInt16(data, 1);
+ unicodechar[1] = (char) LittleEndian.getUInt16(data, 3);
+ unicodechar[2] = (char) LittleEndian.getUInt16(data, 5);
+ unicodechar[3] = (char) LittleEndian.getUInt16(data, 7);
+ unicodechar[4] = (char) LittleEndian.getUInt16(data, 9);
+ unicodechar[5] = (char) LittleEndian.getUInt16(data, 14);
+ unicodechar[6] = (char) LittleEndian.getUInt16(data, 16);
+ unicodechar[7] = (char) LittleEndian.getUInt16(data, 18);
+ unicodechar[8] = (char) LittleEndian.getUInt16(data, 20);
+ unicodechar[9] = (char) LittleEndian.getUInt16(data, 22);
+ unicodechar[10] = (char) LittleEndian.getUInt16(data, 24);
+ unicodechar[11] = (char) LittleEndian.getUInt16(data, 28);
+ unicodechar[12] = (char) LittleEndian.getUInt16(data, 30);
+
+ int end = 0;
+
+ while ((end < 13) && (unicodechar[end] != '\0')) {
+ end++;
+ }
+
+ return new String(unicodechar).substring(0, end);
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatFile.java b/src/main/java/de/waldheinz/fs/fat/FatFile.java
new file mode 100644
index 0000000..95942e0
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatFile.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFsObject;
+import java.io.IOException;
+import de.waldheinz.fs.FsFile;
+import de.waldheinz.fs.ReadOnlyException;
+import java.io.EOFException;
+import java.nio.ByteBuffer;
+
+/**
+ * The in-memory representation of a single file (chain of clusters) on a
+ * FAT file system.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @since 0.6
+ */
+public final class FatFile extends AbstractFsObject implements FsFile {
+ private final FatDirectoryEntry entry;
+ private final ClusterChain chain;
+
+ private FatFile(FatDirectoryEntry myEntry, ClusterChain chain) {
+ super(myEntry.isReadOnly());
+
+ this.entry = myEntry;
+ this.chain = chain;
+ }
+
+ static FatFile get(Fat fat, FatDirectoryEntry entry)
+ throws IOException {
+
+ if (entry.isDirectory())
+ throw new IllegalArgumentException(entry + " is a directory");
+
+ final ClusterChain cc = new ClusterChain(
+ fat, entry.getStartCluster(), entry.isReadonlyFlag());
+
+ if (entry.getLength() > cc.getLengthOnDisk()) throw new IOException(
+ "entry is larger than associated cluster chain");
+
+ return new FatFile(entry, cc);
+ }
+
+ /**
+ * Returns the length of this file in bytes. This is the length that
+ * is stored in the directory entry that is associated with this file.
+ *
+ * @return long the length that is recorded for this file
+ */
+ @Override
+ public long getLength() {
+ checkValid();
+
+ return entry.getLength();
+ }
+
+ /**
+ * Sets the size (in bytes) of this file. Because
+ * {@link #write(long, java.nio.ByteBuffer) writing} to the file will grow
+ * it automatically if needed, this method is mainly usefull for truncating
+ * a file.
+ *
+ * @param length the new length of the file in bytes
+ * @throws ReadOnlyException if this file is read-only
+ * @throws IOException on error updating the file size
+ */
+ @Override
+ public void setLength(long length) throws ReadOnlyException, IOException {
+ checkWritable();
+
+ if (getLength() == length) return;
+
+ updateTimeStamps(true);
+ chain.setSize(length);
+
+ this.entry.setStartCluster(chain.getStartCluster());
+ this.entry.setLength(length);
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * Unless this file is {@link #isReadOnly() read-ony}, this method also
+ * updates the "last accessed" field in the directory entry that is
+ * associated with this file.
+ * </p>
+ *
+ * @param offset {@inheritDoc}
+ * @param dest {@inheritDoc}
+ * @see FatDirectoryEntry#setLastAccessed(long)
+ */
+ @Override
+ public void read(long offset, ByteBuffer dest) throws IOException {
+ checkValid();
+
+ final int len = dest.remaining();
+
+ if (len == 0) return;
+
+ if (offset + len > getLength()) {
+ throw new EOFException();
+ }
+
+ if (!isReadOnly()) {
+ updateTimeStamps(false);
+ }
+
+ chain.readData(offset, dest);
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * If the data to be written extends beyond the current
+ * {@link #getLength() length} of this file, an attempt is made to
+ * {@link #setLength(long) grow} the file so that the data will fit.
+ * Additionally, this method updates the "last accessed" and "last modified"
+ * fields on the directory entry that is associated with this file.
+ * </p>
+ *
+ * @param offset {@inheritDoc}
+ * @param srcBuf {@inheritDoc}
+ */
+ @Override
+ public void write(long offset, ByteBuffer srcBuf)
+ throws ReadOnlyException, IOException {
+
+ checkWritable();
+
+ updateTimeStamps(true);
+
+ final long lastByte = offset + srcBuf.remaining();
+
+ if (lastByte > getLength()) {
+ setLength(lastByte);
+ }
+
+ chain.writeData(offset, srcBuf);
+ }
+
+ private void updateTimeStamps(boolean write) {
+ final long now = System.currentTimeMillis();
+ entry.setLastAccessed(now);
+
+ if (write) {
+ entry.setLastModified(now);
+ }
+ }
+
+ /**
+ * Has no effect besides possibly throwing an {@code ReadOnlyException}. To
+ * make sure that all data is written out to disk use the
+ * {@link FatFileSystem#flush()} method.
+ *
+ * @throws ReadOnlyException if this {@code FatFile} is read-only
+ */
+ @Override
+ public void flush() throws ReadOnlyException {
+ checkWritable();
+
+ /* nothing else to do */
+ }
+
+ /**
+ * Returns the {@code ClusterChain} that holds the contents of
+ * this {@code FatFile}.
+ *
+ * @return the file's {@code ClusterChain}
+ */
+ ClusterChain getChain() {
+ checkValid();
+
+ return chain;
+ }
+
+ /**
+ * Returns a human-readable string representation of this {@code FatFile},
+ * mainly for debugging purposes.
+ *
+ * @return a string describing this {@code FatFile}
+ */
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + " [length=" + getLength() +
+ ", first cluster=" + chain.getStartCluster() + "]";
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatFileSystem.java b/src/main/java/de/waldheinz/fs/fat/FatFileSystem.java
new file mode 100644
index 0000000..db4d3e2
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatFileSystem.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFileSystem;
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import de.waldheinz.fs.ReadOnlyException;
+
+/**
+ * <p>
+ * Implements the {@code FileSystem} interface for the FAT family of file
+ * systems. This class always uses the "long file name" specification when
+ * writing directory entries.
+ * </p><p>
+ * For creating (aka "formatting") FAT file systems please refer to the
+ * {@link SuperFloppyFormatter} class.
+ * </p>
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public final class FatFileSystem extends AbstractFileSystem {
+
+ private final Fat fat;
+ private final FsInfoSector fsiSector;
+ private final BootSector bs;
+ private final FatLfnDirectory rootDir;
+ private final AbstractDirectory rootDirStore;
+ private final FatType fatType;
+ private final long filesOffset;
+
+ FatFileSystem(BlockDevice api, boolean readOnly) throws IOException {
+
+ this(api, readOnly, false);
+ }
+
+ /**
+ * Constructor for FatFileSystem in specified readOnly mode
+ *
+ * @param device the {@code BlockDevice} holding the file system
+ * @param readOnly if this FS should be read-lonly
+ * @param ignoreFatDifferences
+ * @throws IOException on read error
+ */
+ private FatFileSystem(BlockDevice device, boolean readOnly,
+ boolean ignoreFatDifferences)
+ throws IOException {
+
+ super(readOnly);
+
+ this.bs = BootSector.read(device);
+
+ if (bs.getNrFats() <= 0) throw new IOException(
+ "boot sector says there are no FATs");
+
+ this.filesOffset = FatUtils.getFilesOffset(bs);
+ this.fatType = bs.getFatType();
+ this.fat = Fat.read(bs, 0);
+
+ if (!ignoreFatDifferences) {
+ for (int i=1; i < bs.getNrFats(); i++) {
+ final Fat tmpFat = Fat.read(bs, i);
+ if (!fat.equals(tmpFat)) {
+ throw new IOException("FAT " + i + " differs from FAT 0");
+ }
+ }
+ }
+
+ if (fatType == FatType.FAT32) {
+ final Fat32BootSector f32bs = (Fat32BootSector) bs;
+ ClusterChain rootDirFile = new ClusterChain(fat,
+ f32bs.getRootDirFirstCluster(), isReadOnly());
+ this.rootDirStore = ClusterChainDirectory.readRoot(rootDirFile);
+ this.fsiSector = FsInfoSector.read(f32bs);
+
+ if (fsiSector.getFreeClusterCount() != fat.getFreeClusterCount()) {
+ throw new IOException("free cluster count mismatch - fat: " +
+ fat.getFreeClusterCount() + " - fsinfo: " +
+ fsiSector.getFreeClusterCount());
+ }
+ } else {
+ this.rootDirStore =
+ Fat16RootDirectory.read((Fat16BootSector) bs,readOnly);
+ this.fsiSector = null;
+ }
+
+ this.rootDir = new FatLfnDirectory(rootDirStore, fat, isReadOnly());
+
+ }
+
+ /**
+ * Reads the file system structure from the specified {@code BlockDevice}
+ * and returns a fresh {@code FatFileSystem} instance to read or modify
+ * it.
+ *
+ * @param device the {@code BlockDevice} holding the file system
+ * @param readOnly if the {@code FatFileSystem} should be in read-only mode
+ * @return the {@code FatFileSystem} instance for the device
+ * @throws IOException on read error or if the file system structure could
+ * not be parsed
+ */
+ public static FatFileSystem read(BlockDevice device, boolean readOnly)
+ throws IOException {
+
+ return new FatFileSystem(device, readOnly);
+ }
+
+ long getFilesOffset() {
+ checkClosed();
+
+ return filesOffset;
+ }
+
+ /**
+ * Returns the size of the FAT entries of this {@code FatFileSystem}.
+ *
+ * @return the exact type of the FAT used by this file system
+ */
+ public FatType getFatType() {
+ checkClosed();
+
+ return this.fatType;
+ }
+
+ /**
+ * Returns the volume label of this file system.
+ *
+ * @return the volume label
+ */
+ public String getVolumeLabel() {
+ checkClosed();
+
+ final String fromDir = rootDirStore.getLabel();
+
+ if (fromDir == null && fatType != FatType.FAT32) {
+ return ((Fat16BootSector)bs).getVolumeLabel();
+ } else {
+ return fromDir;
+ }
+ }
+
+ /**
+ * Sets the volume label for this file system.
+ *
+ * @param label the new volume label, may be {@code null}
+ * @throws ReadOnlyException if the file system is read-only
+ * @throws IOException on write error
+ */
+ public void setVolumeLabel(String label)
+ throws ReadOnlyException, IOException {
+
+ checkClosed();
+ checkReadOnly();
+
+ rootDirStore.setLabel(label);
+
+ if (fatType != FatType.FAT32) {
+ ((Fat16BootSector)bs).setVolumeLabel(label);
+ }
+ }
+
+ AbstractDirectory getRootDirStore() {
+ checkClosed();
+
+ return rootDirStore;
+ }
+
+ /**
+ * Flush all changed structures to the device.
+ *
+ * @throws IOException on write error
+ */
+ @Override
+ public void flush() throws IOException {
+ checkClosed();
+
+ if (bs.isDirty()) {
+ bs.write();
+ }
+
+ for (int i = 0; i < bs.getNrFats(); i++) {
+ fat.writeCopy(FatUtils.getFatOffset(bs, i));
+ }
+
+ rootDir.flush();
+
+ if (fsiSector != null) {
+ fsiSector.setFreeClusterCount(fat.getFreeClusterCount());
+ fsiSector.setLastAllocatedCluster(fat.getLastAllocatedCluster());
+ fsiSector.write();
+ }
+ }
+
+ @Override
+ public FatLfnDirectory getRoot() {
+ checkClosed();
+
+ return rootDir;
+ }
+
+ /**
+ * Returns the fat.
+ *
+ * @return Fat
+ */
+ public Fat getFat() {
+ return fat;
+ }
+
+ /**
+ * Returns the bootsector.
+ *
+ * @return BootSector
+ */
+ public BootSector getBootSector() {
+ checkClosed();
+
+ return bs;
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * This method shows the free space in terms of available clusters.
+ * </p>
+ *
+ * @return always -1
+ */
+ @Override
+ public long getFreeSpace() {
+ return this.fat.getFreeClusterCount() * this.bs.getBytesPerCluster();
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * This method is currently not implemented for {@code FatFileSystem} and
+ * always returns -1.
+ * </p>
+ *
+ * @return always -1
+ */
+ @Override
+ public long getTotalSpace() {
+ return this.bs.getDataClusterCount() * this.bs.getBytesPerCluster();
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * This method is currently not implemented for {@code FatFileSystem} and
+ * always returns -1.
+ * </p>
+ *
+ * @return always -1
+ */
+ @Override
+ public long getUsableSpace() {
+ // TODO implement me
+ return -1;
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatLfnDirectory.java b/src/main/java/de/waldheinz/fs/fat/FatLfnDirectory.java
new file mode 100644
index 0000000..9f4aa9b
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatLfnDirectory.java
@@ -0,0 +1,438 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFsObject;
+import de.waldheinz.fs.FsDirectory;
+import de.waldheinz.fs.FsDirectoryEntry;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The {@link FsDirectory} implementation for FAT file systems. This
+ * implementation aims to fully comply to the FAT specification, including
+ * the quite complex naming system regarding the long file names (LFNs) and
+ * their corresponding 8+3 short file names. This also means that an
+ * {@code FatLfnDirectory} is case-preserving but <em>not</em> case-sensitive.
+ *
+ * @author gbin
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @since 0.6
+ */
+public final class FatLfnDirectory
+ extends AbstractFsObject
+ implements FsDirectory {
+
+ /**
+ * This set is used to check if a file name is already in use in this
+ * directory. The FAT specification says that file names must be unique
+ * ignoring the case, so this set contains all names converted to
+ * lower-case, and all checks must be performed using lower-case strings.
+ */
+ private final Set<String> usedNames;
+ private final Fat fat;
+ private final Map<ShortName, FatLfnDirectoryEntry> shortNameIndex;
+ private final Map<String, FatLfnDirectoryEntry> longNameIndex;
+ private final Map<FatDirectoryEntry, FatFile> entryToFile;
+ private final Map<FatDirectoryEntry, FatLfnDirectory> entryToDirectory;
+ private Dummy83BufferGenerator dbg;
+
+ final AbstractDirectory dir;
+
+ FatLfnDirectory(AbstractDirectory dir, Fat fat, boolean readOnly)
+ throws IOException {
+
+ super(readOnly);
+
+ if ((dir == null) || (fat == null)) throw new NullPointerException();
+
+ this.fat = fat;
+ this.dir = dir;
+
+ this.shortNameIndex =
+ new LinkedHashMap<ShortName, FatLfnDirectoryEntry>();
+
+ this.longNameIndex =
+ new LinkedHashMap<String, FatLfnDirectoryEntry>();
+
+ this.entryToFile =
+ new LinkedHashMap<FatDirectoryEntry, FatFile>();
+
+ this.entryToDirectory =
+ new LinkedHashMap<FatDirectoryEntry, FatLfnDirectory>();
+
+ this.usedNames = new HashSet<String>();
+ this.dbg = new Dummy83BufferGenerator();
+
+ parseLfn();
+ }
+
+ FatFile getFile(FatDirectoryEntry entry) throws IOException {
+ FatFile file = entryToFile.get(entry);
+
+ if (file == null) {
+ file = FatFile.get(fat, entry);
+ entryToFile.put(entry, file);
+ }
+
+ return file;
+ }
+
+ FatLfnDirectory getDirectory(FatDirectoryEntry entry) throws IOException {
+ FatLfnDirectory result = entryToDirectory.get(entry);
+
+ if (result == null) {
+ final ClusterChainDirectory storage = read(entry, fat);
+ result = new FatLfnDirectory(storage, fat, isReadOnly());
+ entryToDirectory.put(entry, result);
+ }
+
+ return result;
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * According to the FAT file system specification, leading and trailing
+ * spaces in the {@code name} are ignored by this method.
+ * </p>
+ *
+ * @param name {@inheritDoc}
+ * @return {@inheritDoc}
+ * @throws IOException {@inheritDoc}
+ */
+ @Override
+ public FatLfnDirectoryEntry addFile(String name) throws IOException {
+ checkWritable();
+ checkUniqueName(name);
+
+ name = name.trim();
+ final ShortName sn = makeShortName(name, false);
+
+ final FatLfnDirectoryEntry entry =
+ new FatLfnDirectoryEntry(name, sn, this, false);
+
+ dir.addEntries(entry.compactForm());
+
+ shortNameIndex.put(sn, entry);
+ longNameIndex.put(name.toLowerCase(), entry);
+
+ getFile(entry.realEntry);
+
+ dir.setDirty();
+ return entry;
+ }
+
+ boolean isFreeName(String name) {
+ return true;
+ }
+
+ private void checkUniqueName(String name) throws IOException {
+ }
+
+ private void freeUniqueName(String name) {
+ }
+
+ private ShortName makeShortName(String name, boolean isDirectory) throws IOException {
+ final ShortName result;
+
+ try {
+ result = dbg.generate83BufferNew(name);
+ } catch (IllegalArgumentException ex) {
+ throw new IOException(
+ "could not generate short name for \"" + name + "\"", ex);
+ }
+ return result;
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * According to the FAT file system specification, leading and trailing
+ * spaces in the {@code name} are ignored by this method.
+ * </p>
+ *
+ * @param name {@inheritDoc}
+ * @return {@inheritDoc}
+ * @throws IOException {@inheritDoc}
+ */
+ @Override
+ public FatLfnDirectoryEntry addDirectory(String name) throws IOException {
+ checkWritable();
+ checkUniqueName(name);
+
+ name = name.trim();
+ final ShortName sn = makeShortName(name, true);
+ final FatDirectoryEntry real = dir.createSub(fat);
+ real.setShortName(sn);
+ final FatLfnDirectoryEntry e =
+ new FatLfnDirectoryEntry(this, real, name);
+
+ try {
+ dir.addEntries(e.compactForm());
+ } catch (IOException ex) {
+ final ClusterChain cc =
+ new ClusterChain(fat, real.getStartCluster(), false);
+ cc.setChainLength(0);
+ dir.removeEntry(real);
+ throw ex;
+ }
+
+ shortNameIndex.put(sn, e);
+ longNameIndex.put(name.toLowerCase(), e);
+
+ getDirectory(real);
+
+ flush();
+ return e;
+ }
+
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p><p>
+ * According to the FAT file system specification, leading and trailing
+ * spaces in the {@code name} are ignored by this method.
+ * </p>
+ *
+ * @param name {@inheritDoc}
+ * @return {@inheritDoc}
+ */
+ @Override
+ public FatLfnDirectoryEntry getEntry(String name) {
+ name = name.trim().toLowerCase();
+
+ final FatLfnDirectoryEntry entry = longNameIndex.get(name);
+
+ if (entry == null) {
+ if (!ShortName.canConvert(name)) return null;
+ return shortNameIndex.get(ShortName.get(name));
+ } else {
+ return entry;
+ }
+ }
+
+ private void parseLfn() throws IOException {
+ int i = 0;
+ final int size = dir.getEntryCount();
+
+ while (i < size) {
+ // jump over empty entries
+ while (i < size && dir.getEntry(i) == null) {
+ i++;
+ }
+
+ if (i >= size) {
+ break;
+ }
+
+ int offset = i; // beginning of the entry
+ // check when we reach a real entry
+ while (dir.getEntry(i).isLfnEntry()) {
+ i++;
+ if (i >= size) {
+ // This is a cutted entry, forgive it
+ break;
+ }
+ }
+
+ if (i >= size) {
+ // This is a cutted entry, forgive it
+ break;
+ }
+
+ final FatLfnDirectoryEntry current =
+ FatLfnDirectoryEntry.extract(this, offset, ++i - offset);
+
+ if (!current.realEntry.isDeleted() && current.isValid()) {
+ checkUniqueName(current.getName());
+
+ shortNameIndex.put(current.realEntry.getShortName(), current);
+ longNameIndex.put(current.getName().toLowerCase(), current);
+ }
+ }
+ }
+
+ private void updateLFN() throws IOException {
+ ArrayList<FatDirectoryEntry> dest =
+ new ArrayList<FatDirectoryEntry>();
+
+ for (FatLfnDirectoryEntry currentEntry : shortNameIndex.values()) {
+ FatDirectoryEntry[] encoded = currentEntry.compactForm();
+ dest.addAll(Arrays.asList(encoded));
+ }
+
+ final int size = dest.size();
+
+ dir.changeSize(size);
+ dir.setEntries(dest);
+ }
+
+ @Override
+ public void flush() throws IOException {
+ checkWritable();
+
+ for (FatFile f : entryToFile.values()) {
+ f.flush();
+ }
+
+ for (FatLfnDirectory d : entryToDirectory.values()) {
+ d.flush();
+ }
+
+ updateLFN();
+ dir.flush();
+ }
+
+ @Override
+ public Iterator<FsDirectoryEntry> iterator() {
+ return new Iterator<FsDirectoryEntry>() {
+
+ final Iterator<FatLfnDirectoryEntry> it =
+ shortNameIndex.values().iterator();
+
+ @Override
+ public boolean hasNext() {
+ return it.hasNext();
+ }
+
+ @Override
+ public FsDirectoryEntry next() {
+ return it.next();
+ }
+
+ /**
+ * @see java.util.Iterator#remove()
+ */
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ };
+ }
+
+ /**
+ * Remove the entry with the given name from this directory.
+ *
+ * @param name the name of the entry to remove
+ * @throws IOException on error removing the entry
+ * @throws IllegalArgumentException on an attempt to remove the dot entries
+ */
+ @Override
+ public void remove(String name)
+ throws IOException, IllegalArgumentException {
+
+ checkWritable();
+
+ final FatLfnDirectoryEntry entry = getEntry(name);
+ if (entry == null) return;
+
+ unlinkEntry(entry);
+
+ final ClusterChain cc = new ClusterChain(
+ fat, entry.realEntry.getStartCluster(), false);
+
+ cc.setChainLength(0);
+
+ freeUniqueName(name);
+ updateLFN();
+ }
+
+ /**
+ * Unlinks the specified entry from this directory without actually
+ * deleting it.
+ *
+ * @param e the entry to be unlinked
+ * @see #linkEntry(de.waldheinz.fs.fat.FatLfnDirectoryEntry)
+ */
+ void unlinkEntry(FatLfnDirectoryEntry entry) {
+ final ShortName sn = entry.realEntry.getShortName();
+
+ if (sn.equals(ShortName.DOT) || sn.equals(ShortName.DOT_DOT)) throw
+ new IllegalArgumentException(
+ "the dot entries can not be removed");
+
+ final String lowerName = entry.getName().toLowerCase();
+
+ assert (this.longNameIndex.containsKey(lowerName));
+ this.longNameIndex.remove(lowerName);
+
+ assert (this.shortNameIndex.containsKey(sn));
+ this.shortNameIndex.remove(sn);
+
+ if (entry.isFile()) {
+ this.entryToFile.remove(entry.realEntry);
+ } else {
+ this.entryToDirectory.remove(entry.realEntry);
+ }
+ }
+
+ /**
+ * Links the specified entry to this directory, updating the entrie's
+ * short name.
+ *
+ * @param entry the entry to be linked (added) to this directory
+ * @see #unlinkEntry(de.waldheinz.fs.fat.FatLfnDirectoryEntry)
+ */
+ void linkEntry(FatLfnDirectoryEntry entry) throws IOException {
+ checkUniqueName(entry.getName());
+ ShortName name;
+ name = this.dbg.generate83BufferNew(entry.getName());
+ entry.realEntry.setShortName(name);
+
+ this.longNameIndex.put(entry.getName().toLowerCase(), entry);
+ this.shortNameIndex.put(entry.realEntry.getShortName(), entry);
+
+ updateLFN();
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() +
+ " [size=" + shortNameIndex.size() + //NOI18N
+ ", dir=" + dir + "]"; //NOI18N
+ }
+
+ private static ClusterChainDirectory read(FatDirectoryEntry entry, Fat fat)
+ throws IOException {
+
+ if (!entry.isDirectory()) throw
+ new IllegalArgumentException(entry + " is no directory");
+
+ final ClusterChain chain = new ClusterChain(
+ fat, entry.getStartCluster(),
+ entry.isReadonlyFlag());
+
+ final ClusterChainDirectory result =
+ new ClusterChainDirectory(chain, false);
+
+ result.read();
+ return result;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatLfnDirectoryEntry.java b/src/main/java/de/waldheinz/fs/fat/FatLfnDirectoryEntry.java
new file mode 100644
index 0000000..0882516
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatLfnDirectoryEntry.java
@@ -0,0 +1,378 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.AbstractFsObject;
+import de.waldheinz.fs.FsDirectoryEntry;
+import de.waldheinz.fs.ReadOnlyException;
+import java.io.IOException;
+
+/**
+ * Represents an entry in a {@link FatLfnDirectory}. Besides implementing the
+ * {@link FsDirectoryEntry} interface for FAT file systems, it allows access
+ * to the {@link #setArchiveFlag(boolean) archive},
+ * {@link #setHiddenFlag(boolean) hidden},
+ * {@link #setReadOnlyFlag(boolean) read-only} and
+ * {@link #setSystemFlag(boolean) system} flags specifed for the FAT file
+ * system.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @since 0.6
+ */
+public final class FatLfnDirectoryEntry
+ extends AbstractFsObject
+ implements FsDirectoryEntry {
+
+ final FatDirectoryEntry realEntry;
+
+ private FatLfnDirectory parent;
+ private String fileName;
+
+ FatLfnDirectoryEntry(String name, ShortName sn,
+ FatLfnDirectory parent, boolean directory) {
+
+ super(false);
+
+ this.parent = parent;
+ this.fileName = name;
+
+ final long now = System.currentTimeMillis();
+ this.realEntry = FatDirectoryEntry.create(directory);
+ this.realEntry.setShortName(sn);
+ this.realEntry.setCreated(now);
+ this.realEntry.setLastAccessed(now);
+ }
+
+ FatLfnDirectoryEntry(FatLfnDirectory parent,
+ FatDirectoryEntry realEntry, String fileName) {
+
+ super(parent.isReadOnly());
+
+ this.parent = parent;
+ this.realEntry = realEntry;
+ this.fileName = fileName;
+ }
+
+ static FatLfnDirectoryEntry extract(
+ FatLfnDirectory dir, int offset, int len) {
+
+ final FatDirectoryEntry realEntry = dir.dir.getEntry(offset + len - 1);
+ final String fileName;
+
+ if (len == 1) {
+ /* this is just an old plain 8.3 entry */
+ fileName = realEntry.getShortName().asSimpleString();
+ } else {
+ /* stored in reverse order */
+ final StringBuilder name = new StringBuilder(13 * (len - 1));
+
+ for (int i = len - 2; i >= 0; i--) {
+ FatDirectoryEntry entry = dir.dir.getEntry(i + offset);
+ name.append(entry.getLfnPart());
+ }
+
+ fileName = name.toString().trim();
+ }
+
+ return new FatLfnDirectoryEntry(dir, realEntry, fileName);
+ }
+
+ /**
+ * Returns if this directory entry has the FAT "hidden" flag set.
+ *
+ * @return if this is a hidden directory entry
+ * @see #setHiddenFlag(boolean)
+ */
+ public boolean isHiddenFlag() {
+ return this.realEntry.isHiddenFlag();
+ }
+
+ /**
+ * Sets the "hidden" flag on this {@code FatLfnDirectoryEntry} to the
+ * specified value.
+ *
+ * @param hidden if this entry should have the hidden flag set
+ * @throws ReadOnlyException if this entry is read-only
+ * @see #isHiddenFlag()
+ */
+ public void setHiddenFlag(boolean hidden) throws ReadOnlyException {
+ checkWritable();
+
+ this.realEntry.setHiddenFlag(hidden);
+ }
+
+ /**
+ * Returns if this directory entry has the FAT "system" flag set.
+ *
+ * @return if this is a "system" directory entry
+ * @see #setSystemFlag(boolean)
+ */
+ public boolean isSystemFlag() {
+ return this.realEntry.isSystemFlag();
+ }
+
+ /**
+ * Sets the "system" flag on this {@code FatLfnDirectoryEntry} to the
+ * specified value.
+ *
+ * @param systemEntry if this entry should have the system flag set
+ * @throws ReadOnlyException if this entry is read-only
+ * @see #isSystemFlag()
+ */
+ public void setSystemFlag(boolean systemEntry) throws ReadOnlyException {
+ checkWritable();
+
+ this.realEntry.setSystemFlag(systemEntry);
+ }
+
+ /**
+ * Returns if this directory entry has the FAT "read-only" flag set. This
+ * entry may still modified if {@link #isReadOnly()} returns {@code true}.
+ *
+ * @return if this entry has the read-only flag set
+ * @see #setReadOnlyFlag(boolean)
+ */
+ public boolean isReadOnlyFlag() {
+ return this.realEntry.isReadonlyFlag();
+ }
+
+ /**
+ * Sets the "read only" flag on this {@code FatLfnDirectoryEntry} to the
+ * specified value. This method only modifies the read-only flag as
+ * specified by the FAT file system, which is essentially ignored by the
+ * fat32-lib. The true indicator if it is possible to alter this
+ *
+ * @param readOnly if this entry should be flagged as read only
+ * @throws ReadOnlyException if this entry is read-only as given by
+ * {@link #isReadOnly()} method
+ * @see #isReadOnlyFlag()
+ */
+ public void setReadOnlyFlag(boolean readOnly) throws ReadOnlyException {
+ checkWritable();
+
+ this.realEntry.setReadonlyFlag(readOnly);
+ }
+
+ /**
+ * Returns if this directory entry has the FAT "archive" flag set.
+ *
+ * @return if this entry has the archive flag set
+ */
+ public boolean isArchiveFlag() {
+ return this.realEntry.isArchiveFlag();
+ }
+
+ /**
+ * Sets the "archive" flag on this {@code FatLfnDirectoryEntry} to the
+ * specified value.
+ *
+ * @param archive if this entry should have the archive flag set
+ * @throws ReadOnlyException if this entry is
+ * {@link #isReadOnly() read-only}
+ */
+ public void setArchiveFlag(boolean archive) throws ReadOnlyException {
+ checkWritable();
+
+ this.realEntry.setArchiveFlag(archive);
+ }
+
+ private int totalEntrySize() {
+ int result = (fileName.length() / 13) + 1;
+
+ if ((fileName.length() % 13) != 0) {
+ result++;
+ }
+
+ return result;
+ }
+
+ FatDirectoryEntry[] compactForm() {
+ if (this.realEntry.getShortName().equals(ShortName.DOT) ||
+ this.realEntry.getShortName().equals(ShortName.DOT_DOT) ||
+ this.realEntry.hasShortNameOnly) {
+ /* the dot entries must not have a LFN */
+ return new FatDirectoryEntry[]{this.realEntry};
+ }
+
+ final int totalEntrySize = totalEntrySize();
+
+ final FatDirectoryEntry[] entries =
+ new FatDirectoryEntry[totalEntrySize];
+
+ final byte checkSum = this.realEntry.getShortName().checkSum();
+ int j = 0;
+
+ for (int i = totalEntrySize - 2; i > 0; i--) {
+ entries[i] = createPart(fileName.substring(j * 13, j * 13 + 13),
+ j + 1, checkSum, false);
+ j++;
+ }
+
+ entries[0] = createPart(fileName.substring(j * 13),
+ j + 1, checkSum, true);
+
+ entries[totalEntrySize - 1] = this.realEntry;
+
+ return entries;
+ }
+
+ @Override
+ public String getName() {
+ checkValid();
+
+ return fileName;
+ }
+
+ @Override
+ public void setName(String newName) throws IOException {
+ checkWritable();
+
+ if (!this.parent.isFreeName(newName)) {
+ throw new IOException(
+ "the name \"" + newName + "\" is already in use");
+ }
+
+ this.parent.unlinkEntry(this);
+ this.fileName = newName;
+ this.parent.linkEntry(this);
+ }
+
+ /**
+ * Moves this entry to a new directory under the specified name.
+ *
+ * @param target the direcrory where this entry should be moved to
+ * @param newName the new name under which this entry will be accessible
+ * in the target directory
+ * @throws IOException on error moving this entry
+ * @throws ReadOnlyException if this directory is read-only
+ */
+ public void moveTo(FatLfnDirectory target, String newName)
+ throws IOException, ReadOnlyException {
+
+ checkWritable();
+
+ if (!target.isFreeName(newName)) {
+ throw new IOException(
+ "the name \"" + newName + "\" is already in use");
+ }
+
+ this.parent.unlinkEntry(this);
+ this.parent = target;
+ this.fileName = newName;
+ this.parent.linkEntry(this);
+ }
+
+ @Override
+ public void setLastModified(long lastModified) {
+ checkWritable();
+ realEntry.setLastModified(lastModified);
+ }
+
+ @Override
+ public FatFile getFile() throws IOException {
+ return parent.getFile(realEntry);
+ }
+
+ @Override
+ public FatLfnDirectory getDirectory() throws IOException {
+ return parent.getDirectory(realEntry);
+ }
+
+ @Override
+ public String toString() {
+ return "LFN = " + fileName + " / SFN = " + realEntry.getShortName();
+ }
+
+ private static FatDirectoryEntry createPart(String subName,
+ int ordinal, byte checkSum, boolean isLast) {
+
+ final char[] unicodechar = new char[13];
+ subName.getChars(0, subName.length(), unicodechar, 0);
+
+ for (int i=subName.length(); i < 13; i++) {
+ if (i==subName.length()) {
+ unicodechar[i] = 0x0000;
+ } else {
+ unicodechar[i] = 0xffff;
+ }
+ }
+
+ final byte[] rawData = new byte[FatDirectoryEntry.SIZE];
+
+ if (isLast) {
+ LittleEndian.setInt8(rawData, 0, ordinal + (1 << 6));
+ } else {
+ LittleEndian.setInt8(rawData, 0, ordinal);
+ }
+
+ LittleEndian.setInt16(rawData, 1, unicodechar[0]);
+ LittleEndian.setInt16(rawData, 3, unicodechar[1]);
+ LittleEndian.setInt16(rawData, 5, unicodechar[2]);
+ LittleEndian.setInt16(rawData, 7, unicodechar[3]);
+ LittleEndian.setInt16(rawData, 9, unicodechar[4]);
+ LittleEndian.setInt8(rawData, 11, 0x0f); // this is the hidden
+ // attribute tag for
+ // lfn
+ LittleEndian.setInt8(rawData, 12, 0); // reserved
+ LittleEndian.setInt8(rawData, 13, checkSum); // checksum
+ LittleEndian.setInt16(rawData, 14, unicodechar[5]);
+ LittleEndian.setInt16(rawData, 16, unicodechar[6]);
+ LittleEndian.setInt16(rawData, 18, unicodechar[7]);
+ LittleEndian.setInt16(rawData, 20, unicodechar[8]);
+ LittleEndian.setInt16(rawData, 22, unicodechar[9]);
+ LittleEndian.setInt16(rawData, 24, unicodechar[10]);
+ LittleEndian.setInt16(rawData, 26, 0); // sector... unused
+ LittleEndian.setInt16(rawData, 28, unicodechar[11]);
+ LittleEndian.setInt16(rawData, 30, unicodechar[12]);
+
+ return new FatDirectoryEntry(rawData, false);
+ }
+
+ @Override
+ public long getLastModified() throws IOException {
+ return realEntry.getLastModified();
+ }
+
+ @Override
+ public long getCreated() throws IOException {
+ return realEntry.getCreated();
+ }
+
+ @Override
+ public long getLastAccessed() throws IOException {
+ return realEntry.getLastAccessed();
+ }
+
+ @Override
+ public boolean isFile() {
+ return realEntry.isFile();
+ }
+
+ @Override
+ public boolean isDirectory() {
+ return realEntry.isDirectory();
+ }
+
+ @Override
+ public boolean isDirty() {
+ return realEntry.isDirty();
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatType.java b/src/main/java/de/waldheinz/fs/fat/FatType.java
new file mode 100644
index 0000000..1978264
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatType.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+/**
+ * Enumerates the different entry sizes of 12, 16 and 32 bits for the different
+ * FAT flavours.
+ *
+ * @author Ewout Prangsma <epr at jnode.org>
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public enum FatType {
+
+ /**
+ * Represents a 12-bit file allocation table.
+ */
+ FAT12((1 << 12) - 16, 0xFFFL, 1.5f, "FAT12 ") { //NOI18N
+
+ @Override
+ long readEntry(byte[] data, int index) {
+ final int idx = (int) (index * 1.5);
+ final int b1 = data[idx] & 0xFF;
+ final int b2 = data[idx + 1] & 0xFF;
+ final int v = (b2 << 8) | b1;
+
+ if ((index % 2) == 0) {
+ return v & 0xFFF;
+ } else {
+ return v >> 4;
+ }
+ }
+
+ @Override
+ void writeEntry(byte[] data, int index, long entry) {
+ final int idx = (int) (index * 1.5);
+
+ if ((index % 2) == 0) {
+ data[idx] = (byte) (entry & 0xFF);
+ data[idx + 1] = (byte) ((entry >> 8) & 0x0F);
+ } else {
+ data[idx] |= (byte) ((entry & 0x0F) << 4);
+ data[idx + 1] = (byte) ((entry >> 4) & 0xFF);
+ }
+ }
+ },
+
+ /**
+ * Represents a 16-bit file allocation table.
+ */
+ FAT16((1 << 16) - 16, 0xFFFFL, 2.0f, "FAT16 ") { //NOI18N
+
+ @Override
+ long readEntry(byte[] data, int index) {
+ final int idx = index << 1;
+ final int b1 = data[idx] & 0xFF;
+ final int b2 = data[idx + 1] & 0xFF;
+ return (b2 << 8) | b1;
+ }
+
+ @Override
+ void writeEntry(byte[] data, int index, long entry) {
+ final int idx = index << 1;
+ data[idx] = (byte) (entry & 0xFF);
+ data[idx + 1] = (byte) ((entry >> 8) & 0xFF);
+ }
+ },
+
+ /**
+ * Represents a 32-bit file allocation table.
+ */
+ FAT32((1 << 28) - 16, 0xFFFFFFFFL, 4.0f, "FAT32 ") { //NOI18N
+
+ @Override
+ long readEntry(byte[] data, int index) {
+ final int idx = index * 4;
+ final long l1 = data[idx] & 0xFF;
+ final long l2 = data[idx + 1] & 0xFF;
+ final long l3 = data[idx + 2] & 0xFF;
+ final long l4 = data[idx + 3] & 0xFF;
+ return (l4 << 24) | (l3 << 16) | (l2 << 8) | l1;
+ }
+
+ @Override
+ void writeEntry(byte[] data, int index, long entry) {
+ final int idx = index << 2;
+ data[idx] = (byte) (entry & 0xFF);
+ data[idx + 1] = (byte) ((entry >> 8) & 0xFF);
+ data[idx + 2] = (byte) ((entry >> 16) & 0xFF);
+ data[idx + 3] = (byte) ((entry >> 24) & 0xFF);
+ }
+ };
+
+ private final long minReservedEntry;
+ private final long maxReservedEntry;
+ private final long eofCluster;
+ private final long eofMarker;
+ private final long bitMask;
+ private final int maxClusters;
+ private final String label;
+ private final float entrySize;
+
+ private FatType(int maxClusters,
+ long bitMask, float entrySize, String label) {
+
+ this.minReservedEntry = (0xFFFFFF0L & bitMask);
+ this.maxReservedEntry = (0xFFFFFF6L & bitMask);
+ this.eofCluster = (0xFFFFFF8L & bitMask);
+ this.eofMarker = (0xFFFFFFFL & bitMask);
+ this.entrySize = entrySize;
+ this.label = label;
+ this.maxClusters = maxClusters;
+ this.bitMask = bitMask;
+ }
+
+ abstract long readEntry(byte[] data, int index);
+
+ abstract void writeEntry(byte[] data, int index, long entry);
+
+ /**
+ * Returns the maximum number of clusters this file system can address.
+ *
+ * @return the maximum cluster count supported
+ */
+ long maxClusters() {
+ return this.maxClusters;
+ }
+
+ /**
+ * Returns the human-readable FAT name string as written to the
+ * {@link com.meetwise.fs.BootSector}.
+ *
+ * @return the boot sector label for this FAT type
+ */
+ String getLabel() {
+ return this.label;
+ }
+
+ boolean isReservedCluster(long entry) {
+ return ((entry >= minReservedEntry) && (entry <= maxReservedEntry));
+ }
+
+ boolean isEofCluster(long entry) {
+ return (entry >= eofCluster);
+ }
+
+ long getEofMarker() {
+ return eofMarker;
+ }
+
+ float getEntrySize() {
+ return entrySize;
+ }
+
+ long getBitMask() {
+ return bitMask;
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FatUtils.java b/src/main/java/de/waldheinz/fs/fat/FatUtils.java
new file mode 100644
index 0000000..b653f7c
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FatUtils.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.io.IOException;
+
+/**
+ * <description>
+ *
+ * @author Ewout Prangsma < epr at jnode.org>
+ * @author Fabien DUMINY
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public class FatUtils {
+
+ /**
+ * Gets the offset (in bytes) of the fat with the given index
+ *
+ * @param bs
+ * @param fatNr (0..)
+ * @return long
+ * @throws IOException
+ */
+ public static long getFatOffset(BootSector bs, int fatNr) {
+ long sectSize = bs.getBytesPerSector();
+ long sectsPerFat = bs.getSectorsPerFat();
+ long resSects = bs.getNrReservedSectors();
+
+ long offset = resSects * sectSize;
+ long fatSize = sectsPerFat * sectSize;
+
+ offset += fatNr * fatSize;
+
+ return offset;
+ }
+
+ /**
+ * Gets the offset (in bytes) of the root directory with the given index
+ *
+ * @param bs
+ * @return long
+ * @throws IOException
+ */
+ public static long getRootDirOffset(BootSector bs) {
+ long sectSize = bs.getBytesPerSector();
+ long sectsPerFat = bs.getSectorsPerFat();
+ int fats = bs.getNrFats();
+
+ long offset = getFatOffset(bs, 0);
+
+ offset += fats * sectsPerFat * sectSize;
+
+ return offset;
+ }
+
+ /**
+ * Gets the offset of the data (file) area
+ *
+ * @param bs
+ * @return long
+ * @throws IOException
+ */
+ public static long getFilesOffset(BootSector bs) {
+ long offset = getRootDirOffset(bs);
+
+ offset += bs.getRootDirEntryCount() * 32;
+
+ return offset;
+ }
+
+ private FatUtils() { /* no instances */ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/FsInfoSector.java b/src/main/java/de/waldheinz/fs/fat/FsInfoSector.java
new file mode 100644
index 0000000..0399a9f
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/FsInfoSector.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+
+/**
+ * The FAT32 File System Information Sector.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ * @see http://en.wikipedia.org/wiki/File_Allocation_Table#FS_Information_Sector
+ */
+final class FsInfoSector extends Sector {
+
+ /**
+ * The offset to the free cluster count value in the FS info sector.
+ */
+ public static final int FREE_CLUSTERS_OFFSET = 0x1e8;
+
+ /**
+ * The offset to the "last allocated cluster" value in this sector.
+ */
+ public static final int LAST_ALLOCATED_OFFSET = 0x1ec;
+
+ /**
+ * The offset to the signature of this sector.
+ */
+ public static final int SIGNATURE_OFFSET = 0x1fe;
+
+ private FsInfoSector(BlockDevice device, long offset) {
+ super(device, offset, BootSector.SIZE);
+ }
+
+ /**
+ * Reads a {@code FsInfoSector} as specified by the given
+ * {@code Fat32BootSector}.
+ *
+ * @param bs the boot sector that specifies where the FS info sector is
+ * stored
+ * @return the FS info sector that was read
+ * @throws IOException on read error
+ * @see Fat32BootSector#getFsInfoSectorNr()
+ */
+ public static FsInfoSector read(Fat32BootSector bs) throws IOException {
+ final FsInfoSector result =
+ new FsInfoSector(bs.getDevice(), offset(bs));
+
+ result.read();
+ result.verify();
+ return result;
+ }
+
+ /**
+ * Creates an new {@code FsInfoSector} where the specified
+ * {@code Fat32BootSector} indicates it should be.
+ *
+ * @param bs the boot sector specifying the FS info sector storage
+ * @return the FS info sector instance that was created
+ * @throws IOException on write error
+ * @see Fat32BootSector#getFsInfoSectorNr()
+ */
+ public static FsInfoSector create(Fat32BootSector bs) throws IOException {
+ final int offset = offset(bs);
+
+ if (offset == 0) throw new IOException(
+ "creating a FS info sector at offset 0 is strange");
+
+ final FsInfoSector result =
+ new FsInfoSector(bs.getDevice(), offset(bs));
+
+ result.init();
+ result.write();
+ return result;
+ }
+
+ private static int offset(Fat32BootSector bs) {
+ return bs.getFsInfoSectorNr() * bs.getBytesPerSector();
+ }
+
+ /**
+ * Sets the number of free clusters on the file system stored at
+ * {@link #FREE_CLUSTERS_OFFSET}.
+ *
+ * @param value the new free cluster count
+ * @see Fat#getFreeClusterCount()
+ */
+ public void setFreeClusterCount(long value) {
+ if (getFreeClusterCount() == value) return;
+
+ set32(FREE_CLUSTERS_OFFSET, value);
+ }
+
+ /**
+ * Returns the number of free clusters on the file system as sepcified by
+ * the 32-bit value at {@link #FREE_CLUSTERS_OFFSET}.
+ *
+ * @return the number of free clusters
+ * @see Fat#getFreeClusterCount()
+ */
+ public long getFreeClusterCount() {
+ return get32(FREE_CLUSTERS_OFFSET);
+ }
+
+ /**
+ * Sets the last allocated cluster that was used in the {@link Fat}.
+ *
+ * @param value the FAT's last allocated cluster number
+ * @see Fat#getLastAllocatedCluster()
+ */
+ public void setLastAllocatedCluster(long value) {
+ if (getLastAllocatedCluster() == value) return;
+
+ super.set32(LAST_ALLOCATED_OFFSET, value);
+ }
+
+ /**
+ * Returns the last allocated cluster number of the {@link Fat} of the
+ * file system this FS info sector is part of.
+ *
+ * @return the last allocated cluster number
+ * @see Fat#getLastAllocatedCluster()
+ */
+ public long getLastAllocatedCluster() {
+ return super.get32(LAST_ALLOCATED_OFFSET);
+ }
+
+ private void init() {
+ buffer.position(0x00);
+ buffer.put((byte) 0x52);
+ buffer.put((byte) 0x52);
+ buffer.put((byte) 0x61);
+ buffer.put((byte) 0x41);
+
+ /* 480 reserved bytes */
+
+ buffer.position(0x1e4);
+ buffer.put((byte) 0x72);
+ buffer.put((byte) 0x72);
+ buffer.put((byte) 0x41);
+ buffer.put((byte) 0x61);
+
+ setFreeClusterCount(-1);
+ setLastAllocatedCluster(Fat.FIRST_CLUSTER);
+
+ buffer.position(SIGNATURE_OFFSET);
+ buffer.put((byte) 0x55);
+ buffer.put((byte) 0xaa);
+
+ markDirty();
+ }
+
+ private void verify() throws IOException {
+ if (!(get8(SIGNATURE_OFFSET) == 0x55) ||
+ !(get8(SIGNATURE_OFFSET + 1) == 0xaa)) {
+
+ throw new IOException("invalid FS info sector signature");
+ }
+ }
+
+ @Override
+ public String toString() {
+ return FsInfoSector.class.getSimpleName() +
+ " [freeClusterCount=" + getFreeClusterCount() + //NOI18N
+ ", lastAllocatedCluster=" + getLastAllocatedCluster() + //NOI18N
+ ", offset=" + getOffset() + //NOI18N
+ ", dirty=" + isDirty() + //NOI18N
+ "]"; //NOI18N
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/LittleEndian.java b/src/main/java/de/waldheinz/fs/fat/LittleEndian.java
new file mode 100644
index 0000000..a89f7ae
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/LittleEndian.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2003-2009 JNode.org
+ * 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+
+/**
+ * Little endian (LSB first) conversion methods.
+ *
+ * @author Ewout Prangsma <epr at users.sourceforge.net>
+ */
+final class LittleEndian {
+
+ private LittleEndian() { /* no instances */ }
+
+ /**
+ * Gets an 8-bit unsigned integer from the given byte array at
+ * the given offset.
+ *
+ * @param src the byte offset where to read the value from
+ * @param offset the byte array to extract the value from
+ * @return the integer that was read
+ */
+ public static int getUInt8(byte[] src, int offset) {
+ return src[offset] & 0xFF;
+ }
+
+ /**
+ * Gets a 16-bit unsigned integer from the given byte array at the given offset.
+ *
+ * @param src
+ * @param offset
+ */
+ public static int getUInt16(byte[] src, int offset) {
+ final int v0 = src[offset + 0] & 0xFF;
+ final int v1 = src[offset + 1] & 0xFF;
+ return ((v1 << 8) | v0);
+ }
+
+ /**
+ * Gets a 32-bit unsigned integer from the given byte array at the given offset.
+ *
+ * @param src
+ * @param offset
+ */
+ public static long getUInt32(byte[] src, int offset) {
+ final long v0 = src[offset + 0] & 0xFF;
+ final long v1 = src[offset + 1] & 0xFF;
+ final long v2 = src[offset + 2] & 0xFF;
+ final long v3 = src[offset + 3] & 0xFF;
+ return ((v3 << 24) | (v2 << 16) | (v1 << 8) | v0);
+ }
+
+ /**
+ * Sets an 8-bit integer in the given byte array at the given offset.
+ */
+ public static void setInt8(byte[] dst, int offset, int value) {
+ dst[offset] = (byte) value;
+ }
+
+ /**
+ * Sets a 16-bit integer in the given byte array at the given offset.
+ */
+ public static void setInt16(byte[] dst, int offset, int value) {
+ dst[offset + 0] = (byte) (value & 0xFF);
+ dst[offset + 1] = (byte) ((value >>> 8) & 0xFF);
+ }
+
+ /**
+ * Sets a 32-bit integer in the given byte array at the given offset.
+ */
+ public static void setInt32(byte[] dst, int offset, long value)
+ throws IllegalArgumentException {
+
+ if (value > Integer.MAX_VALUE) {
+ throw new IllegalArgumentException(
+ value + " can not be represented in a 32bit dword");
+ }
+
+ dst[offset + 0] = (byte) (value & 0xFF);
+ dst[offset + 1] = (byte) ((value >>> 8) & 0xFF);
+ dst[offset + 2] = (byte) ((value >>> 16) & 0xFF);
+ dst[offset + 3] = (byte) ((value >>> 24) & 0xFF);
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/Sector.java b/src/main/java/de/waldheinz/fs/fat/Sector.java
new file mode 100644
index 0000000..670f149
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/Sector.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+class Sector {
+ private final BlockDevice device;
+ private final long offset;
+
+ /**
+ * The buffer holding the contents of this {@code Sector}.
+ */
+ protected final ByteBuffer buffer;
+
+ private boolean dirty;
+
+ protected Sector(BlockDevice device, long offset, int size) {
+ this.offset = offset;
+ this.device = device;
+ this.buffer = ByteBuffer.allocate(size);
+ this.buffer.order(ByteOrder.LITTLE_ENDIAN);
+ this.dirty = true;
+ }
+
+ /**
+ * Reads the contents of this {@code Sector} from the device into the
+ * internal buffer and resets the "dirty" state.
+ *
+ * @throws IOException on read error
+ * @see #isDirty()
+ */
+ protected void read() throws IOException {
+ buffer.rewind();
+ buffer.limit(buffer.capacity());
+ device.read(offset, buffer);
+ this.dirty = false;
+ }
+
+ public final boolean isDirty() {
+ return this.dirty;
+ }
+
+ protected final void markDirty() {
+ this.dirty = true;
+ }
+
+ /**
+ * Returns the {@code BlockDevice} where this {@code Sector} is stored.
+ *
+ * @return this {@code Sector}'s device
+ */
+ public BlockDevice getDevice() {
+ return this.device;
+ }
+
+ public final void write() throws IOException {
+ if (!isDirty()) return;
+
+ buffer.position(0);
+ buffer.limit(buffer.capacity());
+ device.write(offset, buffer);
+ this.dirty = false;
+ }
+
+ protected int get16(int offset) {
+ return buffer.getShort(offset) & 0xffff;
+ }
+
+ protected long get32(int offset) {
+ return buffer.getInt(offset) & 0xffffffff;
+ }
+
+ protected int get8(int offset) {
+ return buffer.get(offset) & 0xff;
+ }
+
+ protected void set16(int offset, int value) {
+ buffer.putShort(offset, (short) (value & 0xffff));
+ dirty = true;
+ }
+
+ protected void set32(int offset, long value) {
+ buffer.putInt(offset, (int) (value & 0xffffffff));
+ dirty = true;
+ }
+
+ protected void set8(int offset, int value) {
+ if ((value & 0xff) != value) {
+ throw new IllegalArgumentException(
+ value + " too big to be stored in a single octet");
+ }
+
+ buffer.put(offset, (byte) (value & 0xff));
+ dirty = true;
+ }
+
+ /**
+ * Returns the device offset to this {@code Sector}.
+ *
+ * @return the {@code Sector}'s device offset
+ */
+ protected long getOffset() {
+ return this.offset;
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/ShortName.java b/src/main/java/de/waldheinz/fs/fat/ShortName.java
new file mode 100644
index 0000000..0fb382a
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/ShortName.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+/**
+ * Represents a "short" (8.3) file name as used by DOS.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+final class ShortName {
+
+ /**
+ * These are taken from the FAT specification.
+ */
+ private final static byte[] ILLEGAL_CHARS = {
+ 0x22, 0x2A, 0x2B, 0x2C, 0x2E, 0x2F, 0x3A, 0x3B,
+ 0x3C, 0x3D, 0x3E, 0x3F, 0x5B, 0x5C, 0x5D, 0x7C
+ };
+
+ /**
+ * The name of the "current directory" (".") entry of a FAT directory.
+ */
+ public final static ShortName DOT = new ShortName(".", ""); // NOI18N
+
+ /**
+ * The name of the "parent directory" ("..") entry of a FAT directory.
+ */
+ public final static ShortName DOT_DOT = new ShortName("..", ""); // NOI18N
+
+ private final char[] name;
+ private boolean mShortNameOnly;
+
+ private ShortName(String nameExt) {
+ if (nameExt.length() > 12)
+ throw new IllegalArgumentException("name too long");
+
+ final int i = nameExt.indexOf('.');
+ final String nameString, extString;
+
+ if (i < 0) {
+ nameString = nameExt.toUpperCase();
+ extString = "";
+ } else {
+ nameString = nameExt.substring(0, i).toUpperCase();
+ extString = nameExt.substring(i + 1).toUpperCase();
+ }
+
+ this.name = toCharArray(nameString, extString);
+ checkValidChars(this.name);
+ }
+
+ ShortName(String name, String ext) {
+ this.name = toCharArray(name, ext);
+ }
+
+ ShortName(char[] name) {
+ this.name = name;
+ }
+
+ public ShortName(char[] nameArr, char[] extArr) {
+ char[] result = new char[11];
+ System.arraycopy(nameArr, 0, result, 0, nameArr.length);
+ System.arraycopy(extArr, 0, result, 8, extArr.length);
+ this.name = result;
+ }
+
+ private static char[] toCharArray(String name, String ext) {
+ checkValidName(name);
+ checkValidExt(ext);
+
+ final char[] result = new char[11];
+ Arrays.fill(result, ' ');
+ System.arraycopy(name.toCharArray(), 0, result, 0, name.length());
+ System.arraycopy(ext.toCharArray(), 0, result, 8, ext.length());
+
+ return result;
+ }
+
+ /**
+ * Calculates the checksum that is used to test a long file name for it's
+ * validity.
+ *
+ * @return the {@code ShortName}'s checksum
+ */
+ public byte checkSum() {
+ final byte[] dest = new byte[11];
+ for (int i = 0; i < 11; i++)
+ dest[i] = (byte) name[i];
+
+ int sum = dest[0];
+ for (int i = 1; i < 11; i++) {
+ sum = dest[i] + (((sum & 1) << 7) + ((sum & 0xfe) >> 1));
+ }
+
+ return (byte) (sum & 0xff);
+ }
+
+ /**
+ * Parses the specified string into a {@code ShortName}.
+ *
+ * @param name the name+extension of the {@code ShortName} to get
+ * @return the {@code ShortName} representing the specified name
+ * @throws IllegalArgumentException if the specified name can not be parsed
+ * into a {@code ShortName}
+ * @see #canConvert(java.lang.String)
+ */
+ public static ShortName get(String name) throws IllegalArgumentException {
+ if (name.equals("."))
+ return DOT;
+ else if (name.equals(".."))
+ return DOT_DOT;
+ else
+ return new ShortName(name);
+ }
+
+ /**
+ * Tests if the specified string can be converted to a {@code ShortName}.
+ *
+ * @param nameExt the string to test
+ * @return if the string can be converted
+ * @see #get(java.lang.String)
+ */
+ public static boolean canConvert(String nameExt) {
+ /* TODO: do this without exceptions */
+ try {
+ ShortName.get(nameExt);
+ return true;
+ } catch (IllegalArgumentException ex) {
+ return false;
+ }
+ }
+
+ public static ShortName parse(byte[] data) {
+ final char[] nameArr = new char[8];
+
+ for (int i = 0; i < nameArr.length; i++) {
+ nameArr[i] = (char) LittleEndian.getUInt8(data, i);
+ }
+
+ final char[] extArr = new char[3];
+ for (int i = 0; i < extArr.length; i++) {
+ extArr[i] = (char) LittleEndian.getUInt8(data, 0x08 + i);
+ }
+
+ return new ShortName(nameArr, extArr);
+ }
+
+ public void write(byte[] dest) {
+ for (int i = 0; i < 11; i++) {
+ dest[i] = (byte) name[i];
+ }
+ }
+
+ public String asSimpleString() {
+ return new String(this.name).trim();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < this.name.length; i++) {
+ sb.append(Integer.toHexString(name[i]));
+ sb.append(' ');
+ }
+ return getClass().getSimpleName() +
+ " [" +
+ asSimpleString() + " -- " +
+ sb.toString() + "]"; // NOI18N
+ }
+
+ private static void checkValidName(String name) {
+ checkString(name, "name", 1, 8);
+ }
+
+ private static void checkValidExt(String ext) {
+ checkString(ext, "extension", 0, 3);
+ }
+
+ private static void checkString(String str, String strType,
+ int minLength, int maxLength) {
+
+ if (str == null)
+ throw new IllegalArgumentException(strType +
+ " is null");
+ if (str.length() < minLength)
+ throw new IllegalArgumentException(strType +
+ " must have at least " + minLength +
+ " characters: " + str);
+ if (str.length() > maxLength)
+ throw new IllegalArgumentException(strType +
+ " has more than " + maxLength +
+ " characters: " + str);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (!(obj instanceof ShortName)) {
+ return false;
+ }
+
+ final ShortName other = (ShortName) obj;
+ return Arrays.equals(name, other.name);
+ }
+
+ @Override
+ public int hashCode() {
+ return Arrays.hashCode(this.name);
+ }
+
+ public void setHasShortNameOnly(boolean hasShortNameOnly) {
+ mShortNameOnly = hasShortNameOnly;
+ }
+
+ public boolean hasShortNameOnly() {
+ return mShortNameOnly;
+ }
+
+ /**
+ * Checks if the specified char array consists only of "valid" byte values
+ * according to the FAT specification.
+ *
+ * @param chars the char array to test
+ * @throws IllegalArgumentException if invalid chars are contained
+ */
+ public static void checkValidChars(char[] chars)
+ throws IllegalArgumentException {
+
+ if (chars[0] == 0x20)
+ throw new IllegalArgumentException(
+ "0x20 can not be the first character");
+
+ for (int i = 0; i < chars.length; i++) {
+ if ((chars[i] & 0xff) != chars[i])
+ throw new IllegalArgumentException("multi-byte character at " + i);
+
+ final byte toTest = (byte) (chars[i] & 0xff);
+
+ if (toTest < 0x20 && toTest != 0x05)
+ throw new IllegalArgumentException("character < 0x20 at" + i);
+
+ for (int j = 0; j < ILLEGAL_CHARS.length; j++) {
+ if (toTest == ILLEGAL_CHARS[j])
+ throw new IllegalArgumentException("illegal character " +
+ ILLEGAL_CHARS[j] + " at " + i);
+ }
+ }
+ }
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/SuperFloppyFormatter.java b/src/main/java/de/waldheinz/fs/fat/SuperFloppyFormatter.java
new file mode 100644
index 0000000..5a64639
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/SuperFloppyFormatter.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.fat;
+
+import de.waldheinz.fs.BlockDevice;
+import java.io.IOException;
+import java.util.Random;
+
+/**
+ * <p>
+ * Allows to create FAT file systems on {@link BlockDevice}s which follow the
+ * "super floppy" standard. This means that the device will be formatted so
+ * that it does not contain a partition table. Instead, the entire device holds
+ * a single FAT file system.
+ * </p><p>
+ * This class follows the "builder" pattern, which means it's methods always
+ * returns the {@code SuperFloppyFormatter} instance they're called on. This
+ * allows to chain the method calls like this:
+ * <pre>
+ * BlockDevice dev = new RamDisk(16700000);
+ * FatFileSystem fs = SuperFloppyFormatter.get(dev).
+ * setFatType(FatType.FAT12).format();
+ * </pre>
+ *
+ * </p>
+ *
+ * @author Matthias Treydte <matthias.treydte at meetwise.com>
+ */
+public final class SuperFloppyFormatter {
+
+ /**
+ * The media descriptor used (hard disk).
+ */
+ public final static int MEDIUM_DESCRIPTOR_HD = 0xf8;
+
+ /**
+ * The default number of FATs.
+ */
+ public final static int DEFAULT_FAT_COUNT = 2;
+
+ /**
+ * The default number of sectors per track.
+ */
+ public final static int DEFAULT_SECTORS_PER_TRACK = 32;
+
+ /**
+ * The default number of heads.
+ *
+ * @since 0.6
+ */
+ public final static int DEFAULT_HEADS = 64;
+
+ /**
+ * The default number of heads.
+ *
+ * @deprecated the name of this constant was mistyped
+ * @see #DEFAULT_HEADS
+ */
+ @Deprecated
+ public final static int DEFULT_HEADS = DEFAULT_HEADS;
+
+ /**
+ * The default OEM name for file systems created by this class.
+ */
+ public final static String DEFAULT_OEM_NAME = "fat32lib"; //NOI18N
+
+ private static final int MAX_DIRECTORY = 512;
+
+ private final BlockDevice device;
+
+ private String label;
+ private String oemName;
+ private FatType fatType;
+ private int sectorsPerCluster;
+ private int reservedSectors;
+ private int fatCount;
+
+ /**
+ * Creates a new {@code SuperFloppyFormatter} for the specified
+ * {@code BlockDevice}.
+ *
+ * @param device
+ * @throws IOException on error accessing the specified {@code device}
+ */
+ private SuperFloppyFormatter(BlockDevice device) throws IOException {
+ this.device = device;
+ this.oemName = DEFAULT_OEM_NAME;
+ this.fatCount = DEFAULT_FAT_COUNT;
+ setFatType(fatTypeFromDevice());
+ }
+
+ /**
+ * Retruns a {@code SuperFloppyFormatter} instance suitable for formatting
+ * the specified device.
+ *
+ * @param dev the device that should be formatted
+ * @return the formatter for the device
+ * @throws IOException on error creating the formatter
+ */
+ public static SuperFloppyFormatter get(BlockDevice dev) throws IOException {
+ return new SuperFloppyFormatter(dev);
+ }
+
+ /**
+ * Returns the OEM name that will be written to the {@link BootSector}.
+ *
+ * @return the OEM name of the new file system
+ */
+ public String getOemName() {
+ return oemName;
+ }
+
+ /**
+ * Sets the OEM name of the boot sector.
+ *
+ * TODO: throw an exception early if name is invalid (too long, ...)
+ *
+ * @param oemName the new OEM name
+ * @return this {@code SuperFloppyFormatter}
+ * @see BootSector#setOemName(java.lang.String)
+ */
+ public SuperFloppyFormatter setOemName(String oemName) {
+ this.oemName = oemName;
+ return this;
+ }
+
+ /**
+ * Sets the volume label of the file system to create.
+ *
+ * TODO: throw an exception early if label is invalid (too long, ...)
+ *
+ * @param label the new file system label, may be {@code null}
+ * @return this {@code SuperFloppyFormatter}
+ * @see FatFileSystem#setVolumeLabel(java.lang.String)
+ */
+ public SuperFloppyFormatter setVolumeLabel(String label) {
+ this.label = label;
+ return this;
+ }
+
+ /**
+ * Returns the volume label that will be given to the new file system.
+ *
+ * @return the file system label, may be {@code null}
+ * @see FatFileSystem#getVolumeLabel()
+ */
+ public String getVolumeLabel() {
+ return label;
+ }
+
+ private void initBootSector(BootSector bs)
+ throws IOException {
+
+ bs.init();
+ bs.setFileSystemTypeLabel(fatType.getLabel());
+ bs.setNrReservedSectors(reservedSectors);
+ bs.setNrFats(fatCount);
+ bs.setSectorsPerCluster(sectorsPerCluster);
+ bs.setMediumDescriptor(MEDIUM_DESCRIPTOR_HD);
+ bs.setSectorsPerTrack(DEFAULT_SECTORS_PER_TRACK);
+ bs.setNrHeads(DEFAULT_HEADS);
+ bs.setOemName(oemName);
+ }
+
+ /**
+ * Initializes the boot sector and file system for the device. The file
+ * system created by this method will always be in read-write mode.
+ *
+ * @return the file system that was created
+ * @throws IOException on write error
+ */
+ public FatFileSystem format() throws IOException {
+ final int sectorSize = device.getSectorSize();
+ final int totalSectors = (int)(device.getSize() / sectorSize);
+
+ final FsInfoSector fsi;
+ final BootSector bs;
+ if (sectorsPerCluster == 0) throw new AssertionError();
+
+ if (fatType == FatType.FAT32) {
+ bs = new Fat32BootSector(device);
+ initBootSector(bs);
+
+ final Fat32BootSector f32bs = (Fat32BootSector) bs;
+
+ f32bs.setFsInfoSectorNr(1);
+
+ f32bs.setSectorsPerFat(sectorsPerFat(0, totalSectors));
+ final Random rnd = new Random(System.currentTimeMillis());
+ f32bs.setFileSystemId(rnd.nextInt());
+
+ f32bs.setVolumeLabel(label);
+
+ /* create FS info sector */
+ fsi = FsInfoSector.create(f32bs);
+ } else {
+ bs = new Fat16BootSector(device);
+ initBootSector(bs);
+
+ final Fat16BootSector f16bs = (Fat16BootSector) bs;
+
+ final int rootDirEntries = rootDirectorySize(
+ device.getSectorSize(), totalSectors);
+
+ f16bs.setRootDirEntryCount(rootDirEntries);
+ f16bs.setSectorsPerFat(sectorsPerFat(rootDirEntries, totalSectors));
+ if (label != null) f16bs.setVolumeLabel(label);
+ fsi = null;
+ }
+
+
+// bs.write();
+
+ if (fatType == FatType.FAT32) {
+ Fat32BootSector f32bs = (Fat32BootSector) bs;
+ /* possibly writes the boot sector copy */
+ f32bs.writeCopy(device);
+ }
+
+ final Fat fat = Fat.create(bs, 0);
+
+ final AbstractDirectory rootDirStore;
+ if (fatType == FatType.FAT32) {
+ rootDirStore = ClusterChainDirectory.createRoot(fat);
+ fsi.setFreeClusterCount(fat.getFreeClusterCount());
+ fsi.setLastAllocatedCluster(fat.getLastAllocatedCluster());
+ fsi.write();
+ } else {
+ rootDirStore = Fat16RootDirectory.create((Fat16BootSector) bs);
+ }
+
+ final FatLfnDirectory rootDir =
+ new FatLfnDirectory(rootDirStore, fat, false);
+
+ rootDir.flush();
+
+ for (int i = 0; i < bs.getNrFats(); i++) {
+ fat.writeCopy(FatUtils.getFatOffset(bs, i));
+ }
+
+ bs.write();
+
+ FatFileSystem fs = FatFileSystem.read(device, false);
+
+ if (label != null) {
+ fs.setVolumeLabel(label);
+ }
+
+ fs.flush();
+ return fs;
+ }
+
+ private int sectorsPerFat(int rootDirEntries, int totalSectors)
+ throws IOException {
+
+ final int bps = device.getSectorSize();
+ final int rootDirSectors =
+ ((rootDirEntries * 32) + (bps - 1)) / bps;
+ final long tmp1 =
+ totalSectors - (this.reservedSectors + rootDirSectors);
+ int tmp2 = (256 * this.sectorsPerCluster) + this.fatCount;
+
+ if (fatType == FatType.FAT32)
+ tmp2 /= 2;
+
+ final int result = (int) ((tmp1 + (tmp2 - 1)) / tmp2);
+
+ return result;
+ }
+
+ /**
+ * Determines a usable FAT type from the {@link #device} by looking at the
+ * {@link BlockDevice#getSize() device size} only.
+ *
+ * @return the suggested FAT type
+ * @throws IOException on error determining the device's size
+ */
+ private FatType fatTypeFromDevice() throws IOException {
+ return fatTypeFromSize(device.getSize());
+ }
+
+ /**
+ * Determines a usable FAT type from the {@link #device} by looking at the
+ * {@link BlockDevice#getSize() device size} only.
+ *
+ * @return the suggested FAT type
+ * @throws IOException on error determining the device's size
+ */
+ public static FatType fatTypeFromSize(long sizeInBytes) {
+ final long sizeInMb = sizeInBytes / (1024 * 1024);
+ if (sizeInMb < 4) return FatType.FAT12;
+ else if (sizeInMb < 512) return FatType.FAT16;
+ else return FatType.FAT32;
+ }
+
+ public static int clusterSizeFromSize(long sizeInBytes, int sectorSize){
+ switch(fatTypeFromSize(sizeInBytes)) {
+ case FAT12:
+ return sectorsPerCluster12(sizeInBytes, sectorSize);
+ case FAT16:
+ return sectorsPerCluster16FromSize(sizeInBytes, sectorSize);
+ case FAT32:
+ return sectorsPerCluster32FromSize(sizeInBytes, sectorSize);
+
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ /**
+ * Returns the exact type of FAT the will be created by this formatter.
+ *
+ * @return the FAT type
+ */
+ public FatType getFatType() {
+ return this.fatType;
+ }
+
+ /**
+ * Sets the type of FAT that will be created by this
+ * {@code SuperFloppyFormatter}.
+ *
+ * @param fatType the desired {@code FatType}
+ * @return this {@code SuperFloppyFormatter}
+ * @throws IOException on error setting the {@code fatType}
+ * @throws IllegalArgumentException if {@code fatType} does not support the
+ * size of the device
+ */
+ public SuperFloppyFormatter setFatType(FatType fatType)
+ throws IOException, IllegalArgumentException {
+
+ if (fatType == null) throw new NullPointerException();
+
+ switch (fatType) {
+ case FAT12: case FAT16:
+ this.reservedSectors = 1;
+ break;
+
+ case FAT32:
+ this.reservedSectors = 32;
+ }
+
+ this.sectorsPerCluster = defaultSectorsPerCluster(fatType);
+ this.fatType = fatType;
+
+ return this;
+ }
+
+ private static int rootDirectorySize(int bps, int nbTotalSectors) {
+ final int totalSize = bps * nbTotalSectors;
+ if (totalSize >= MAX_DIRECTORY * 5 * 32) {
+ return MAX_DIRECTORY;
+ } else {
+ return totalSize / (5 * 32);
+ }
+ }
+
+ static private int MAX_FAT32_CLUSTERS = 0x0FFFFFF5;
+
+ static private int sectorsPerCluster32FromSize(long size, int sectorSize) {
+ final long sectors = size / sectorSize;
+
+ if (sectors <= 66600) throw new IllegalArgumentException(
+ "disk too small for FAT32");
+
+ return
+ sectors > 67108864 ? 64 :
+ sectors > 33554432 ? 32 :
+ sectors > 16777216 ? 16 :
+ sectors > 532480 ? 8 : 1;
+ }
+
+ private int sectorsPerCluster32() throws IOException {
+ if (this.reservedSectors != 32) throw new IllegalStateException(
+ "number of reserved sectors must be 32");
+
+ if (this.fatCount != 2) throw new IllegalStateException(
+ "number of FATs must be 2");
+
+ final long sectors = device.getSize() / device.getSectorSize();
+
+ if (sectors <= 66600) throw new IllegalArgumentException(
+ "disk too small for FAT32");
+
+ return sectorsPerCluster32FromSize(device.getSize(), device.getSectorSize());
+ }
+
+ static private int MAX_FAT16_CLUSTERS = 65524;
+
+ static private int sectorsPerCluster16FromSize(long size, int sectorSize) {
+ final long sectors = size / sectorSize;
+
+ if (sectors <= 8400) throw new IllegalArgumentException(
+ "disk too small for FAT16");
+
+ if (sectors > 4194304) throw new IllegalArgumentException(
+ "disk too large for FAT16");
+
+ return
+ sectors > 2097152 ? 64 :
+ sectors > 1048576 ? 32 :
+ sectors > 524288 ? 16 :
+ sectors > 262144 ? 8 :
+ sectors > 32680 ? 4 : 2;
+ }
+
+ private int sectorsPerCluster16() throws IOException {
+ if (this.reservedSectors != 1) throw new IllegalStateException(
+ "number of reserved sectors must be 1");
+
+ if (this.fatCount != 2) throw new IllegalStateException(
+ "number of FATs must be 2");
+
+ long size = device.getSize();
+ int sectorSize = device.getSectorSize();
+ return sectorsPerCluster16FromSize(size, sectorSize);
+ }
+
+ private int defaultSectorsPerCluster(FatType fatType) throws IOException {
+ long size = device.getSize();
+ int sectorSize = device.getSectorSize();
+
+ switch (fatType) {
+ case FAT12:
+ return sectorsPerCluster12(size, sectorSize);
+
+ case FAT16:
+ return sectorsPerCluster16();
+
+ case FAT32:
+ return sectorsPerCluster32();
+
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ static private int sectorsPerCluster12(long size, int sectorSize) {
+ int result = 1;
+
+ final long sectors = size / sectorSize;
+
+ while (sectors / result > Fat16BootSector.MAX_FAT12_CLUSTERS) {
+ result *= 2;
+ if (result * size > 4096) throw new
+ IllegalArgumentException("disk too large for FAT12");
+ }
+
+ return result;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/fat/package-info.java b/src/main/java/de/waldheinz/fs/fat/package-info.java
new file mode 100644
index 0000000..4baf68f
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/fat/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * Contains the classes implementing the FAT(12/16/32) file system.
+ */
+package de.waldheinz.fs.fat;
diff --git a/src/main/java/de/waldheinz/fs/package-info.java b/src/main/java/de/waldheinz/fs/package-info.java
new file mode 100644
index 0000000..eb534b4
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * Contains the file-system independent classes and interfaces, as well as
+ * the {@link de.waldheinz.fs.FileSystemFactory} for creating
+ * {@link de.waldheinz.fs.FileSystem} instances.
+ */
+package de.waldheinz.fs;
diff --git a/src/main/java/de/waldheinz/fs/util/FileDisk.java b/src/main/java/de/waldheinz/fs/util/FileDisk.java
new file mode 100644
index 0000000..0f3f0bb
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/util/FileDisk.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.util;
+
+import de.waldheinz.fs.BlockDevice;
+import de.waldheinz.fs.ReadOnlyException;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+
+/**
+ * This is a {@code BlockDevice} that uses a {@link File} as it's backing store.
+ *
+ * @author Matthias Treydte <matthias.treydte at meetwise.com>
+ */
+public final class FileDisk implements BlockDevice {
+
+ /**
+ * The number of bytes per sector for all {@code FileDisk} instances.
+ */
+ public final static int BYTES_PER_SECTOR = 512;
+
+ private final RandomAccessFile raf;
+ private final FileChannel fc;
+ private final boolean readOnly;
+ private boolean closed;
+
+ /**
+ * Creates a new instance of {@code FileDisk} for the specified
+ * {@code File}.
+ *
+ * @param file the file that holds the disk contents
+ * @param readOnly if the file should be opened in read-only mode, which
+ * will result in a read-only {@code FileDisk} instance
+ * @throws FileNotFoundException if the specified file does not exist
+ * @see #isReadOnly()
+ */
+ public FileDisk(File file, boolean readOnly) throws FileNotFoundException {
+ if (!file.exists()) throw new FileNotFoundException();
+
+ this.readOnly = readOnly;
+ this.closed = false;
+ final String modeString = readOnly ? "r" : "rw"; //NOI18N
+ this.raf = new RandomAccessFile(file, modeString);
+ this.fc = raf.getChannel();
+ }
+
+ public FileDisk(RandomAccessFile raf, FileChannel fc, boolean readOnly) {
+ this.closed = false;
+ this.raf = raf;
+ this.fc = fc;
+ this.readOnly = readOnly;
+ }
+
+ private FileDisk(RandomAccessFile raf, boolean readOnly) {
+ this.closed = false;
+ this.raf = raf;
+ this.fc = raf.getChannel();
+ this.readOnly = readOnly;
+ }
+
+ /**
+ * Creates a new {@code FileDisk} of the specified size. The
+ * {@code FileDisk} returned by this method will be writable.
+ *
+ * @param file the file to hold the {@code FileDisk} contents
+ * @param size the size of the new {@code FileDisk}
+ * @return the created {@code FileDisk} instance
+ * @throws IOException on error creating the {@code FileDisk}
+ */
+ public static FileDisk create(File file, long size) throws IOException {
+ try {
+ final RandomAccessFile raf =
+ new RandomAccessFile(file, "rw"); //NOI18N
+ raf.setLength(size);
+
+ return new FileDisk(raf, false);
+ } catch (FileNotFoundException ex) {
+ throw new IOException(ex);
+ }
+ }
+
+ @Override
+ public long getSize() throws IOException {
+ checkClosed();
+
+ return raf.length();
+ }
+
+ @Override
+ public void read(long devOffset, ByteBuffer dest) throws IOException {
+ checkClosed();
+
+ int toRead = dest.remaining();
+ if ((devOffset + toRead) > getSize()) throw new IOException(
+ "reading past end of device");
+
+ while (toRead > 0) {
+ final int read = fc.read(dest, devOffset);
+ if (read < 0) throw new IOException();
+ toRead -= read;
+ devOffset += read;
+ }
+ }
+
+ @Override
+ public void write(long devOffset, ByteBuffer src) throws IOException {
+ checkClosed();
+
+ if (this.readOnly) throw new ReadOnlyException();
+
+ int toWrite = src.remaining();
+
+ if ((devOffset + toWrite) > getSize()) throw new IOException(
+ "writing past end of file");
+
+ while (toWrite > 0) {
+ final int written = fc.write(src, devOffset);
+ if (written < 0) throw new IOException();
+ toWrite -= written;
+ devOffset += written;
+ }
+ }
+
+ @Override
+ public void flush() throws IOException {
+ checkClosed();
+ }
+
+ @Override
+ public int getSectorSize() {
+ checkClosed();
+
+ return BYTES_PER_SECTOR;
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (isClosed()) return;
+
+ this.closed = true;
+ this.fc.close();
+ this.raf.close();
+ }
+
+ @Override
+ public boolean isClosed() {
+ return this.closed;
+ }
+
+ private void checkClosed() {
+ if (closed) throw new IllegalStateException("device already closed");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ checkClosed();
+
+ return this.readOnly;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/util/RamDisk.java b/src/main/java/de/waldheinz/fs/util/RamDisk.java
new file mode 100644
index 0000000..51a1be1
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/util/RamDisk.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package de.waldheinz.fs.util;
+
+import de.waldheinz.fs.*;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.zip.GZIPInputStream;
+
+/**
+ * A {@link BlockDevice} that lives entirely in heap memory. This is basically
+ * a RAM disk. A {@code RamDisk} is always writable.
+ *
+ * @author Matthias Treydte <waldheinz at gmail.com>
+ */
+public final class RamDisk implements BlockDevice {
+
+ /**
+ * The default sector size for {@code RamDisk}s.
+ */
+ public final static int DEFAULT_SECTOR_SIZE = 512;
+
+ private final int sectorSize;
+ private final ByteBuffer data;
+ private final int size;
+ private boolean closed;
+
+ /**
+ * Reads a GZIP compressed disk image from the specified input stream and
+ * returns a {@code RamDisk} holding the decompressed image.
+ *
+ * @param in the stream to read the disk image from
+ * @return the decompressed {@code RamDisk}
+ * @throws IOException on read or decompression error
+ */
+ public static RamDisk readGzipped(InputStream in) throws IOException {
+ final GZIPInputStream zis = new GZIPInputStream(in);
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+ final byte[] buffer = new byte[4096];
+
+ int read = zis.read(buffer);
+ int total = 0;
+
+ while (read >= 0) {
+ total += read;
+ bos.write(buffer, 0, read);
+ read = zis.read(buffer);
+ }
+
+ if (total < DEFAULT_SECTOR_SIZE) throw new IOException(
+ "read only " + total + " bytes"); //NOI18N
+
+ final ByteBuffer bb = ByteBuffer.wrap(bos.toByteArray(), 0, total);
+ return new RamDisk(bb, DEFAULT_SECTOR_SIZE);
+ }
+
+ private RamDisk(ByteBuffer buffer, int sectorSize) {
+ this.size = buffer.limit();
+ this.sectorSize = sectorSize;
+ this.data = buffer;
+ this.closed = false;
+ }
+
+ /**
+ * Creates a new instance of {@code RamDisk} of this specified
+ * size and using the {@link #DEFAULT_SECTOR_SIZE}.
+ *
+ * @param size the size of the new block device
+ */
+ public RamDisk(int size) {
+ this(size, DEFAULT_SECTOR_SIZE);
+ }
+
+ /**
+ * Creates a new instance of {@code RamDisk} of this specified
+ * size and sector size
+ *
+ * @param size the size of the new block device
+ * @param sectorSize the sector size of the new block device
+ */
+ public RamDisk(int size, int sectorSize) {
+ if (sectorSize < 1) throw new IllegalArgumentException(
+ "invalid sector size"); //NOI18N
+
+ this.sectorSize = sectorSize;
+ this.size = size;
+ this.data = ByteBuffer.allocate(size);
+ }
+
+ @Override
+ public long getSize() {
+ checkClosed();
+ return this.size;
+ }
+
+ @Override
+ public void read(long devOffset, ByteBuffer dest) throws IOException {
+ checkClosed();
+
+ if (devOffset > getSize()){
+ final StringBuilder sb = new StringBuilder();
+ sb.append("read at ").append(devOffset);
+ sb.append(" is off size (").append(getSize()).append(")");
+
+ throw new IllegalArgumentException(sb.toString());
+ }
+
+ data.limit((int) (devOffset + dest.remaining()));
+ data.position((int) devOffset);
+
+ dest.put(data);
+ }
+
+ @Override
+ public void write(long devOffset, ByteBuffer src) throws IOException {
+ checkClosed();
+
+ if (devOffset + src.remaining() > getSize()) throw new
+ IllegalArgumentException(
+ "offset=" + devOffset +
+ ", length=" + src.remaining() +
+ ", size=" + getSize());
+
+ data.limit((int) (devOffset + src.remaining()));
+ data.position((int) devOffset);
+
+
+ data.put(src);
+ }
+
+ /**
+ * Returns a slice of the {@code ByteBuffer} that is used by this
+ * {@code RamDisk} as it's backing store. The returned buffer will be
+ * live (reflecting any changes made through the
+ * {@link #write(long, java.nio.ByteBuffer) method}, but read-only.
+ *
+ * @return a buffer holding the contents of this {@code RamDisk}
+ */
+ public ByteBuffer getBuffer() {
+ return this.data.asReadOnlyBuffer();
+ }
+
+ @Override
+ public void flush() throws IOException {
+ checkClosed();
+ }
+
+ @Override
+ public int getSectorSize() {
+ checkClosed();
+ return this.sectorSize;
+ }
+
+ @Override
+ public void close() throws IOException {
+ this.closed = true;
+ }
+
+ @Override
+ public boolean isClosed() {
+ return this.closed;
+ }
+
+ private void checkClosed() {
+ if (closed) throw new IllegalStateException("device already closed");
+ }
+
+ /**
+ * Returns always {@code false}, as a {@code RamDisk} is always writable.
+ *
+ * @return always {@code false}
+ */
+ @Override
+ public boolean isReadOnly() {
+ checkClosed();
+
+ return false;
+ }
+
+}
diff --git a/src/main/java/de/waldheinz/fs/util/package-info.java b/src/main/java/de/waldheinz/fs/util/package-info.java
new file mode 100644
index 0000000..afde34e
--- /dev/null
+++ b/src/main/java/de/waldheinz/fs/util/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2009,2010 Matthias Treydte <mt@waldheinz.de>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * Contains some utility classes that are useful independent of the file system
+ * type.
+ */
+package de.waldheinz.fs.util;
+
