Case.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2015 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.autopsy.casemodule;

import java.awt.Frame;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.logging.Level;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.actions.CallableSystemAction;
import org.openide.util.actions.SystemAction;
import org.openide.windows.WindowManager;
import org.sleuthkit.autopsy.casemodule.services.Services;
import org.sleuthkit.autopsy.corecomponentinterfaces.CoreComponentControl;
import org.sleuthkit.autopsy.coreutils.FileUtil;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.MessageNotifyUtil;
import org.sleuthkit.autopsy.coreutils.PlatformUtil;
import org.sleuthkit.autopsy.coreutils.Version;
import org.sleuthkit.datamodel.*;
import org.sleuthkit.datamodel.SleuthkitJNI.CaseDbHandle.AddImageProcess;

@SuppressWarnings("deprecation") // TODO: Remove this when ErrorObserver is replaced.
public class Case implements SleuthkitCase.ErrorObserver {

    private static final String autopsyVer = Version.getVersion(); // current version of autopsy. Change it when the version is changed
    private static String appName = null;

    public static final String propStartup = "LBL_StartupDialog"; //NON-NLS
    // pcs is initialized in CaseListener constructor
    private static final PropertyChangeSupport pcs = new PropertyChangeSupport(Case.class);

    public enum Events {

        // @@@ BC: I propose that this is no longer called for case open/close.
        NAME,
        NUMBER,
        EXAMINER,
        DATA_SOURCE_ADDED,
        DATA_SOURCE_DELETED,
        CURRENT_CASE,
        REPORT_ADDED;
    };

    private String name;
    private String number;
    private String examiner;
    private String configFilePath;
    private final XMLCaseManagement xmlcm;
    private final SleuthkitCase db;
    // Track the current case (only set with changeCase() method)
    private static Case currentCase = null;
    private final Services services;
    private static final Logger logger = Logger.getLogger(Case.class.getName());
    static final String CASE_EXTENSION = "aut"; //NON-NLS
    static final String CASE_DOT_EXTENSION = "." + CASE_EXTENSION;

    // we cache if the case has data in it yet since a few places ask for it and we dont' need to keep going to DB
    private boolean hasData = false;

    private Case(String name, String number, String examiner, String configFilePath, XMLCaseManagement xmlcm, SleuthkitCase db) {
        this.name = name;
        this.number = number;
        this.examiner = examiner;
        this.configFilePath = configFilePath;
        this.xmlcm = xmlcm;
        this.db = db;
        this.services = new Services(db);
    }

    private void init() {
        db.addErrorObserver(this);
    }

    public static Case getCurrentCase() {
        if (currentCase != null) {
            return currentCase;
        } else {
            throw new IllegalStateException(NbBundle.getMessage(Case.class, "Case.getCurCase.exception.noneOpen"));
        }
    }

    public static boolean isCaseOpen() {
        return currentCase != null;
    }

    private static void changeCase(Case newCase) {

        // close the existing case
        Case oldCase = Case.currentCase;
        Case.currentCase = null;
        if (oldCase != null) {
            doCaseChange(null); //closes windows, etc

            try {
                pcs.firePropertyChange(Events.CURRENT_CASE.toString(), oldCase, null);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(Case.class, "Case.moduleErr"),
                        NbBundle.getMessage(Case.class,
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
            doCaseNameChange("");

            try {
                pcs.firePropertyChange(Events.NAME.toString(), oldCase.name, "");
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(Case.class, "Case.moduleErr"),
                        NbBundle.getMessage(Case.class,
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
        }

        if (newCase != null) {
            currentCase = newCase;

            Logger.setLogDirectory(currentCase.getLogDirectoryPath());

            try {
                pcs.firePropertyChange(Events.CURRENT_CASE.toString(), null, currentCase);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(Case.class, "Case.moduleErr"),
                        NbBundle.getMessage(Case.class,
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
            doCaseChange(currentCase);

            try {
                pcs.firePropertyChange(Events.NAME.toString(), "", currentCase.name);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(Case.class, "Case.moduleErr"),
                        NbBundle.getMessage(Case.class,
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
            doCaseNameChange(currentCase.name);

            RecentCases.getInstance().addRecentCase(currentCase.name, currentCase.configFilePath); // update the recent cases
        } else {
            Logger.setLogDirectory(PlatformUtil.getLogDirectory());
        }
    }

    AddImageProcess makeAddImageProcess(String timezone, boolean processUnallocSpace, boolean noFatOrphans) {
        return this.db.makeAddImageProcess(timezone, processUnallocSpace, noFatOrphans);
    }

    public static void create(String caseDir, String caseName, String caseNumber, String examiner) throws CaseActionException {
        logger.log(Level.INFO, "Creating new case.\ncaseDir: {0}\ncaseName: {1}", new Object[]{caseDir, caseName}); //NON-NLS

        // create case directory if it doesn't already exist.
        if (new File(caseDir).exists() == false) {
            Case.createCaseDirectory(caseDir);
        }

        String configFilePath = caseDir + File.separator + caseName + CASE_DOT_EXTENSION;

        XMLCaseManagement xmlcm = new XMLCaseManagement();
        xmlcm.create(caseDir, caseName, examiner, caseNumber); // create a new XML config file
        xmlcm.writeFile();

        String dbPath = caseDir + File.separator + "autopsy.db"; //NON-NLS
        SleuthkitCase db = null;
        try {
            db = SleuthkitCase.newCase(dbPath);
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, "Error creating a case: " + caseName + " in dir " + caseDir, ex); //NON-NLS
            throw new CaseActionException(
                    NbBundle.getMessage(Case.class, "Case.create.exception.msg", caseName, caseDir), ex);
        }

        Case newCase = new Case(caseName, caseNumber, examiner, configFilePath, xmlcm, db);
        newCase.init();

        changeCase(newCase);
    }

    public static void open(String configFilePath) throws CaseActionException {
        logger.log(Level.INFO, "Opening case.\nconfigFilePath: {0}", configFilePath); //NON-NLS

        try {
            XMLCaseManagement xmlcm = new XMLCaseManagement();

            xmlcm.open(configFilePath); // open and load the config file to the document handler in the XML class
            xmlcm.writeFile(); // write any changes to the config file

            String caseName = xmlcm.getCaseName();
            String caseNumber = xmlcm.getCaseNumber();
            String examiner = xmlcm.getCaseExaminer();
            // if the caseName is "", case / config file can't be opened
            if (caseName.equals("")) {
                throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.open.exception.blankCase.msg"));
            }

            String caseDir = xmlcm.getCaseDirectory();
            String dbPath = caseDir + File.separator + "autopsy.db"; //NON-NLS
            SleuthkitCase db = SleuthkitCase.openCase(dbPath);
            if (null != db.getBackupDatabasePath()) {
                JOptionPane.showMessageDialog(null,
                        NbBundle.getMessage(Case.class, "Case.open.msgDlg.updated.msg",
                                db.getBackupDatabasePath()),
                        NbBundle.getMessage(Case.class, "Case.open.msgDlg.updated.title"),
                        JOptionPane.INFORMATION_MESSAGE);
            }

            checkImagesExist(db);

            Case openedCase = new Case(caseName, caseNumber, examiner, configFilePath, xmlcm, db);
            openedCase.init();

            changeCase(openedCase);

        } catch (Exception ex) {
            logger.log(Level.SEVERE, "Error opening the case: ", ex); //NON-NLS
            // close the previous case if there's any
            CaseCloseAction closeCase = SystemAction.get(CaseCloseAction.class);
            closeCase.actionPerformed(null);
            if (!configFilePath.endsWith(CASE_DOT_EXTENSION)) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.open.exception.checkFile.msg", CASE_DOT_EXTENSION), ex);
            } else {
                throw new CaseActionException(NbBundle.getMessage(Case.class, "Case.open.exception.gen.msg") + ". " + ex.getMessage(), ex);
            }
        }
    }

    static Map<Long, String> getImagePaths(SleuthkitCase db) { //TODO: clean this up
        Map<Long, String> imgPaths = new HashMap<>();
        try {
            Map<Long, List<String>> imgPathsList = db.getImagePaths();
            for (Map.Entry<Long, List<String>> entry : imgPathsList.entrySet()) {
                if (entry.getValue().size() > 0) {
                    imgPaths.put(entry.getKey(), entry.getValue().get(0));
                }
            }
        } catch (TskException ex) {
            logger.log(Level.WARNING, "Error getting image paths", ex); //NON-NLS
        }
        return imgPaths;
    }

    private static void checkImagesExist(SleuthkitCase db) {
        Map<Long, String> imgPaths = getImagePaths(db);
        for (Map.Entry<Long, String> entry : imgPaths.entrySet()) {
            long obj_id = entry.getKey();
            String path = entry.getValue();
            boolean fileExists = (pathExists(path)
                    || driveExists(path));
            if (!fileExists) {
                int ret = JOptionPane.showConfirmDialog(null,
                        NbBundle.getMessage(Case.class,
                                "Case.checkImgExist.confDlg.doesntExist.msg",
                                appName, path),
                        NbBundle.getMessage(Case.class,
                                "Case.checkImgExist.confDlg.doesntExist.title"),
                        JOptionPane.YES_NO_OPTION);
                if (ret == JOptionPane.YES_OPTION) {

                    MissingImageDialog.makeDialog(obj_id, db);

                } else {
                    logger.log(Level.WARNING, "Selected image files don't match old files!"); //NON-NLS
                }

            }
        }
    }

    @Deprecated
    public Image addImage(String imgPath, long imgId, String timeZone) throws CaseActionException {
        logger.log(Level.INFO, "Adding image to Case.  imgPath: {0}  ID: {1} TimeZone: {2}", new Object[]{imgPath, imgId, timeZone}); //NON-NLS

        try {
            Image newImage = db.getImageById(imgId);

            try {
                pcs.firePropertyChange(Events.DATA_SOURCE_ADDED.toString(), null, newImage); // the new value is the instance of the image
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(this.getClass(), "Case.moduleErr"),
                        NbBundle.getMessage(this.getClass(),
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
            CoreComponentControl.openCoreWindows();
            return newImage;
        } catch (Exception ex) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.addImg.exception.msg"), ex);
        }
    }

    @Deprecated
    void addLocalDataSource(Content newDataSource) {

        notifyNewDataSource(newDataSource);
    }

    void notifyNewDataSource(Content newDataSource) {

        try {
            pcs.firePropertyChange(Events.DATA_SOURCE_ADDED.toString(), null, newDataSource);
        } catch (Exception e) {
            logger.log(Level.SEVERE, "Case threw exception", e); //NON-NLS
            MessageNotifyUtil.Notify.show(NbBundle.getMessage(this.getClass(), "Case.moduleErr"),
                    NbBundle.getMessage(this.getClass(),
                            "Case.changeCase.errListenToCaseUpdates.msg"),
                    MessageNotifyUtil.MessageType.ERROR);
        }
        CoreComponentControl.openCoreWindows();
    }

    public Services getServices() {
        return services;
    }

    public SleuthkitCase getSleuthkitCase() {
        return this.db;
    }

    public void closeCase() throws CaseActionException {
        changeCase(null);

        try {
            services.close();
            this.xmlcm.close(); // close the xmlcm
            this.db.close();
        } catch (Exception e) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.closeCase.exception.msg"), e);
        }
    }

    void deleteCase(File caseDir) throws CaseActionException {
        logger.log(Level.INFO, "Deleting case.\ncaseDir: {0}", caseDir); //NON-NLS

        try {

            xmlcm.close(); // close the xmlcm
            boolean result = deleteCaseDirectory(caseDir); // delete the directory

            RecentCases.getInstance().removeRecentCase(this.name, this.configFilePath); // remove it from the recent case
            Case.changeCase(null);
            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(this.getClass(), "Case.deleteCase.exception.msg", caseDir));
            }
        } catch (Exception ex) {
            logger.log(Level.SEVERE, "Error deleting the current case dir: " + caseDir, ex); //NON-NLS
            throw new CaseActionException(
                    NbBundle.getMessage(this.getClass(), "Case.deleteCase.exception.msg2", caseDir), ex);
        }
    }

    void updateCaseName(String oldCaseName, String oldPath, String newCaseName, String newPath) throws CaseActionException {
        try {
            xmlcm.setCaseName(newCaseName); // set the case
            name = newCaseName; // change the local value
            RecentCases.getInstance().updateRecentCase(oldCaseName, oldPath, newCaseName, newPath); // update the recent case 
            try {
                pcs.firePropertyChange(Events.NAME.toString(), oldCaseName, newCaseName);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(this.getClass(), "Case.moduleErr"),
                        NbBundle.getMessage(this.getClass(),
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
            doCaseNameChange(newCaseName);

        } catch (Exception e) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.updateCaseName.exception.msg"), e);
        }
    }

    void updateExaminer(String oldExaminer, String newExaminer) throws CaseActionException {
        try {
            xmlcm.setCaseExaminer(newExaminer); // set the examiner
            examiner = newExaminer;
            try {
                pcs.firePropertyChange(Events.EXAMINER.toString(), oldExaminer, newExaminer);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(this.getClass(), "Case.moduleErr"),
                        NbBundle.getMessage(this.getClass(),
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
        } catch (Exception e) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.updateExaminer.exception.msg"), e);
        }
    }

    void updateCaseNumber(String oldCaseNumber, String newCaseNumber) throws CaseActionException {
        try {
            xmlcm.setCaseNumber(newCaseNumber); // set the case number
            number = newCaseNumber;

            try {
                pcs.firePropertyChange(Events.NUMBER.toString(), oldCaseNumber, newCaseNumber);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Case listener threw exception", e); //NON-NLS
                MessageNotifyUtil.Notify.show(NbBundle.getMessage(this.getClass(), "Case.moduleErr"),
                        NbBundle.getMessage(this.getClass(),
                                "Case.changeCase.errListenToCaseUpdates.msg"),
                        MessageNotifyUtil.MessageType.ERROR);
            }
        } catch (Exception e) {
            throw new CaseActionException(NbBundle.getMessage(this.getClass(), "Case.updateCaseNum.exception.msg"), e);
        }
    }

    public static boolean existsCurrentCase() {
        return currentCase != null;
    }

    private void setConfigFilePath(String givenPath) {
        configFilePath = givenPath;
    }

    String getConfigFilePath() {
        return configFilePath;
    }

    public static String getAutopsyVersion() {
        return autopsyVer;
    }

    public static String getAppName() {
        if ((appName == null) || appName.equals("")) {
            appName = WindowManager.getDefault().getMainWindow().getTitle();
        }
        return appName;
    }

    public String getName() {
        return name;
    }

    public String getNumber() {
        return number;
    }

    public String getExaminer() {
        return examiner;
    }

    public String getCaseDirectory() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getCaseDirectory();
        }
    }

    public String getTempDirectory() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getTempDir();
        }
    }

    public String getCacheDirectory() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getCacheDir();
        }
    }

    public String getExportDirectory() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getExportDir();
        }
    }

    public String getLogDirectoryPath() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getLogDir();
        }
    }

    public String getCreatedDate() {
        if (xmlcm == null) {
            return "";
        } else {
            return xmlcm.getCreatedDate();
        }
    }

    public String getModulesOutputDirAbsPath() {
        return this.getCaseDirectory() + File.separator + getModulesOutputDirRelPath();
    }

    public static String getModulesOutputDirRelPath() {
        return "ModuleOutput"; //NON-NLS
    }

    public static PropertyChangeSupport getPropertyChangeSupport() {
        return pcs;
    }

    public List<Content> getDataSources() throws TskCoreException {
        List<Content> list = db.getRootObjects();
        hasData = (list.size() > 0);
        return list;
    }

    public Set<TimeZone> getTimeZone() {
        Set<TimeZone> timezones = new HashSet<>();
        try {
            for (Content c : getDataSources()) {
                final Content dataSource = c.getDataSource();
                if ((dataSource != null) && (dataSource instanceof Image)) {
                    Image image = (Image) dataSource;
                    timezones.add(TimeZone.getTimeZone(image.getTimeZone()));
                }
            }
        } catch (TskCoreException ex) {
            logger.log(Level.INFO, "Error getting time zones", ex); //NON-NLS
        }
        return timezones;
    }

    public static synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
        pcs.addPropertyChangeListener(listener);
    }

    public static synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
        pcs.removePropertyChangeListener(listener);
    }

    public static boolean pathExists(String imgPath) {
        return new File(imgPath).isFile();
    }
    private static final String pdisk = "\\\\.\\physicaldrive"; //NON-NLS
    private static final String dev = "/dev/"; //NON-NLS

    static boolean isPhysicalDrive(String path) {
        return path.toLowerCase().startsWith(pdisk)
                || path.toLowerCase().startsWith(dev);
    }

    static boolean isPartition(String path) {
        return path.toLowerCase().startsWith("\\\\.\\")
                && path.toLowerCase().endsWith(":");
    }

    static boolean driveExists(String path) {
        // Test the drive by reading the first byte and checking if it's -1
        BufferedInputStream br = null;
        try {
            File tmp = new File(path);
            br = new BufferedInputStream(new FileInputStream(tmp));
            int b = br.read();
            return b != -1;
        } catch (Exception ex) {
            return false;
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException ex) {
            }
        }
    }

    public static String convertTimeZone(String timezoneID) {

        TimeZone zone = TimeZone.getTimeZone(timezoneID);
        int offset = zone.getRawOffset() / 1000;
        int hour = offset / 3600;
        int min = (offset % 3600) / 60;

        DateFormat dfm = new SimpleDateFormat("z");
        dfm.setTimeZone(zone);
        boolean hasDaylight = zone.useDaylightTime();
        String first = dfm.format(new GregorianCalendar(2010, 1, 1).getTime()).substring(0, 3); // make it only 3 letters code
        String second = dfm.format(new GregorianCalendar(2011, 6, 6).getTime()).substring(0, 3); // make it only 3 letters code
        int mid = hour * -1;
        String result = first + Integer.toString(mid);
        if (min != 0) {
            result = result + ":" + Integer.toString(min);
        }
        if (hasDaylight) {
            result = result + second;
        }

        return result;
    }

    /*
     * The methods below are used to manage the case directories (creating,
     * checking, deleting, etc)
     */
    static void createCaseDirectory(String caseDir, String caseName) throws CaseActionException {
        createCaseDirectory(caseDir);

    }

    static void createCaseDirectory(String caseDir) throws CaseActionException {

        File caseDirF = new File(caseDir);
        if (caseDirF.exists()) {
            if (caseDirF.isFile()) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existNotDir", caseDir));
            } else if (!caseDirF.canRead() || !caseDirF.canWrite()) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.existCantRW", caseDir));
            }
        }

        try {
            boolean result = (caseDirF).mkdirs(); // create root case Directory
            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreate", caseDir));
            }

            // create the folders inside the case directory
            result = result && (new File(caseDir + File.separator + XMLCaseManagement.EXPORT_FOLDER_RELPATH)).mkdir()
                    && (new File(caseDir + File.separator + XMLCaseManagement.LOG_FOLDER_RELPATH)).mkdir()
                    && (new File(caseDir + File.separator + XMLCaseManagement.TEMP_FOLDER_RELPATH)).mkdir()
                    && (new File(caseDir + File.separator + XMLCaseManagement.CACHE_FOLDER_RELPATH)).mkdir();

            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateCaseDir", caseDir));
            }

            final String modulesOutDir = caseDir + File.separator + getModulesOutputDirRelPath();
            result = new File(modulesOutDir).mkdir();
            if (result == false) {
                throw new CaseActionException(
                        NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.cantCreateModDir",
                                modulesOutDir));
            }

        } catch (Exception e) {
            throw new CaseActionException(
                    NbBundle.getMessage(Case.class, "Case.createCaseDir.exception.gen", caseDir), e);
        }
    }

    static boolean deleteCaseDirectory(File casePath) {
        logger.log(Level.INFO, "Deleting case directory: {0}", casePath.getAbsolutePath()); //NON-NLS
        return FileUtil.deleteDir(casePath);
    }

    static public void invokeStartupDialog() {
        StartupWindowProvider.getInstance().open();
    }

    private static void runAddImageAction() {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                final AddImageAction action = Lookup.getDefault().lookup(AddImageAction.class);
                action.actionPerformed(null);
            }
        });
    }

    static public boolean isValidName(String caseName) {
        return !(caseName.contains("\\") || caseName.contains("/") || caseName.contains(":")
                || caseName.contains("*") || caseName.contains("?") || caseName.contains("\"")
                || caseName.contains("<") || caseName.contains(">") || caseName.contains("|"));
    }

    static private void clearTempFolder() {
        File tempFolder = new File(currentCase.getTempDirectory());
        if (tempFolder.isDirectory()) {
            File[] files = tempFolder.listFiles();
            if (files.length > 0) {
                for (File file : files) {
                    if (file.isDirectory()) {
                        deleteCaseDirectory(file);
                    } else {
                        file.delete();
                    }
                }
            }
        }
    }

    private static void checkSubFolders(Case openedCase) {
        String modulesOutputDir = openedCase.getModulesOutputDirAbsPath();
        File modulesOutputDirF = new File(modulesOutputDir);
        if (!modulesOutputDirF.exists()) {
            logger.log(Level.INFO, "Creating modules output dir for the case."); //NON-NLS

            try {
                if (!modulesOutputDirF.mkdir()) {
                    logger.log(Level.SEVERE, "Error creating modules output dir for the case, dir: {0}", modulesOutputDir); //NON-NLS
                }
            } catch (SecurityException e) {
                logger.log(Level.SEVERE, "Error creating modules output dir for the case, dir: " + modulesOutputDir, e); //NON-NLS
            }
        }
    }

    //case change helper
    private static void doCaseChange(Case toChangeTo) {
        logger.log(Level.INFO, "Changing Case to: {0}", toChangeTo); //NON-NLS
        if (toChangeTo != null) { // new case is open

            // clear the temp folder when the case is created / opened
            Case.clearTempFolder();
            checkSubFolders(toChangeTo);

            // enable these menus
            CallableSystemAction.get(AddImageAction.class).setEnabled(true);
            CallableSystemAction.get(CaseCloseAction.class).setEnabled(true);
            CallableSystemAction.get(CasePropertiesAction.class).setEnabled(true);
            CallableSystemAction.get(CaseDeleteAction.class).setEnabled(true); // Delete Case menu

            if (toChangeTo.hasData()) {
                // open all top components
                CoreComponentControl.openCoreWindows();
            } else {
                // close all top components
                CoreComponentControl.closeCoreWindows();
            }
        } else { // case is closed
            // close all top components first
            CoreComponentControl.closeCoreWindows();

            // disable these menus
            CallableSystemAction.get(AddImageAction.class).setEnabled(false); // Add Image menu
            CallableSystemAction.get(CaseCloseAction.class).setEnabled(false); // Case Close menu
            CallableSystemAction.get(CasePropertiesAction.class).setEnabled(false); // Case Properties menu
            CallableSystemAction.get(CaseDeleteAction.class).setEnabled(false); // Delete Case menu

            //clear pending notifications
            MessageNotifyUtil.Notify.clear();

            Frame f = WindowManager.getDefault().getMainWindow();
            f.setTitle(Case.getAppName()); // set the window name to just application name

            //try to force gc to happen
            System.gc();
            System.gc();
        }

        //log memory usage after case changed
        logger.log(Level.INFO, PlatformUtil.getAllMemUsageInfo());

    }

    //case name change helper
    private static void doCaseNameChange(String newCaseName) {
        // update case name
        if (!newCaseName.equals("")) {
            Frame f = WindowManager.getDefault().getMainWindow();
            f.setTitle(newCaseName + " - " + Case.getAppName()); // set the window name to the new value
        }
    }

    //delete image helper
    private void doDeleteImage() {
        // no more image left in this case
        if (currentCase.hasData()) {
            // close all top components
            CoreComponentControl.closeCoreWindows();
        }
    }

    @Override
    public void receiveError(String context, String errorMessage) {
        MessageNotifyUtil.Notify.error(context, errorMessage);
    }

    public void addReport(String localPath, String srcModuleName, String reportName) throws TskCoreException {
        Report report = this.db.addReport(localPath, srcModuleName, reportName);
        try {
            Case.pcs.firePropertyChange(Events.REPORT_ADDED.toString(), null, report);
        } catch (Exception ex) {
            String errorMessage = String.format("A Case %s listener threw an exception", Events.REPORT_ADDED.toString()); //NON-NLS
            logger.log(Level.SEVERE, errorMessage, ex);
        }
    }

    public List<Report> getAllReports() throws TskCoreException {
        return this.db.getAllReports();
    }

    public boolean hasData() {
        // false is also the initial value, so make the DB trip if it is still false
        if (!hasData) {
            try {
                hasData = (getDataSources().size() > 0);
            } catch (TskCoreException ex) {
            }
        }
        return hasData;
    }
}