DerivedFile.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.text.MessageFormat;
import java.util.Collections;
import java.util.ResourceBundle;
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_META_TYPE_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_NAME_FLAG_ENUM;
import org.sleuthkit.datamodel.TskData.TSK_FS_NAME_TYPE_ENUM;

public class DerivedFile extends AbstractFile {

        private volatile DerivedMethod derivedMethod;
        private static final Logger logger = Logger.getLogger(DerivedFile.class.getName());
        private static ResourceBundle bundle = ResourceBundle.getBundle("org.sleuthkit.datamodel.Bundle");
        private boolean hasDerivedMethod = true;

        DerivedFile(SleuthkitCase db,
                        long objId,
                        long dataSourceObjectId,
                        String name,
                        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,
                        String md5Hash, String sha256Hash, FileKnown knownState,
                        String parentPath,
                        String localPath,
                        long parentId,
                        String mimeType,
                        TskData.EncodingType encodingType,
                        String extension, 
                        String ownerUid,
                        Long osAccountObjId) {
                // TODO (AUT-1904): The parent id should be passed to AbstractContent 
                // through the class hierarchy contructors.
                super(db, objId, dataSourceObjectId, TskData.TSK_FS_ATTR_TYPE_ENUM.TSK_FS_ATTR_TYPE_DEFAULT, 0,
                                name, TSK_DB_FILES_TYPE_ENUM.LOCAL, 0L, 0, dirType, metaType, dirFlag,
                                metaFlags, size, ctime, crtime, atime, mtime, (short) 0, 0, 0, md5Hash, sha256Hash, knownState, parentPath, mimeType, extension, ownerUid, osAccountObjId, Collections.emptyList());
                setLocalFilePath(localPath);
                setEncodingType(encodingType);
        }

        @Override
        public boolean isRoot() {
                return false;
        }

        public synchronized DerivedMethod getDerivedMethod() throws TskCoreException {
                if (derivedMethod == null && hasDerivedMethod == true) {
                        try {
                                derivedMethod = getSleuthkitCase().getDerivedMethod(getId());
                                if (derivedMethod == null) {
                                        hasDerivedMethod = false;  //do not attempt to lazy load
                                }
                        } catch (TskCoreException e) {
                                String msg = MessageFormat.format(bundle.getString("DerviedFile.derivedMethod.exception.msg1.text"), getId());
                                logger.log(Level.WARNING, msg, e);
                                throw new TskCoreException(msg, e);
                        }
                }
                return derivedMethod;
        }

        @Override
        public <T> T accept(SleuthkitItemVisitor<T> v) {
                return v.visit(this);
        }

        @Override
        public <T> T accept(ContentVisitor<T> v) {
                return v.visit(this);
        }

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

        @Override
        public String toString(boolean preserveState) {
                return super.toString(preserveState) + "DerivedFile{" //NON-NLS
                                + "derivedMethod=" + derivedMethod //NON-NLS
                                + ", hasDerivedMethod=" + hasDerivedMethod //NON-NLS
                                + '}';
        }

        public static class DerivedMethod {

                private final int derivedId;
                private String toolName;
                private String toolVersion;
                private String other;
                private String rederiveDetails;

                public DerivedMethod(int derivedId, String rederiveDetails) {
                        this.derivedId = derivedId;
                        this.rederiveDetails = rederiveDetails;
                        if (this.rederiveDetails == null) {
                                this.rederiveDetails = "";
                        }
                        this.toolName = "";
                        this.toolVersion = "";
                        this.other = "";
                }

                void setToolName(String toolName) {
                        this.toolName = toolName;
                }

                void setToolVersion(String toolVersion) {
                        this.toolVersion = toolVersion;
                }

                void setOther(String other) {
                        this.other = other;
                }

                public int getDerivedId() {
                        return derivedId;
                }

                public String getToolName() {
                        return toolName;
                }

                public String getToolVersion() {
                        return toolVersion;
                }

                public String getOther() {
                        return other;
                }

                public String getRederiveDetails() {
                        return rederiveDetails;
                }

                @Override
                public String toString() {
                        return "DerivedMethod{" + "derived_id=" + derivedId + ", toolName=" + toolName + ", toolVersion=" + toolVersion + ", other=" + other + ", rederiveDetails=" + rederiveDetails + '}'; //NON-NLS
                }
        }

        @Deprecated
        @SuppressWarnings("deprecation")
        protected DerivedFile(SleuthkitCase db,
                        long objId,
                        String name,
                        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,
                        String md5Hash, FileKnown knownState,
                        String parentPath,
                        String localPath,
                        long parentId) {
                this(db, objId, db.getDataSourceObjectId(objId), name, dirType, metaType, dirFlag, metaFlags, size,
                                ctime, crtime, atime, mtime,
                                md5Hash, null, knownState,
                                parentPath, localPath, parentId, null, TskData.EncodingType.NONE, null, OsAccount.NO_OWNER_ID, OsAccount.NO_ACCOUNT);
        }

}