Thread: [Jnode-svn-commits] SF.net SVN: jnode:[4781] trunk/fs/src/fs/org/jnode/fs/ntfs

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 4781
          http://jnode.svn.sourceforge.net/jnode/?rev=4781&view=rev
Author:   lsantha
Date:     2008-12-08 08:08:56 +0000 (Mon, 08 Dec 2008)

Log Message:
-----------
NTFS data in multiple attribute lists, by Daniel Noll

Modified Paths:
--------------
    trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttribute.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeNonRes.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeRes.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListBlock.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListEntry.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/FileRecord.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/IndexAllocationAttribute.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/IndexEntry.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/MasterFileTable.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSEntry.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSIndex.java
    trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSNonResidentAttribute.java

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttribute.java
===================================================================

--- trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttribute.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttribute.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -22,25 +22,22 @@
 package org.jnode.fs.ntfs;
 
 import java.io.IOException;
-import java.util.List;
+import java.util.Iterator;
 
 /**
  * Common interface for both resident and non-resident attribute list
  * attributes.
  *
- * @author Daniel Noll (da...@nu...)
+ * @author Daniel Noll (da...@no...)
  */
 interface AttributeListAttribute {
 
     /**
-     * Gets an entry from the attribute list.
+     * Gets an iterator over all the entries in the attribute list.
      *
-     * XXX: What if there are multiple?  In the case I've seen, there are multiple but only the first
-     *      one contains any data.
-     *
-     * @param attrTypeID the type of attribute to find.
-     * @return the attribute entry.
-     * @throws IOException if there is an error reading the attribute's non-resident data.
+     * @return an iterator of all attribute list entries.
+     * @throws IOException if there is an error reading the attribute's data.
      */
-    List<AttributeListEntry> getEntries(int attrTypeID) throws IOException;
+    Iterator<AttributeListEntry> getAllEntries() throws IOException;
+
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeNonRes.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeNonRes.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeNonRes.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -22,14 +22,14 @@
 package org.jnode.fs.ntfs;
 
 import java.io.IOException;
-import java.util.List;
+import java.util.Iterator;
 
 /**
  * $ATTRIBUTE_LIST attribute, non-resident version.
  *
  * XXX: Is there a sensible way we can merge this with the resident version?
  *
- * @author Daniel Noll (da...@nu...)
+ * @author Daniel Noll (da...@no...)
  */
 final class AttributeListAttributeNonRes extends NTFSNonResidentAttribute implements
         AttributeListAttribute {
@@ -43,16 +43,12 @@
     }
 
     /**
-     * Gets an entry from the attribute list.
+     * Gets an iterator over all the entries in the attribute list.
      *
-     * XXX: What if there are multiple?  In the case I've seen, there are multiple but only the first
-     *      one contains any data.
-     *
-     * @param attrTypeID the type of attribute to find.
-     * @return the attribute entry.
-     * @throws IOException if there is an error reading the attribute's non-resident data.
+     * @return an iterator of all attribute list entries.
+     * @throws IOException if there is an error reading the attribute's data.
      */
-    public List<AttributeListEntry> getEntries(int attrTypeID) throws IOException {
+    public Iterator<AttributeListEntry> getAllEntries() throws IOException {
         // Read the actual data from wherever it happens to be located.
         // TODO: Consider handling multiple data runs separately instead
         //       of "glueing" them all together like this.
@@ -60,7 +56,6 @@
         final byte[] data = new byte[nrClusters * getFileRecord().getVolume().getClusterSize()];
         readVCN(getStartVCN(), data, 0, nrClusters);
         AttributeListBlock listBlock = new AttributeListBlock(data, 0, getAttributeActualSize());
-        return listBlock.getEntries(attrTypeID);
+        return listBlock.getAllEntries();
     }
-
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeRes.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeRes.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListAttributeRes.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -22,14 +22,14 @@
 package org.jnode.fs.ntfs;
 
 import java.io.IOException;
-import java.util.List;
+import java.util.Iterator;
 
 /**
  * $ATTRIBUTE_LIST attribute, resident version.
  *
  * XXX: Is there a sensible way we can merge this with the non-resident version?
  *
- * @author Daniel Noll (da...@nu...)
+ * @author Daniel Noll (da...@no...)
  */
 final class AttributeListAttributeRes extends NTFSResidentAttribute implements
         AttributeListAttribute {
@@ -43,20 +43,16 @@
     }
 
     /**
-     * Gets an entry from the attribute list.
+     * Gets an iterator over all the entries in the attribute list.
      *
-     * XXX: What if there are multiple?  In the case I've seen, there are multiple but only the first
-     *      one contains any data.
-     *
-     * @param attrTypeID the type of attribute to find.
-     * @return the attribute entry.
-     * @throws IOException if there is an error reading the attribute's non-resident data.
+     * @return an iterator of all attribute list entries.
+     * @throws IOException if there is an error reading the attribute's data.
      */
-    public List<AttributeListEntry> getEntries(int attrTypeID) throws IOException {
+    public Iterator<AttributeListEntry> getAllEntries() throws IOException {
         final byte[] data = new byte[getAttributeLength()];
         getData(getAttributeOffset(), data, 0, data.length);
         AttributeListBlock listBlock = new AttributeListBlock(data, 0, getAttributeLength());
-        return listBlock.getEntries(attrTypeID);
+        return listBlock.getAllEntries();
     }
 
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListBlock.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListBlock.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListBlock.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -21,8 +21,8 @@
  
 package org.jnode.fs.ntfs;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
 
 /**
  * Data structure containing a list of {@link AttributeListEntry} entries.
@@ -46,32 +46,71 @@
     }
 
     /**
-     * Finds all entries from the attribute list with the given type ID.
+     * Gets an iterator over all the entries in the attribute list.
      *
-     * XXX: What if there are multiple?  In the case I've seen, there are
-     *      multiple but only the first one contains any data.
-     *
-     * @param attrTypeID the type of attribute to find.
-     * @return the attribute entry.
+     * @return an iterator of all attribute list entries.
      */
-    public List<AttributeListEntry> getEntries(int attrTypeID) {
-        final List<AttributeListEntry> entries = new ArrayList<AttributeListEntry>();
-        int offset = 0;
-        while (offset + 4 <= length) // Should be just (offset < length) but it seems we have some uneven lengths.
-        {
-            try {
-                int type = getUInt32AsInt(offset + 0x00);
-                if (type == attrTypeID) {
-                    entries.add(new AttributeListEntry(this, offset));
-                }
+    public Iterator<AttributeListEntry> getAllEntries() {
+        return new AttributeListEntryIterator();
+    }
 
-                int length = getUInt16(offset + 0x04);
-                offset += length;
-            } catch (ArrayIndexOutOfBoundsException e) {
-                log.error("...");
+    /**
+     * Iteration of attribute list entries.
+     */
+    private class AttributeListEntryIterator implements Iterator<AttributeListEntry> {
+
+        /**
+         * The next element to return.
+         */
+        private AttributeListEntry nextElement;
+
+        /**
+         * Current offset being looked at.
+         */
+        private int offset = 0;
+
+        /**
+         * Returns {@code true} if there are more elements in the iteration.
+         *
+         * @return {@code true} if there are more elements in the iteration.
+         */
+        public boolean hasNext() {
+            // Safety check in case hasNext is called twice without calling next.
+            if (nextElement != null) {
+                return true;
             }
+
+            // If the length is specified, use it to determine where the block ends.
+            if (offset + 4 > length) {
+                return false;
+            }
+            
+            int length = getUInt16(offset + 0x04);
+            nextElement = new AttributeListEntry(AttributeListBlock.this, offset);
+            offset += length;
+            return true;
         }
-        return entries;
+
+        /**
+         * Gets the next entry from the iteration.
+         *
+         * @return the next entry from the iteration.
+         */
+        public AttributeListEntry next() {
+            if (hasNext()) {
+                AttributeListEntry result = nextElement;
+                nextElement = null;
+                return result;
+            } else {
+                throw new NoSuchElementException("Iterator has no more entries");
+            }
+        }
+
+        /**
+         * @throws UnsupportedOperationException always.
+         */
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
     }
-
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListEntry.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListEntry.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/AttributeListEntry.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -56,8 +56,33 @@
     }
 
     /**
+     * Gets the length of the name.  Not so useful for callers, hence private.
+     * @return the name length.
+     */
+    private int getNameLength() {
+        return getUInt8(0x06);
+    }
+
+    /**
+     * Gets the offset of the name.  Not so useful for callers, hence private.
+     * @return the name offset (from the front of the entry.)
+     */
+    private int getNameOffset() {
+        return getUInt8(0x07);
+    }
+
+    /**
+     * Gets the starting VCN of the attribute, zero if the attribute is resident.
+     * @return the starting VCN.
+     */
+    public int getStartingVCN() {
+        return getUInt16(0x08);
+    }
+
+    /**
      * Gets the file reference number, which is the lowest 48 bits of the MFT
-     * reference.
+     * reference.  This may point to the same file record which contains the
+     * attribute list. 
      * 
      * @return the file reference number.
      */
@@ -75,10 +100,46 @@
         return getUInt48(0x16);
     }
 
-    // TODO:
-    // 0x06 1 Name length (N)
-    // 0x07 1 Offset to Name (a)
-    // 0x08 8 Starting VCN (b)
-    // 0x18 2 Attribute Id (c)
-    // 0x1A 2N Name in Unicode (if N >0)
+    /**
+     * Gets the ID of the attribute.  This ID is unique within all attributes.
+     * @return the attribute ID.
+     */
+    public int getAttributeID() {
+        return getUInt16(0x18);
+    }
+
+    /**
+     * Gets the name of the attribute.  Some attributes don't have names, and the names
+     * on attributes are supposedly unique within a given attribute type.
+     *
+     * @return the name of the attribute referenced by this entry.  Returns the empty string
+     *         if the attribute has no name.
+     */
+    public String getName() {
+        final int nameLength = getNameLength();
+        if (nameLength == 0) {
+            return "";
+        } else {
+            char[] name = new char[nameLength];
+            for (int i = 0, off = getNameOffset(); i < nameLength; i++, off += 2) {
+                name[i] = getChar16(off);
+            }
+            return new String(name);
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder(super.toString());
+        builder.append("[type=").append(getType());
+        builder.append(",name=").append(getName());
+        if (getStartingVCN() == 0) {
+            builder.append(",resident");
+        } else {
+            builder.append(",ref=").append(getFileReferenceNumber());
+            builder.append(",vcn=").append(getStartingVCN());
+        }
+        builder.append(",id=").append(getAttributeID()).append("]");
+        return builder.toString();
+    }
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/FileRecord.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/FileRecord.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/FileRecord.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -22,6 +22,8 @@
 package org.jnode.fs.ntfs;
 
 import java.io.IOException;
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 
 import org.jnode.util.NumberUtils;
@@ -34,28 +36,57 @@
  */
 class FileRecord extends NTFSRecord {
 
+    /**
+     * Sequence number of the file within the MFT.
+     */
+    private long referenceNumber;
+
+    /**
+     * Cached attribute list attribute.
+     */
+    private AttributeListAttribute attributeListAttribute;
+
+    /**
+     * Cached file name attribute.
+     */
     private FileNameAttribute fileNameAttribute;
 
     /**
      * Initialize this instance.
-     * 
-     * @param volume
-     * @param buffer
+     *
+     * @param volume reference to the NTFS volume.
+     * @param referenceNumber the reference number of the file within the MFT.
+     * @param buffer data buffer.
+     * @param offset offset into the buffer.
      */
-    public FileRecord(NTFSVolume volume, byte[] buffer, int offset) throws IOException {
+    public FileRecord(NTFSVolume volume, long referenceNumber, byte[] buffer, int offset) throws IOException {
         super(volume, buffer, offset);
+        this.referenceNumber = referenceNumber;
+
+        // Linux NTFS docs say there can only be one of these, so I'll believe them.
+        attributeListAttribute = (AttributeListAttribute)
+            findStoredAttributeByType(NTFSAttribute.Types.ATTRIBUTE_LIST);
+
         //  check for the magic number to see if we have a filerecord
         if (getMagic() != Magic.FILE) {
             throw new IOException("Invalid magic found: " + getMagic());
         }
+
+        // This additional sanity check is possible if the record also contains the MFT number.
+        // Helps catch bugs where a record is being read from the wrong offset.
+        final long storedReferenceNumber = getStoredReferenceNumber();
+        if (storedReferenceNumber >= 0 && referenceNumber != storedReferenceNumber) {
+            throw new IOException("Stored reference number " + getStoredReferenceNumber() +
+                                  " does not match reference number " + referenceNumber);
+        }
     }
 
     /**
      * Gets the allocated size of the FILE record in bytes.
      * 
-     * @return Returns the alocatedSize.
+     * @return Returns the allocated size.
      */
-    public long getAlocatedSize() {
+    public long getAllocatedSize() {
         return getUInt32(0x1C);
     }
 
@@ -69,12 +100,21 @@
     }
 
     /**
-     * Is this a directory.
+     * Is this record in use?
+     *
+     * @return {@code true} if the record is in use.
+     */
+    public boolean isInUse() {
+        return (getFlags() & 0x01) != 0;
+    }
+
+    /**
+     * Is this a directory?
      * 
-     * @return
+     * @return {@code true} if the record is a directory.
      */
     public boolean isDirectory() {
-        return ((this.getFlags() & 0x02) != 0);
+        return (getFlags() & 0x02) != 0;
     }
 
     /**
@@ -90,9 +130,9 @@
      * Gets the byte offset to the first attribute in this mft record from the
      * start of the mft record.
      * 
-     * @return Returns the firtAttributeOffset.
+     * @return the first attribute offset.
      */
-    public int getFirtAttributeOffset() {
+    public int getFirstAttributeOffset() {
         return getUInt16(0x14);
     }
 
@@ -131,6 +171,22 @@
     }
 
     /**
+     * Gets the stored reference number.  This can be compared against the reference number
+     * to confirm that the correct file record was returned, however it is not available
+     * on all versions of NTFS, and even on recent versions some MFT records lack it.
+     *
+     * @return the stored file reference number, or {@code -1} if it is not stored.
+     */
+    public long getStoredReferenceNumber() {
+        // Expected to be 0x2A pre-XP.
+        if (getUpdateSequenceOffset() >= 0x30) {
+            return getUInt32(0x2C);
+        } else {
+            return -1;
+        }
+    }
+
+    /**
      * Gets the name of this file.
      * 
      * @return
@@ -151,7 +207,7 @@
      */
     public FileNameAttribute getFileNameAttribute() {
         if (fileNameAttribute == null) {
-            fileNameAttribute = (FileNameAttribute) getAttribute(NTFSAttribute.Types.FILE_NAME);
+            fileNameAttribute = (FileNameAttribute) findAttributeByType(NTFSAttribute.Types.FILE_NAME);
         }
         return fileNameAttribute;
     }
@@ -159,87 +215,133 @@
     /**
      * Gets an attribute in this filerecord with a given id.
      *
-     * XXX: Returning an iterator of multiple might be better.
+     * @return an iteratover over attributes stored in this file record.
+     */
+    public AttributeIterator getAllStoredAttributes() {
+        return new StoredAttributeIterator();
+    }
+
+    /**
+     * Finds a single stored attribute by ID.
      *
-     * @param attrTypeID the type ID of the attribute we're looking for.
-     * @return the attribute.
+     * @param id the ID.
+     * @return the attribute found, or {@code null} if not found.
      */
-    public NTFSAttribute getAttribute(int attrTypeID) {
-        log.debug("getAttribute(0x" + NumberUtils.hex(attrTypeID, 4) + ")");
-        int offset = this.getFirtAttributeOffset();
-        while (true) {
-            final int type = getUInt32AsInt(offset + 0x00);
-            if (type == 0xFFFFFFFF) {
-                // The end of the attribute list
-                break;
-            } else if (type == attrTypeID) {
-                return NTFSAttribute.getAttribute(this, offset);
-            } else {
-                // Skip and go to the next
-                final int attrLength = getUInt32AsInt(offset + 0x04);
-                offset += attrLength;
+    private NTFSAttribute findStoredAttributeByID(int id) {
+        AttributeIterator iter = getAllStoredAttributes();
+        NTFSAttribute attr;
+        while ((attr = iter.next()) != null) {
+            if (attr.getAttributeID() == id) {
+                return attr;
             }
         }
+        return null;
+    }
 
-        if (attrTypeID != NTFSAttribute.Types.ATTRIBUTE_LIST) {
-            final AttributeListAttribute attributeList =
-                    (AttributeListAttribute) getAttribute(NTFSAttribute.Types.ATTRIBUTE_LIST);
-            if (attributeList != null) {
-                log.info("Has $ATTRIBUTE_LIST attribute");
+    /**
+     * Finds a single stored attribute by type.
+     *
+     * @param typeID the type ID
+     * @return the attribute found, or {@code null} if not found.
+     * @see NTFSAttribute.Types
+     */
+    private NTFSAttribute findStoredAttributeByType(int typeID) {
+        AttributeIterator iter = getAllStoredAttributes();
+        NTFSAttribute attr;
+        while ((attr = iter.next()) != null) {
+            if (attr.getAttributeType() == typeID) {
+                return attr;
+            }
+        }
+        return null;
+    }
 
-                try {
-                    final List<AttributeListEntry> entries = attributeList.getEntries(attrTypeID);
-                    if (!entries.isEmpty()) {
-                        log.debug("Found entries via $ATTRIBUTE_LIST: " + entries);
-                        MasterFileTable mft = getVolume().getMFT();
-                        NTFSAttribute attribute = null;
-                        for (AttributeListEntry entry : entries) {
-                            // XXX: This is a little crappy as we should already know the exact offset
-                            //      of this attribute.  This just makes the best of the API we already
-                            //      use everywhere else.
-                            NTFSAttribute attr =
-                                    mft.getRecord(entry.getFileReferenceNumber()).getAttribute(
-                                            attrTypeID);
+    /**
+     * Gets an iterator over all attributes in this file record, including any attributes
+     * which are stored in other file records referenced from an $ATTRIBUTE_LIST attribute.
+     *
+     * @return an iterator over all attributes.
+     */
+    private AttributeIterator getAllAttributes() {
+        if (attributeListAttribute == null) {
+            return getAllStoredAttributes();
+        } else {
+            return new AttributeListAttributeIterator();
+        }
+    }
 
-                            if (attribute == null) {
-                                // First attribute encountered.
-                                attribute = attr;
-                                if (!(attr instanceof NTFSNonResidentAttribute)) {
-                                    log
-                                            .info("Don't know how to glue together resident attributes, "
-                                                    + "returning the first one alone");
-                                    break;
-                                }
-                            } else {
-                                // Subsequent attribute.
-                                if (attr instanceof NTFSNonResidentAttribute) {
-                                    log.debug("Appending data runs onto parent attribute");
-                                    ((NTFSNonResidentAttribute) attribute)
-                                            .appendDataRuns(((NTFSNonResidentAttribute) attr)
-                                                    .getDataRuns());
-                                } else {
-                                    log.info("Don't know how to glue a resident attribute onto "
-                                            + "a non-resident one, skipping this attribute.");
-                                }
-                            }
-                        }
+    /**
+     * Gets the first attribute in this filerecord with a given type.
+     *
+     * @param attrTypeID the type ID of the attribute we're looking for.
+     * @return the attribute.
+     */
+    public NTFSAttribute findAttributeByType(int attrTypeID) {
+        log.debug("findAttributeByType(0x" + NumberUtils.hex(attrTypeID, 4) + ")");
 
-                        return attribute;
-                    }
-                } catch (IOException e) {
-                    log.error("IO error getting locating attribute list entry", e);
-                }
+        AttributeIterator iter = getAllAttributes();
+        NTFSAttribute attr;
+        while ((attr = iter.next()) != null) {
+            if (attr.getAttributeType() == attrTypeID) {
+                log.debug("findAttributeByType(0x" + NumberUtils.hex(attrTypeID, 4) + ") found");
+                return attr;
             }
         }
 
-        log.info("getAttribute(0x" + NumberUtils.hex(attrTypeID, 4) + ") not found");
+        log.debug("findAttributeByType(0x" + NumberUtils.hex(attrTypeID, 4) + ") not found");
         return null;
     }
 
+    /**
+     * Gets attributes in this filerecord with a given type and name.
+     *
+     * @param attrTypeID the type ID of the attribute we're looking for.
+     * @param name the name to look for.
+     * @return the attributes, will be empty if not found, never {@code null}.
+     */
+    public AttributeIterator findAttributesByTypeAndName(final int attrTypeID, final String name) {
+        log.debug("findAttributesByTypeAndName(0x" + NumberUtils.hex(attrTypeID, 4) +
+                  "," + name + ")");
+        return new FilteredAttributeIterator(getAllAttributes()) {
+            @Override
+            protected boolean matches(NTFSAttribute attr) {
+                if (attr.getAttributeType() == attrTypeID) {
+                    String attrName = attr.getAttributeName();
+                    if (name == null ? attrName == null : name.equals(attrName)) {
+                        log.debug("findAttributesByTypeAndName(0x" + NumberUtils.hex(attrTypeID, 4) +
+                                  "," + name + ") found");
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+    }
+
+    /**
+     * Reads data from the file.
+     *
+     * @param fileOffset the offset into the file.
+     * @param dest the destination byte array into which to copy the file data.
+     * @param off the offset into the destination byte array.
+     * @param len the number of bytes of data to read.
+     * @throws IOException if an error occurs reading from the filesystem.
+     */
     public void readData(long fileOffset, byte[] dest, int off, int len) throws IOException {
-        final NTFSAttribute data = this.getAttribute(NTFSAttribute.Types.DATA);
-        if (data.isResident()) {
-            final NTFSResidentAttribute resData = (NTFSResidentAttribute) data;
+        // Explicitly look for the attribute with no name, to avoid getting alternate streams.
+        // XXX: Add API for getting length and content from alternate streams.
+        final AttributeIterator dataAttrs = findAttributesByTypeAndName(NTFSAttribute.Types.DATA, null);
+        NTFSAttribute attr = dataAttrs.next();
+        if (attr == null) {
+            throw new IOException("Data attribute not found, file record = " + this);
+        }
+
+        if (attr.isResident()) {
+            if (dataAttrs.next() != null) {
+                throw new IOException("Resident attribute should be by itself, file record = " + this);
+            }
+
+            final NTFSResidentAttribute resData = (NTFSResidentAttribute) attr;
             final int attrLength = resData.getAttributeLength();
             if (attrLength < len) {
                 throw new IOException("File data(" + attrLength +
@@ -252,12 +354,167 @@
         // calculate start and end cluster
 
         final int clusterSize = getVolume().getClusterSize();
-        final long startCluster = (fileOffset / clusterSize);
-        final int nrClusters = (int) ((len + (fileOffset % clusterSize)) / clusterSize) + 1;
-        final NTFSNonResidentAttribute nresData = (NTFSNonResidentAttribute) data;
+        final long startCluster = fileOffset / clusterSize;
+        final long endCluster = (fileOffset + len - 1) / clusterSize;
+        final int nrClusters = (int) (endCluster - startCluster + 1);
+        final byte[] tmp = new byte[nrClusters * clusterSize];
 
-        final byte[] tmp = new byte[nrClusters * clusterSize];
-        nresData.readVCN(startCluster, tmp, 0, nrClusters);
+        long clusterWithinNresData = startCluster;
+        int readClusters = 0;
+        do {
+            if (attr.isResident()) {
+                throw new IOException("Resident attribute should be by itself, file record = " + this);
+            }
+
+            final NTFSNonResidentAttribute nresData = (NTFSNonResidentAttribute) attr;
+
+            readClusters += nresData.readVCN(clusterWithinNresData, tmp, 0, nrClusters);
+            if (readClusters == nrClusters) {
+                // Already done.
+                break;
+            }
+
+            // When there are multiple attributes, the data in each one claims to start at VCN 0.
+            // Clearly this is not the case, so we need to offset when we read.
+            clusterWithinNresData -= nresData.getNumberOfVCNs();
+            attr = dataAttrs.next();
+        } while (attr != null);
+
+        if (readClusters != nrClusters) {
+            throw new IOException("Requested " + nrClusters + " clusters but only read " + readClusters);
+        }
+
         System.arraycopy(tmp, (int) fileOffset % clusterSize, dest, off, len);
     }
+
+    public String toString() {
+        if (isInUse()) {
+            return super.toString() + "[fileName=" + getFileName() + "]";
+        } else {
+            return super.toString() + "[unused]";
+        }
+    }
+
+    /**
+     * Iterator over multiple attributes, where those attributes are stored in an
+     * attribute list instead of directly in the file record.
+     */
+    private class AttributeListAttributeIterator extends AttributeIterator {
+
+        /**
+         * Current iterator over attribute list entries.
+         */
+        private Iterator<AttributeListEntry> entryIterator;
+
+        /**
+         * Constructs the iterator.
+         */
+        private AttributeListAttributeIterator() {
+            try {
+                entryIterator = attributeListAttribute.getAllEntries();
+            } catch (IOException e) {
+                log.error("Error getting attributes from attribute list, file record " + FileRecord.this, e);
+                List<AttributeListEntry> emptyList = Collections.emptyList();
+                entryIterator = emptyList.iterator();
+            }
+        }
+
+        @Override
+        protected NTFSAttribute next() {
+            while (entryIterator.hasNext()) {
+                AttributeListEntry entry = entryIterator.next();
+                try {
+                    // If it's resident (i.e. in the current file record) then we don't need to
+                    // look it up, and doing so would risk infinite recursion.
+                    FileRecord holdingRecord;
+                    if (entry.getFileReferenceNumber() == referenceNumber) {
+                        holdingRecord = FileRecord.this;
+                    } else {
+                        holdingRecord = getVolume().getMFT().getRecord(entry.getFileReferenceNumber());
+                    }
+
+                    return holdingRecord.findStoredAttributeByID(entry.getAttributeID());
+                } catch (IOException e) {
+                    // XXX: I wish the iterator could just throw this error out.  Should we
+                    //      just create a different kind of iterator class instead?
+                    log.error("Error getting MFT or FileRecord for attribute in list, ref = 0x" +
+                              Long.toHexString(entry.getFileReferenceNumber()), e);
+                }
+            }
+
+            return null;
+        }
+    }
+
+    /**
+     * Iterator over stored attributes in this file record.
+     */
+    private class StoredAttributeIterator extends AttributeIterator {
+        /**
+         * The next attribute offset to look at.
+         */
+        private int nextOffset = getFirstAttributeOffset();
+
+        @Override
+        protected NTFSAttribute next() {
+            final int offset = nextOffset;
+            final int type = getUInt32AsInt(offset + 0x00);
+            if (type == 0xFFFFFFFF) {
+                // Normal end of list condition.
+                return null;
+            } else {
+                NTFSAttribute attribute = NTFSAttribute.getAttribute(FileRecord.this, offset);
+                int offsetToNextOffset = getUInt32AsInt(offset + 0x04);
+                if (offsetToNextOffset <= 0) {
+                    log.error("Non-positive offset, preventing infinite loop.  Data on disk may be corrupt.  " +
+                              "referenceNumber = " + referenceNumber);
+                    return null;
+                }
+
+                nextOffset += offsetToNextOffset;
+                return attribute;
+            }
+        }
+    }
+
+    /**
+     * An iterator for filtering another iterator.
+     */
+    private abstract class FilteredAttributeIterator extends AttributeIterator {
+        private AttributeIterator inner;
+        private FilteredAttributeIterator(AttributeIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        protected NTFSAttribute next() {
+            NTFSAttribute attr;
+            while ((attr = inner.next()) != null) {
+                if (matches(attr)) {
+                    return attr;
+                }
+            }
+            return null;
+        }
+
+        /**
+         * Implemented by subclasses to perform matching logic.
+         *
+         * @param attr the attribute.
+         * @return {@code true} if it matches, {@code false} otherwise.
+         */
+        protected abstract boolean matches(NTFSAttribute attr);
+    }
+
+    /**
+     * Holds code common to both types of attribute list.
+     */
+    private abstract class AttributeIterator {
+        /**
+         * Gets the next element from the iterator.
+         *
+         * @return the next element from the iterator.  Returns {@code null} at the end.
+         */
+        protected abstract NTFSAttribute next();
+    }
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/IndexAllocationAttribute.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/IndexAllocationAttribute.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/IndexAllocationAttribute.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -47,9 +47,26 @@
     public IndexBlock getIndexBlock(IndexRoot indexRoot, long vcn) throws IOException {
         log.debug("getIndexBlock(..," + vcn + ")");
         final FileRecord fileRecord = getFileRecord();
-        final int nrClusters = indexRoot.getClustersPerIndexBlock();
-        final byte[] data = new byte[nrClusters * fileRecord.getVolume().getClusterSize()];
-        readVCN(vcn, data, 0, nrClusters);
-        return new IndexBlock(fileRecord, data, 0);
+
+        // VCN passed in is relative to the size of index clusters, not filesystem clusters.
+        // Calculate the actual offset we need in terms of filesystem clusters,
+        // and how many actual clusters we will need to read.
+
+        final int indexBlockSize = indexRoot.getIndexBlockSize();
+        final int indexClusterSize = indexBlockSize / indexRoot.getClustersPerIndexBlock();
+        final int fsClusterSize = fileRecord.getVolume().getClusterSize();
+        final long fsVcn = vcn * indexClusterSize / fsClusterSize;
+        final int fsNrClusters = (indexBlockSize - 1) / fsClusterSize + 1;
+        final int offsetIntoVcn = (int) ((vcn * indexClusterSize) % fsClusterSize);
+
+        final byte[] data = new byte[fsNrClusters * fsClusterSize];
+        final int readClusters = readVCN(fsVcn, data, 0, fsNrClusters);
+        if (readClusters != fsNrClusters) {
+            // If we don't throw an error now, it just fails more mysteriously later!
+            throw new IOException("Number of clusters read was not the number requested (requested " +
+                                  fsNrClusters + ", read " + readClusters + ")");
+        }
+
+        return new IndexBlock(fileRecord, data, offsetIntoVcn);
     }
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/IndexEntry.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/IndexEntry.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/IndexEntry.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -55,7 +55,7 @@
     }
 
     public boolean hasSubNodes() {
-        return (getFlags() & 0x01) != 0;
+        return (getIndexFlags() & 0x01) != 0;
     }
 
     /**
@@ -70,12 +70,12 @@
      * Gets the flags of this index entry.
      * @return
      */
-    public int getFlags() {
+    public int getIndexFlags() {
         return getUInt8(0x0C);
     }
 
     public boolean isLastIndexEntryInSubnode() {
-        return (getFlags() & 0x02) != 0;
+        return (getIndexFlags() & 0x02) != 0;
     }
 
     /**
@@ -88,7 +88,7 @@
     }
 
     public boolean isDirectory() {
-        return (getUInt32(0x48) & 0x10000000L) != 0;
+        return (getFileFlags() & 0x10000000L) != 0;
     }
 
     public String getFileName() {
@@ -126,4 +126,12 @@
         }
         return name;
     }
+
+    @Override
+    public String toString() {
+        return super.toString() +
+               "[fileName=" + getFileName() +
+               ",indexFlags=" + getIndexFlags() +
+               ",fileFlags=" + getFileFlags() + "]";
+    }
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/MasterFileTable.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/MasterFileTable.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/MasterFileTable.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -123,7 +123,7 @@
      * @throws IOException
      */
     public MasterFileTable(NTFSVolume volume, byte[] buffer, int offset) throws IOException {
-        super(volume, buffer, offset);
+        super(volume, SystemFiles.MFT, buffer, offset);
     }
 
     /**
@@ -142,7 +142,7 @@
         // read the buffer
         final byte[] buffer = new byte[bytesPerFileRecord];
         readData(offset, buffer, 0, bytesPerFileRecord);
-        return new FileRecord(volume, buffer, 0);
+        return new FileRecord(volume, index, buffer, 0);
     }
 
     public FileRecord getIndexedFileRecord(IndexEntry indexEntry) throws IOException {

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSEntry.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSEntry.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSEntry.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -138,6 +138,7 @@
     public FSDirectory getDirectory() throws IOException {
         if (this.isDirectory()) {
             if (cachedFSObject == null) {
+                // XXX: Why can't this just use getFileRecord()?
                 cachedFSObject =
                         new NTFSDirectory(fs, getFileRecord().getVolume().getMFT()
                                 .getIndexedFileRecord(indexEntry));
@@ -194,4 +195,9 @@
     public boolean isDirty() throws IOException {
         return true;
     }
+
+    @Override
+    public String toString() {
+        return super.toString() + '(' + indexEntry + ')';
+    }
 }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSIndex.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSIndex.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSIndex.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -62,7 +62,7 @@
     public IndexRootAttribute getIndexRootAttribute() {
         if (indexRootAttribute == null) {
             indexRootAttribute = (IndexRootAttribute) 
-                    fileRecord.getAttribute(NTFSAttribute.Types.INDEX_ROOT);
+                    fileRecord.findAttributeByType(NTFSAttribute.Types.INDEX_ROOT);
             log.debug("getIndexRootAttribute: " + indexRootAttribute);
         }
         return indexRootAttribute;
@@ -76,7 +76,7 @@
     public IndexAllocationAttribute getIndexAllocationAttribute() {
         if (indexAllocationAttribute == null) {
             indexAllocationAttribute = (IndexAllocationAttribute) 
-                    fileRecord.getAttribute(NTFSAttribute.Types.INDEX_ALLOCATION);
+                    fileRecord.findAttributeByType(NTFSAttribute.Types.INDEX_ALLOCATION);
         }
         return indexAllocationAttribute;
     }

Modified: trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSNonResidentAttribute.java
===================================================================
--- trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSNonResidentAttribute.java	2008-12-08 07:14:48 UTC (rev 4780)
+++ trunk/fs/src/fs/org/jnode/fs/ntfs/NTFSNonResidentAttribute.java	2008-12-08 08:08:56 UTC (rev 4781)
@@ -91,7 +91,7 @@
      *
      * @return the size allocated to the attribute.
      */
-    public long getAttributeAlocatedSize() {
+    public long getAttributeAllocatedSize() {
         return getUInt32(0x28);
     }
 
@@ -125,11 +125,13 @@
         }
         // check the dataruns
         final int clusterSize = getFileRecord().getVolume().getClusterSize();
-        if (this.numberOfVCNs != this.getAttributeAlocatedSize() / clusterSize) {
-            log.error("ERROR: The number of VCNs from the data runs is different than the allocated size!: - " +
-                    this.numberOfVCNs);
-            log.error("Alocatedsize = " + getAttributeAlocatedSize() / clusterSize);
-            log.error("number of data runs = " + dataRuns.size());
+        // Rounds up but won't work for 0, which shouldn't occur here.
+        final long allocatedVCNs = (getAttributeAllocatedSize() - 1) / clusterSize + 1;
+        if (this.numberOfVCNs != allocatedVCNs) {
+            // Probably not a problem, often multiple attributes make up one allocation.
+            log.debug("VCN mismatch between data runs and allocated size, possibly a composite attribute. " +
+                      "data run VCNs = " + this.numberOfVCNs + ", allocated size = " + allocatedVCNs +
+                      ", data run count = " + dataRuns.size());
         }
     }
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [Jnode-svn-commits] SF.net SVN: jnode:[4781] trunk/fs/src/fs/org/jnode/fs/ntfs

jnode-svn-commits