LocalFilesDataSource.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2011-2021 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.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;

public class LocalFilesDataSource extends VirtualDirectory implements DataSource {

        private final long objectId;
        private final String deviceId;
        private final String timezone;
        private volatile Host host;

        private static final Logger LOGGER = Logger.getLogger(LocalFilesDataSource.class.getName());

        public LocalFilesDataSource(SleuthkitCase db, long objId, long dataSourceObjectId, String deviceId, String name, TskData.TSK_FS_NAME_TYPE_ENUM dirType, TskData.TSK_FS_META_TYPE_ENUM metaType, TskData.TSK_FS_NAME_FLAG_ENUM dirFlag, short metaFlags, String timezone, String md5Hash, String sha256Hash, TskData.FileKnown knownState, String parentPath) {
                super(db, objId, dataSourceObjectId, name, dirType, metaType, dirFlag, metaFlags, md5Hash, sha256Hash, knownState, parentPath);
                this.objectId = objId;
                this.deviceId = deviceId;
                this.timezone = timezone;
        }

        @Deprecated
        public VirtualDirectory getRootDirectory() {
                return this;
        }

        @Override
        public String getDeviceId() {
                return deviceId;
        }

        @Override
        public String getTimeZone() {
                return timezone;
        }
        
        @Override
        public void setDisplayName(String newName) throws TskCoreException {
                this.getSleuthkitCase().setFileName(newName, objectId);
        }

        @Override
        public long getContentSize(SleuthkitCase sleuthkitCase) throws TskCoreException {
                return getContentSize(sleuthkitCase, objectId);
        }

        static long getContentSize(SleuthkitCase sleuthkitCase, long dataSourceObjId) throws TskCoreException {
                SleuthkitCase.CaseDbConnection connection;
                Statement statement = null;
                ResultSet resultSet = null;
                long contentSize = 0;

                connection = sleuthkitCase.getConnection();

                try {
                        statement = connection.createStatement();
                        resultSet = connection.executeQuery(statement, "SELECT SUM (size) FROM tsk_files WHERE tsk_files.data_source_obj_id = " + dataSourceObjId);
                        if (resultSet.next()) {
                                contentSize = resultSet.getLong("sum");
                        }
                } catch (SQLException ex) {
                        throw new TskCoreException(String.format("There was a problem while querying the database for size data for object ID %d.", dataSourceObjId), ex);
                } finally {
                        closeResultSet(resultSet);
                        closeStatement(statement);
                        connection.close();
                }

                return contentSize;
        }

        @Override
        public void setAcquisitionDetails(String details) throws TskCoreException {
                getSleuthkitCase().setAcquisitionDetails(this, details);
        }

        @Override
        public void setAcquisitionToolDetails(String name, String version, String settings) throws TskCoreException {
                getSleuthkitCase().setAcquisitionToolDetails(this, name, version, settings);
        }
  
        @Override
        public String getAcquisitionDetails() throws TskCoreException {
                return getSleuthkitCase().getAcquisitionDetails(this);
        }


        @Override
        public String getAcquisitionToolSettings() throws TskCoreException {
                return getSleuthkitCase().getDataSourceInfoString(this, "acquisition_tool_settings");
        }

        public String getAcquisitionToolName() throws TskCoreException {
                return getSleuthkitCase().getDataSourceInfoString(this, "acquisition_tool_name");
        }

        public String getAcquisitionToolVersion() throws TskCoreException{
                return getSleuthkitCase().getDataSourceInfoString(this, "acquisition_tool_version");
        }
        
        @Override
        public Host getHost() throws TskCoreException {
                // This is a check-then-act race condition that may occasionally result
                // in additional processing but is safer than using locks.
                if (host == null) {
                        host = getSleuthkitCase().getHostManager().getHostByDataSource(this);
                }
                return host;
        }       

        public Long getDateAdded() throws TskCoreException {
                return getSleuthkitCase().getDataSourceInfoLong(this, "added_date_time");
        }

        private static void closeResultSet(ResultSet resultSet) {
                if (resultSet != null) {
                        try {
                                resultSet.close();
                        } catch (SQLException ex) {
                                LOGGER.log(Level.SEVERE, "Error closing ResultSet", ex); //NON-NLS
                        }
                }
        }

        private static void closeStatement(Statement statement) {
                if (statement != null) {
                        try {
                                statement.close();
                        } catch (SQLException ex) {
                                LOGGER.log(Level.SEVERE, "Error closing Statement", ex); //NON-NLS
                        }
                }
        }
        
        @Override
        public <T> T accept(ContentVisitor<T> visitor) {
                return visitor.visit(this);
        }
        
        @Override
        public <T> T accept(SleuthkitItemVisitor<T> visitor) {
                return visitor.visit(this);
        }
        
        @Deprecated
        public LocalFilesDataSource(SleuthkitCase db, long objId, long dataSourceObjectId, String deviceId, String name, TskData.TSK_FS_NAME_TYPE_ENUM dirType, TskData.TSK_FS_META_TYPE_ENUM metaType, TskData.TSK_FS_NAME_FLAG_ENUM dirFlag, short metaFlags, String timezone, String md5Hash, TskData.FileKnown knownState, String parentPath) {
                this(db, objId, dataSourceObjectId, deviceId, name, dirType, metaType, dirFlag, metaFlags, timezone, md5Hash, null, knownState, parentPath);
        }       
}