CaseNodeData.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2017-2019 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.multiusercases;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.ParseException;
import java.util.Date;
import java.util.logging.Level;
import org.sleuthkit.autopsy.casemodule.CaseMetadata;
import org.sleuthkit.autopsy.casemodule.CaseMetadata.CaseMetadataException;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService;
import org.sleuthkit.autopsy.coordinationservice.CoordinationService.CoordinationServiceException;
import org.sleuthkit.autopsy.coreutils.Logger;

public final class CaseNodeData {
 
    private static final int MAJOR_VERSION = 2;
    private static final int MINOR_VERSION = 0;
    private static final Logger logger = Logger.getLogger(CaseNodeData.class.getName());
 
    /*
     * Version 0 fields. Note that version 0 node data was only written to the
     * coordination service node if an auto ingest job error occurred.
     */
    private int version;
    private boolean errorsOccurred;
 
    /*
     * Version 1 fields.
     */
    private Path directory;
    private Date createDate;
    private Date lastAccessDate;
    private String name;
    private String displayName;
    private short deletedItemFlags;
 
    /*
     * Version 2 fields.
     */
    private int minorVersion;

    public static CaseNodeData createCaseNodeData(final CaseMetadata metadata) throws CaseNodeDataException, InterruptedException {
        try {
            final CaseNodeData nodeData = new CaseNodeData(metadata);
            CoordinationService.getInstance().setNodeData(CoordinationService.CategoryNode.CASES, nodeData.getDirectory().toString(), nodeData.toArray());
            return nodeData;
 
        } catch (ParseException | IOException | CoordinationServiceException ex) {
            throw new CaseNodeDataException(String.format("Error creating case node data for coordination service node with path %s", metadata.getCaseDirectory().toUpperCase()), ex); //NON-NLS
        }
    }

    public static CaseNodeData readCaseNodeData(String nodePath) throws CaseNodeDataException, InterruptedException {
        try {
            CaseNodeData nodeData;
            final byte[] nodeBytes = CoordinationService.getInstance().getNodeData(CoordinationService.CategoryNode.CASES, nodePath);
            if (nodeBytes != null && nodeBytes.length > 0) {
                try {
                    nodeData = new CaseNodeData(nodeBytes);
                } catch (IOException ex) {
                    /*
                     * The existing case node data is corrupted.
                     */
                    logger.log(Level.WARNING, String.format("Error reading node data for coordination service node with path %s, will attempt to replace it", nodePath.toUpperCase()), ex); //NON-NLS
                    final CaseMetadata metadata = getCaseMetadata(nodePath);
                    nodeData = createCaseNodeData(metadata);
                    logger.log(Level.INFO, String.format("Replaced corrupt node data for coordination service node with path %s", nodePath.toUpperCase())); //NON-NLS
                }
            } else {
                /*
                 * The case node data is missing. Version 0 node data was only
                 * written to the coordination service node if an auto ingest
                 * job error occurred.
                 */
                logger.log(Level.INFO, String.format("Missing node data for coordination service node with path %s, will attempt to create it", nodePath.toUpperCase())); //NON-NLS
                final CaseMetadata metadata = getCaseMetadata(nodePath);
                nodeData = createCaseNodeData(metadata);
                logger.log(Level.INFO, String.format("Created node data for coordination service node with path %s", nodePath.toUpperCase())); //NON-NLS
            }
            if (nodeData.getVersion() < CaseNodeData.MAJOR_VERSION) {
                nodeData = upgradeCaseNodeData(nodePath, nodeData);
            }
            return nodeData;
 
        } catch (CaseNodeDataException | CaseMetadataException | ParseException | IOException | CoordinationServiceException ex) {
            throw new CaseNodeDataException(String.format("Error reading/writing node data coordination service node with path %s", nodePath.toUpperCase()), ex); //NON-NLS
        }
    }

    public static void writeCaseNodeData(CaseNodeData nodeData) throws CaseNodeDataException, InterruptedException {
        try {
            CoordinationService.getInstance().setNodeData(CoordinationService.CategoryNode.CASES, nodeData.getDirectory().toString(), nodeData.toArray());
 
        } catch (IOException | CoordinationServiceException ex) {
            throw new CaseNodeDataException(String.format("Error writing node data coordination service node with path %s", nodeData.getDirectory().toString().toUpperCase()), ex); //NON-NLS
        }
    }

    private static CaseNodeData upgradeCaseNodeData(String nodePath, CaseNodeData oldNodeData) throws CaseNodeDataException, CaseMetadataException, ParseException, IOException, CoordinationServiceException, InterruptedException {
        CaseNodeData nodeData;
        switch (oldNodeData.getVersion()) {
            case 0:
                /*
                 * Version 0 node data consisted of only the version number and
                 * the errors occurred flag and was only written when an auto
                 * ingest job error occurred. To upgrade from version 0, the
                 * version 1 fields need to be set from the case metadata and
                 * the errors occurred flag needs to be carried forward. Note
                 * that the last accessed date gets advanced to now, since it is
                 * otherwise unknown.
                 */
                final CaseMetadata metadata = getCaseMetadata(nodePath);
                nodeData = new CaseNodeData(metadata);
                nodeData.setErrorsOccurred(oldNodeData.getErrorsOccurred());
                break;
            case 1:
                /*
                 * Version 1 node data did not have a minor version number
                 * field.
                 */
                oldNodeData.setMinorVersion(MINOR_VERSION);
                nodeData = oldNodeData;
                break;
            default:
                nodeData = oldNodeData;
                break;
        }
        writeCaseNodeData(nodeData);
        return nodeData;
    }

    private static CaseMetadata getCaseMetadata(String nodePath) throws CaseNodeDataException, CaseMetadataException {
        final Path caseDirectoryPath = Paths.get(nodePath);
        final File caseDirectory = caseDirectoryPath.toFile();
        if (!caseDirectory.exists()) {
            throw new CaseNodeDataException("Case directory does not exist"); // NON-NLS
        }
        final Path metadataFilePath = CaseMetadata.getCaseMetadataFilePath(caseDirectoryPath);
        if (metadataFilePath == null) {
            throw new CaseNodeDataException("Case meta data file does not exist"); // NON-NLS            
        }
        return new CaseMetadata(metadataFilePath);
    }

    private CaseNodeData(CaseMetadata metadata) throws ParseException {
        this.version = MAJOR_VERSION;
        this.errorsOccurred = false;
        this.directory = Paths.get(metadata.getCaseDirectory());
        this.createDate = CaseMetadata.getDateFormat().parse(metadata.getCreatedDate());
        this.lastAccessDate = new Date();
        this.name = metadata.getCaseName();
        this.displayName = metadata.getCaseDisplayName();
        this.deletedItemFlags = 0;
        this.minorVersion = MINOR_VERSION;
    }

    private CaseNodeData(byte[] nodeData) throws IOException {
        if (nodeData == null || nodeData.length == 0) {
            throw new IOException(null == nodeData ? "Null node data byte array" : "Zero-length node data byte array");
        }
        try (ByteArrayInputStream byteStream = new ByteArrayInputStream(nodeData); DataInputStream inputStream = new DataInputStream(byteStream)) {
            this.version = inputStream.readInt();
            if (this.version == 1) {
                this.errorsOccurred = inputStream.readBoolean();
            } else {
                byte errorsOccurredByte = inputStream.readByte();
                this.errorsOccurred = (errorsOccurredByte < 0);
            }
            if (this.version > 0) {
                this.directory = Paths.get(inputStream.readUTF());
                this.createDate = new Date(inputStream.readLong());
                this.lastAccessDate = new Date(inputStream.readLong());
                this.name = inputStream.readUTF();
                this.displayName = inputStream.readUTF();
                this.deletedItemFlags = inputStream.readShort();
            }
            if (this.version > 1) {
                this.minorVersion = inputStream.readInt();
            }
        }
    }

    private int getVersion() {
        return this.version;
    }

    private void setMinorVersion(int minorVersion) {
        this.minorVersion = minorVersion;
    }

    public boolean getErrorsOccurred() {
        return this.errorsOccurred;
    }

    public void setErrorsOccurred(boolean errorsOccurred) {
        this.errorsOccurred = errorsOccurred;
    }

    public Path getDirectory() {
        return this.directory;
    }

    public Date getCreateDate() {
        return new Date(this.createDate.getTime());
    }

    public Date getLastAccessDate() {
        return new Date(this.lastAccessDate.getTime());
    }

    public void setLastAccessDate(Date lastAccessDate) {
        this.lastAccessDate = new Date(lastAccessDate.getTime());
    }

    public String getName() {
        return this.name;
    }

    public String getDisplayName() {
        return this.displayName;
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

    public boolean isDeletedFlagSet(DeletedFlags flag) {
        return (this.deletedItemFlags & flag.getValue()) == flag.getValue();
    }

    public void setDeletedFlag(DeletedFlags flag) {
        this.deletedItemFlags |= flag.getValue();
    }

    private byte[] toArray() throws IOException {
        try (ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); DataOutputStream outputStream = new DataOutputStream(byteStream)) {
            outputStream.writeInt(this.version);
            outputStream.writeByte((byte) (this.errorsOccurred ? 0x80 : 0));
            outputStream.writeUTF(this.directory.toString());
            outputStream.writeLong(this.createDate.getTime());
            outputStream.writeLong(this.lastAccessDate.getTime());
            outputStream.writeUTF(this.name);
            outputStream.writeUTF(this.displayName);
            outputStream.writeShort(this.deletedItemFlags);
            outputStream.writeInt(this.minorVersion);
            outputStream.flush();
            byteStream.flush();
            return byteStream.toByteArray();
        }
    }

    public enum DeletedFlags {
 
        TEXT_INDEX(1),
        CASE_DB(2),
        CASE_DIR(4),
        DATA_SOURCES(8),
        MANIFEST_FILE_NODES(16);
 
        private final short value;

        private DeletedFlags(int value) {
            this.value = (short) value;
        }

        private short getValue() {
            return value;
        }
 
    }

    public static final class CaseNodeDataException extends Exception {
 
        private static final long serialVersionUID = 1L;

        private CaseNodeDataException(String message) {
            super(message);
        }

        private CaseNodeDataException(String message, Throwable cause) {
            super(message, cause);
        }
    }
 
}