ContentProviderUtils.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2023 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.util.Collection;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.lang3.StringUtils;
import org.openide.util.Lookup;
import org.sleuthkit.datamodel.ContentStreamProvider;

class ContentProviderUtils {
 
    private static final Logger logger = Logger.getLogger(ContentProviderUtils.class.getName());
 
    private ContentProviderUtils() {
    }

    static Optional<int[]> parseProviderVersion(String name) {
        if (name == null) {
            return Optional.empty();
        }
        int lastUnderscore = name.lastIndexOf('_');
        if (lastUnderscore < 0 || lastUnderscore == name.length() - 1) {
            return Optional.empty();
        }
        String[] parts = name.substring(lastUnderscore + 1).split("\\.");
        if (parts.length != 3) {
            return Optional.empty();
        }
        try {
            return Optional.of(new int[]{
                Integer.parseInt(parts[0]),
                Integer.parseInt(parts[1]),
                Integer.parseInt(parts[2])
            });
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    static Optional<String> parseProviderBaseName(String name) {
        if (!parseProviderVersion(name).isPresent()) {
            return Optional.empty();
        }
        return Optional.of(name.substring(0, name.lastIndexOf('_')));
    }

    static boolean isVersionCompatible(String createdName, String moduleName) {
        Optional<int[]> created = parseProviderVersion(createdName);
        Optional<int[]> module = parseProviderVersion(moduleName);
        if (!created.isPresent() || !module.isPresent()) {
            return false;
        }
        Optional<String> createdBase = parseProviderBaseName(createdName);
        Optional<String> moduleBase = parseProviderBaseName(moduleName);
        if (!createdBase.isPresent() || !moduleBase.isPresent()
                || !StringUtils.equalsIgnoreCase(createdBase.get(), moduleBase.get())) {
            return false;
        }
        int[] c = created.get();
        int[] m = module.get();
        return c[0] == m[0] && c[1] == m[1] && m[2] >= c[2];
    }

    static Optional<AutopsyContentProvider> findInstalledProvider(String createdName) {
        Optional<String> baseName = parseProviderBaseName(createdName);
        if (!baseName.isPresent()) {
            return Optional.empty();
        }
        Collection<? extends AutopsyContentProvider> providers
                = Lookup.getDefault().lookupAll(AutopsyContentProvider.class);
        for (AutopsyContentProvider provider : providers) {
            Optional<String> providerBase = parseProviderBaseName(
                    provider != null ? provider.getName() : null);
            if (providerBase.isPresent()
                    && StringUtils.equalsIgnoreCase(baseName.get(), providerBase.get())) {
                return Optional.of(provider);
            }
        }
        return Optional.empty();
    }

    static ContentStreamProvider getContentProvider(String createdName) {
        Collection<? extends AutopsyContentProvider> providers
                = Lookup.getDefault().lookupAll(AutopsyContentProvider.class);
        for (AutopsyContentProvider provider : providers) {
            if (provider != null
                    && (StringUtils.equalsIgnoreCase(createdName, provider.getName())
                        || isVersionCompatible(createdName, provider.getName()))) {
                try {
                    ContentStreamProvider contentProvider = provider.load();
                    if (contentProvider != null) {
                        return contentProvider;
                    }
                } catch (Exception ex) {
                    logger.log(Level.WARNING, "Content provider " + provider.getName() + " threw an exception during load(); skipping.", ex);
                }
            }
        }
        return null;
    }
}