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.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 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, FileKnown knownState,
                        String parentPath,
                        String mimeType,
                        String extension) {
                super(db, objId, dataSourceObjectId, attrType, attrId, name, fileType, metaAddr, metaSeq, dirType, metaType, dirFlag, metaFlags, size, ctime, crtime, atime, mtime, modes, uid, gid, md5Hash, knownState, parentPath, mimeType, extension);
                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 synchronized String getUniquePath() throws TskCoreException {
                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, knownState, parentPath, null, null);
        }

        @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, knownState, parentPath, mimeType, null);
        }
}