SqliteTextExtractor.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2018-2018 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.textextractors;

import java.io.IOException;
import java.io.Reader;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.logging.Level;
import org.sleuthkit.autopsy.coreutils.SQLiteTableReaderException;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.SQLiteTableReader;
import org.sleuthkit.datamodel.AbstractFile;

final class SqliteTextExtractor implements TextExtractor {

    private static final String SQLITE_MIMETYPE = "application/x-sqlite3";
    private static final Logger logger = Logger.getLogger(SqliteTextExtractor.class.getName());
    private final AbstractFile file;

    public SqliteTextExtractor(AbstractFile file) {
        this.file = file;
    }
    @Override
    public boolean isSupported() {
        return SQLITE_MIMETYPE.equals(file.getMIMEType());
    }

    @Override
    public Reader getReader() throws InitReaderException {
        return new SQLiteStreamReader(file);
    }
    
    private class SQLiteStreamReader extends Reader {

        private final SQLiteTableReader reader;
        private final AbstractFile file;

        private Iterator<String> tableNames;
        private String currentTableName;

        private char[] buf;
        private ExcessBytes leftOvers;
        private int totalColumns;

        private int bufIndex;

        public SQLiteStreamReader(AbstractFile file) {
            this.file = file;
            reader = new SQLiteTableReader.Builder(file)
                    .forAllColumnNames(getColumnNameStrategy())
                    .forAllTableValues(getForAllTableValuesStrategy()).build();
        }

        private Consumer<Object> getForAllTableValuesStrategy() {
            return new Consumer<Object>() {
                private int columnIndex = 0;

                @Override
                public void accept(Object value) {
                    columnIndex++;
                    //Ignore blobs
                    String objectStr = (value instanceof byte[]) ? "" : Objects.toString(value, "");

                    if (columnIndex > 1 && columnIndex < totalColumns) {
                        objectStr += " ";
                    }
                    if (columnIndex == 1) {
                        objectStr = "\t" + objectStr + " ";
                    }
                    if (columnIndex == totalColumns) {
                        objectStr += "\n";
                    }

                    fillBuffer(objectStr);
                    columnIndex = columnIndex % totalColumns;
                }
            };
        }

        private Consumer<String> getColumnNameStrategy() {
            return new Consumer<String>() {
                private int columnIndex = 0;

                @Override
                public void accept(String columnName) {
                    if (columnIndex == 0) {
                        fillBuffer("\n" + currentTableName + "\n\n\t");
                    }
                    columnIndex++;

                    fillBuffer(columnName + ((columnIndex == totalColumns) ? "\n" : " "));

                    //Reset the columnCount to 0 for next table read
                    columnIndex = columnIndex % totalColumns;
                }
            };
        }

        private void fillBuffer(String val) {
            for (int i = 0; i < val.length(); i++) {
                if (bufIndex != buf.length) {
                    buf[bufIndex++] = val.charAt(i);
                } else {
                    leftOvers = new ExcessBytes(val, i);
                    break;
                }
            }
        }

        @Override
        public int read(char[] cbuf, int off, int len) throws IOException {
            buf = cbuf;

            bufIndex = off;

            //Lazily wait to get table names until first call to read.
            if (Objects.isNull(tableNames)) {
                try {
                    tableNames = reader.getTableNames().iterator();
                } catch (SQLiteTableReaderException ex) {
                    //Can't get table names so can't read the file!
                    return -1;
                }
            }

            //If there are excess bytes from last read, then copy thoses in.
            if (Objects.nonNull(leftOvers) && !leftOvers.isFinished()) {
                bufIndex += leftOvers.read(cbuf, off, len);
            }

            //Keep grabbing table names from the queue and reading them until
            //our buffer is full.
            while (bufIndex != len) {
                if (Objects.isNull(currentTableName) || reader.isFinished()) {
                    if (tableNames.hasNext()) {
                        currentTableName = tableNames.next();
                        try {
                            totalColumns = reader.getColumnCount(currentTableName);
                            reader.read(currentTableName, () -> bufIndex == len);
                        } catch (SQLiteTableReaderException ex) {
                            logger.log(Level.WARNING, String.format(
                                    "Error attempting to read file table: [%s]" //NON-NLS
                                    + " for file: [%s] (id=%d).", currentTableName, //NON-NLS
                                    file.getName(), file.getId()), ex.getMessage());
                        }
                    } else {
                        if (bufIndex == off) {
                            return -1;
                        }
                        return bufIndex;
                    }
                } else {
                    try {
                        reader.read(currentTableName, () -> bufIndex == len);
                    } catch (SQLiteTableReaderException ex) {
                        logger.log(Level.WARNING, String.format(
                                "Error attempting to read file table: [%s]" //NON-NLS
                                + " for file: [%s] (id=%d).", currentTableName, //NON-NLS
                                file.getName(), file.getId()), ex.getMessage());
                    }
                }
            }

            return bufIndex;
        }

        @Override
        public void close() throws IOException {
            try {
                reader.close();
            } catch (SQLiteTableReaderException ex) {
                logger.log(Level.WARNING, "Could not close SQliteTableReader.", ex.getMessage());
            }
        }

        private class ExcessBytes {

            private final String entity;
            private Integer pointer;

            public ExcessBytes(String entity, Integer pointer) {
                this.entity = entity;
                this.pointer = pointer;
            }

            public boolean isFinished() {
                return entity.length() == pointer;
            }

            public int read(char[] buf, int off, int len) {
                for (int i = off; i < len; i++) {
                    if (isFinished()) {
                        return i - off;
                    }

                    buf[i] = entity.charAt(pointer++);
                }

                return len - off;
            }
        }
    }
}