FsContent.java

Go to the documentation of this file.

/*
 * SleuthKit Java Bindings
 *
 * Copyright 2011-2017 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * 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.
 */
package org.sleuthkit.datamodel;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.sleuthkit.datamodel.TskData.FileKnown;
import org.sleuthkit.datamodel.TskData.TSK_DB_FILES_TYPE_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_ATTR_TYPE_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_META_TYPE_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_NAME_FLAG_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_NAME_TYPE_ENUM;

public abstract class FsContent extends AbstractFile {

        private static final Logger logger = Logger.getLogger(FsContent.class.getName());
        private volatile String uniquePath;
        private List<String> metaDataText = null;
        private volatile FileSystem parentFileSystem;

        // TODO: Make private.
        @Deprecated
        protected final long fsObjId;

        // TODO: Make private.
        @Deprecated
        protected volatile long fileHandle = 0;

        @SuppressWarnings("deprecation")
        FsContent(SleuthkitCase db,
                        long objId,
                        long dataSourceObjectId,
                        long fsObjId,
                        TSK_FS_ATTR_TYPE_ENUM attrType, int attrId,
                        String name,
                        TSK_DB_FILES_TYPE_ENUM fileType,
                        long metaAddr, int metaSeq,
                        TSK_FS_NAME_TYPE_ENUM dirType, TSK_FS_META_TYPE_ENUM metaType,
                        TSK_FS_NAME_FLAG_ENUM dirFlag, short metaFlags,
                        long size,
                        long ctime, long crtime, long atime, long mtime,
                        short modes, int uid, int gid,
                        String md5Hash, String sha256Hash, FileKnown knownState,
                        String parentPath,
                        String mimeType,
                        String extension,
                        String ownerUid,
                        Long osAccountObjId,
                        List<Attribute> fileAttributes) {
                super(db, objId, dataSourceObjectId, attrType, attrId, name, fileType, metaAddr, metaSeq, dirType, metaType, dirFlag, metaFlags, size, ctime, crtime, atime, mtime, modes, uid, gid, md5Hash, sha256Hash, knownState, parentPath, mimeType, extension, ownerUid, osAccountObjId, fileAttributes);
                this.fsObjId = fsObjId;
        }

        @SuppressWarnings("deprecation")
        public long getFileSystemId() {
                return fsObjId;
        }

        void setFileSystem(FileSystem parent) {
                parentFileSystem = parent;
        }

        @SuppressWarnings("deprecation")
        public FileSystem getFileSystem() throws TskCoreException {
                if (parentFileSystem == null) {
                        synchronized (this) {
                                if (parentFileSystem == null) {
                                        parentFileSystem = getSleuthkitCase().getFileSystemById(fsObjId, AbstractContent.UNKNOWN_ID);
                                }
                        }
                }
                return parentFileSystem;
        }

        @SuppressWarnings("deprecation")
        void loadFileHandle() throws TskCoreException {
                if (fileHandle == 0) {
                        synchronized (this) {
                                if (fileHandle == 0) {
                                        fileHandle = SleuthkitJNI.openFile(getFileSystem().getFileSystemHandle(), metaAddr, attrType, attrId, getSleuthkitCase());
                                }
                        }
                }
        }

        @SuppressWarnings("deprecation")
        long getFileHandle() {
                return fileHandle;
        }

        @Override
        @SuppressWarnings("deprecation")
        protected synchronized int readInt(byte[] buf, long offset, long len) throws TskCoreException {
                if (offset == 0 && size == 0) {
                        //special case for 0-size file
                        return 0;
                }
                loadFileHandle();
                return SleuthkitJNI.readFile(fileHandle, buf, offset, len);
        }

        @Override
        public boolean isRoot() {
                try {
                        FileSystem fs = getFileSystem();
                        return fs.getRoot_inum() == this.getMetaAddr();
                } catch (TskCoreException ex) {
                        logger.log(Level.SEVERE, "Exception while calling 'getFileSystem' on " + this, ex); //NON-NLS
                        return false;
                }
        }

        public AbstractFile getParentDirectory() throws TskCoreException {
                return getSleuthkitCase().getParentDirectory(this);
        }

        @Override
        public Content getDataSource() throws TskCoreException {
                return getFileSystem().getDataSource();
        }

        @Override
        public String getUniquePath() throws TskCoreException {
                // It is possible that multiple threads could be doing this calculation
                // simultaneously, but it's worth the potential extra processing to prevent deadlocks.
                if (uniquePath == null) {
                        StringBuilder sb = new StringBuilder();
                        sb.append(getFileSystem().getUniquePath());
                        sb.append(getParentPath());
                        sb.append(getName());
                        uniquePath = sb.toString();
                }
                return uniquePath;
        }

        public synchronized List<String> getMetaDataText() throws TskCoreException {
                if (metaDataText != null) {
                        return metaDataText;
                }

                // if there is no metadata for this file, return empty string
                if (metaAddr == 0) {
                        metaDataText = new ArrayList<String>();
                        metaDataText.add("");
                        return metaDataText;
                }

                loadFileHandle();
                metaDataText = SleuthkitJNI.getFileMetaDataText(fileHandle);
                return metaDataText;
        }

        @Override
        @SuppressWarnings("deprecation")
        public synchronized void close() {
                if (fileHandle != 0) {
                        SleuthkitJNI.closeFile(fileHandle);
                        fileHandle = 0;
                }
        }

        @Override
        public void finalize() throws Throwable {
                try {
                        close();
                } finally {
                        super.finalize();
                }
        }

        @Override
        @SuppressWarnings("deprecation")
        public String toString(boolean preserveState) {
                return super.toString(preserveState)
                                + "FsContent [\t" //NON-NLS
                                + "fsObjId " + fsObjId //NON-NLS
                                + "\t" + "uniquePath " + uniquePath //NON-NLS
                                + "\t" + "fileHandle " + fileHandle //NON-NLS
                                + "]\t";
        }

        @Deprecated
        @SuppressWarnings("deprecation")
        FsContent(SleuthkitCase db, long objId, long fsObjId, TSK_FS_ATTR_TYPE_ENUM attrType, short attrId,
                        String name, long metaAddr, int metaSeq, TSK_FS_NAME_TYPE_ENUM dirType, TSK_FS_META_TYPE_ENUM metaType,
                        TSK_FS_NAME_FLAG_ENUM dirFlag, short metaFlags, long size, long ctime, long crtime, long atime, long mtime,
                        short modes, int uid, int gid, String md5Hash, FileKnown knownState, String parentPath) {
                this(db, objId, db.getDataSourceObjectId(objId), fsObjId, attrType, (int) attrId, name, TSK_DB_FILES_TYPE_ENUM.FS, metaAddr, metaSeq, dirType, metaType, dirFlag, metaFlags, size, ctime, crtime, atime, mtime, modes, uid, gid, md5Hash, null, knownState, parentPath, null, null, OsAccount.NO_OWNER_ID, OsAccount.NO_ACCOUNT, Collections.emptyList() );
        }

        @Deprecated
        @SuppressWarnings("deprecation")
        FsContent(SleuthkitCase db, long objId, long dataSourceObjectId, long fsObjId, TSK_FS_ATTR_TYPE_ENUM attrType, short attrId,
                        String name, long metaAddr, int metaSeq, TSK_FS_NAME_TYPE_ENUM dirType, TSK_FS_META_TYPE_ENUM metaType,
                        TSK_FS_NAME_FLAG_ENUM dirFlag, short metaFlags, long size, long ctime, long crtime, long atime, long mtime,
                        short modes, int uid, int gid, String md5Hash, FileKnown knownState, String parentPath, String mimeType) {
                this(db, objId, dataSourceObjectId, fsObjId, attrType, (int) attrId, name, TSK_DB_FILES_TYPE_ENUM.FS, metaAddr, metaSeq, dirType, metaType, dirFlag, metaFlags, size, ctime, crtime, atime, mtime, modes, uid, gid, md5Hash, null, knownState, parentPath, mimeType, null, OsAccount.NO_OWNER_ID, OsAccount.NO_ACCOUNT, Collections.emptyList());
        }
}