FileManager.java

Go to the documentation of this file.

/*
 *
 * Autopsy Forensic Browser
 * 
 * Copyright 2012 Basis Technology Corp.
 * 
 * Copyright 2012 42six Solutions.
 * Contact: aebadirad <at> 42six <dot> com
 * Project Contact/Architect: 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.autopsy.casemodule.services;

import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.datamodel.VirtualDirectoryNode;
import org.sleuthkit.autopsy.ingest.IngestServices;
import org.sleuthkit.autopsy.ingest.ModuleContentEvent;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.DerivedFile;
import org.sleuthkit.datamodel.LayoutFile;
import org.sleuthkit.datamodel.LocalFile;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.SleuthkitCase.CaseDbTransaction;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskFileRange;
import org.sleuthkit.datamodel.VirtualDirectory;
import org.sleuthkit.datamodel.CarvedFileContainer;

public class FileManager implements Closeable {

    private SleuthkitCase tskCase;
    private static final Logger logger = Logger.getLogger(FileManager.class.getName());
    private volatile int curNumFileSets;  //current number of filesets (root virt dir objects)

    public FileManager(SleuthkitCase tskCase) {
        this.tskCase = tskCase;
        init();
    }

    private synchronized void init() {
        //get the number of local file sets in db
        List<VirtualDirectory> virtRoots;
        curNumFileSets = 0;
        try {
            virtRoots = tskCase.getVirtualDirectoryRoots();
            for (VirtualDirectory vd : virtRoots) {
                if (vd.getName().startsWith(VirtualDirectoryNode.LOGICAL_FILE_SET_PREFIX)) {
                    ++curNumFileSets;
                }
            }
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, "Error initializing FileManager and getting number of local file sets"); //NON-NLS
        }


    }

    public synchronized List<AbstractFile> findFiles(Content dataSource, String fileName) throws TskCoreException {
        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.findFiles.exception.msg"));
        }
        return tskCase.findFiles(dataSource, fileName);
    }

    public synchronized List<AbstractFile> findFiles(Content dataSource, String fileName, String dirName) throws TskCoreException {
        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.findFiles2.exception.msg"));
        }
        return tskCase.findFiles(dataSource, fileName, dirName);
    }

    public synchronized List<AbstractFile> findFiles(Content dataSource, String fileName, AbstractFile parentFile) throws TskCoreException {
        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.findFiles3.exception.msg"));
        }
        return findFiles(dataSource, fileName, parentFile.getName());
    }

    public synchronized List<AbstractFile> openFiles(Content dataSource, String filePath) throws TskCoreException {
        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.openFiles.exception.msg"));
        }
        return tskCase.openFiles(dataSource, filePath);
    }

    public synchronized DerivedFile addDerivedFile(String fileName, String localPath, long size,
            long ctime, long crtime, long atime, long mtime,
            boolean isFile, AbstractFile parentFile,
            String rederiveDetails, String toolName, String toolVersion, String otherDetails) throws TskCoreException {

        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.addDerivedFile.exception.msg"));
        }

        return tskCase.addDerivedFile(fileName, localPath, size,
                ctime, crtime, atime, mtime,
                isFile, parentFile, rederiveDetails, toolName, toolVersion, otherDetails);
    }

    public synchronized LayoutFile addCarvedFile(String carvedFileName, long carvedFileSize,
            long systemId, List<TskFileRange> sectors) throws TskCoreException {

        if (tskCase == null) {
            throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.addCarvedFile.exception.msg"));
        }

        return tskCase.addCarvedFile(carvedFileName, carvedFileSize, systemId, sectors);
    }

    public List<LayoutFile> addCarvedFiles(List<CarvedFileContainer> filesToAdd) throws TskCoreException {
     if (tskCase == null) {
         throw new TskCoreException(NbBundle.getMessage(this.getClass(), "FileManager.addCarvedFile.exception.msg"));
     }
     else {
         return tskCase.addCarvedFiles(filesToAdd);
     }
    }

    public interface FileAddProgressUpdater {

        public void fileAdded(AbstractFile newFile);
    }

    public synchronized VirtualDirectory addLocalFilesDirs(List<String> localAbsPaths, FileAddProgressUpdater addProgressUpdater) throws TskCoreException {
        final List<java.io.File> rootsToAdd = new ArrayList<>();
        //first validate all the inputs before any additions
        for (String absPath : localAbsPaths) {
            java.io.File localFile = new java.io.File(absPath);
            if (!localFile.exists() || !localFile.canRead()) {
                String msg = NbBundle
                        .getMessage(this.getClass(), "FileManager.addLocalFilesDirs.exception.notReadable.msg",
                                    localFile.getAbsolutePath());
                logger.log(Level.SEVERE, msg);
                throw new TskCoreException(msg);
            }
            rootsToAdd.add(localFile);
        }

        CaseDbTransaction trans = tskCase.beginTransaction();
        // make a virtual top-level directory for this set of files/dirs
        final VirtualDirectory fileSetRootDir = addLocalFileSetRootDir(trans);

        try {
            // recursively add each item in the set
            for (java.io.File localRootToAdd : rootsToAdd) {
                AbstractFile localFileAdded = addLocalDirInt(trans, fileSetRootDir, localRootToAdd, addProgressUpdater);

                if (localFileAdded == null) {
                    String msg = NbBundle
                            .getMessage(this.getClass(), "FileManager.addLocalFilesDirs.exception.cantAdd.msg",
                                        localRootToAdd.getAbsolutePath());
                    logger.log(Level.SEVERE, msg);
                    throw new TskCoreException(msg);
                } else {
                    //added.add(localFileAdded);
                    //send new content event
                    //for now reusing ingest events, in future this will be replaced by datamodel / observer sending out events
                    // @@@ Is this the right place for this? A directory tree refresh will be triggered, so this may be creating a race condition
                    // since the transaction is not yet committed.   
                    IngestServices.getInstance().fireModuleContentEvent(new ModuleContentEvent(localFileAdded));
                }
            }

            trans.commit();
        } catch (TskCoreException ex) {
            trans.rollback();
        }
        return fileSetRootDir;
    }

    private VirtualDirectory addLocalFileSetRootDir(CaseDbTransaction trans) throws TskCoreException {

        VirtualDirectory created = null;

        int newFileSetCount = curNumFileSets + 1;
        final String fileSetName = VirtualDirectoryNode.LOGICAL_FILE_SET_PREFIX + newFileSetCount;

        try {
            created = tskCase.addVirtualDirectory(0, fileSetName, trans);
            curNumFileSets = newFileSetCount;
        } catch (TskCoreException ex) {
            String msg = NbBundle
                    .getMessage(this.getClass(), "FileManager.addLocalFileSetRootDir.exception.errCreateDir.msg",
                                fileSetName);
            logger.log(Level.SEVERE, msg, ex);
            throw new TskCoreException(msg, ex);
        }

        return created;
    }

    private AbstractFile addLocalDirInt(CaseDbTransaction trans, VirtualDirectory parentVd,
            java.io.File localFile, FileAddProgressUpdater addProgressUpdater) throws TskCoreException {

        if (tskCase == null) {
            throw new TskCoreException(
                    NbBundle.getMessage(this.getClass(), "FileManager.addLocalDirInt.exception.closed.msg"));
        }

        //final String localName = localDir.getName();
        if (!localFile.exists()) {
            throw new TskCoreException(
                    NbBundle.getMessage(this.getClass(), "FileManager.addLocalDirInt.exception.doesntExist.msg",
                                        localFile.getAbsolutePath()));
        }
        if (!localFile.canRead()) {
            throw new TskCoreException(
                    NbBundle.getMessage(this.getClass(), "FileManager.addLocalDirInt.exception.notReadable.msg",
                                        localFile.getAbsolutePath()));
        }


        if (localFile.isDirectory()) {
            //create virtual folder (we don't have a notion of a 'local folder')
            final VirtualDirectory childVd = tskCase.addVirtualDirectory(parentVd.getId(), localFile.getName(), trans);
            if (childVd != null && addProgressUpdater != null) {
                addProgressUpdater.fileAdded(childVd);
            }
            //add children recursively
            final java.io.File[] childrenFiles = localFile.listFiles();
            if (childrenFiles != null) {
                for (java.io.File childFile : childrenFiles) {
                    addLocalDirInt(trans, childVd, childFile, addProgressUpdater);
                }
            }
            return childVd;
        } else {
            //add leaf file, base case
            return this.addLocalFileInt(parentVd, localFile, trans);
        }
    }

    private synchronized LocalFile addLocalFileInt(AbstractFile parentFile, java.io.File localFile, CaseDbTransaction trans) throws TskCoreException {

        if (tskCase == null) {
            throw new TskCoreException(
                    NbBundle.getMessage(this.getClass(), "FileManager.addLocalDirInt2.exception.closed.msg"));
        }

        long size = localFile.length();
        boolean isFile = localFile.isFile();

        long ctime = 0;
        long crtime = 0;
        long atime = 0;
        long mtime = 0;

        String fileName = localFile.getName();

        LocalFile lf = tskCase.addLocalFile(fileName, localFile.getAbsolutePath(), size,
                ctime, crtime, atime, mtime,
                isFile, parentFile, trans);

        return lf;
    }

    @Override
    public synchronized void close() throws IOException {
        tskCase = null;
    }
}