UNCPathUtilities.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2016 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.coreutils;

import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;

public class UNCPathUtilities {

    private static Map<String, String> drives;
    private static final String MAPPED_DRIVES = "_mapped_drives.txt"; //NON-NLS
    private static final String TEMP_FOLDER = "TEMP"; //NON-NLS
    private static final String DATA_TRIGGER = "----------"; //NON-NLS
    private static final String OK_TXT = "OK"; //NON-NLS
    private static final String COLON = ":"; //NON-NLS
    private static final String UNC_PATH_START = "\\\\"; //NON-NLS
    private static final String C_DRIVE = "C:"; //NON-NLS
    private static final int DRIVE_LEN = 2;
    private static final int STARTING_OFFSET = 0;
    private static final int REPLACEMENT_SIZE = 2;
    private static final int FIRST_ITEM = 0;
    private final String nameString;

    public UNCPathUtilities() {
        // get UUID for this instance
        this.nameString = UUID.randomUUID().toString();
        drives = getMappedDrives();
    }

    synchronized public String mappedDriveToUNC(String inputPath) {
        if (inputPath != null) {
            // If it is a C:, do not attempt to convert. This is for the single-user case.
            if (inputPath.toUpperCase().startsWith(C_DRIVE)) {
                return null;
            }
            if (false == isUNC(inputPath)) {
                String uncPath = null;
                try {
                    String currentDrive = Paths.get(inputPath).getRoot().toString().substring(STARTING_OFFSET, REPLACEMENT_SIZE);
                    String uncMapping = drives.get(currentDrive.toUpperCase());
                    if (uncMapping != null) {
                        uncPath = uncMapping + inputPath.substring(REPLACEMENT_SIZE, inputPath.length());
                    }
                } catch (Exception ex) {
                    // Didn't work. Skip it.
                }
                return uncPath;
            } else {
                return inputPath;
            }
        } else {
            return null;
        }
    }

    synchronized public Path mappedDriveToUNC(Path inputPath) {
        if (inputPath != null) {
            String uncPath = UNCPathUtilities.this.mappedDriveToUNC(inputPath.toString());
            if (uncPath == null) {
                return null;
            } else {
                return Paths.get(uncPath);
            }
        } else {
            return null;
        }
    }

    synchronized public boolean isDriveMapped(Path inputPath) {
        if (inputPath != null) {
            return isDriveMapped(inputPath.toString());
        } else {
            return false;
        }
    }

    synchronized public boolean isDriveMapped(String inputPath) {
        if (inputPath != null) {
            String shortenedPath = inputPath.substring(STARTING_OFFSET, DRIVE_LEN);
            for (String s : drives.keySet()) {
                if (shortenedPath.equals(s)) {
                    return true;
                }
            }
        }
        return false;
    }

    synchronized public Path ipToHostName(Path inputPath) {
        if (inputPath != null) {
            return Paths.get(ipToHostName(inputPath.toString()));
        } else {
            return null;
        }
    }

    synchronized public String ipToHostName(String inputPath) {
        if (inputPath != null) {
            String result = null;
            try {
                if (isUNC(Paths.get(inputPath))) {
                    String potentialIP = Paths.get(inputPath.substring(REPLACEMENT_SIZE)).getName(FIRST_ITEM).toString();
                    String hostname = InetAddress.getByName(potentialIP).getHostName();
                    result = inputPath.replaceAll(potentialIP, hostname);
                }
            } catch (Exception ex) {
                // Could not resolve hostname for IP address, return null result
            }
            return result;
        } else {
            return null;
        }
    }

    synchronized public static boolean isUNC(Path inputPath) {
        if (inputPath != null) {
            return isUNC(inputPath.toString());
        } else {
            return false;
        }
    }

    synchronized public static boolean isUNC(String inputPath) {
        if (inputPath != null) {
            return inputPath.startsWith(UNC_PATH_START);
        } else {
            return false;
        }
    }

    synchronized public void rescanDrives() {
        drives = getMappedDrives();
    }

    synchronized private Map<String, String> getMappedDrives() {
        Map<String, String> driveMap = new HashMap<>();

        if (PlatformUtil.isWindowsOS() == false) {
            return driveMap;
        }

        File mappedDrive = Paths.get(System.getenv(TEMP_FOLDER), nameString + MAPPED_DRIVES).toFile();
        try {
            Files.deleteIfExists(mappedDrive.toPath());
            ProcessBuilder builder = new ProcessBuilder("cmd", "/c", "net", "use"); //NON-NLS
            builder.redirectOutput(mappedDrive);
            builder.redirectError(mappedDrive);
            Process p = builder.start(); // throws IOException
            p.waitFor(10, TimeUnit.SECONDS);
            try (Scanner scanner = new Scanner(mappedDrive)) {
                // parse the data and place it in the hashmap
                while (scanner.hasNext()) {
                    String entry1 = scanner.next();
                    if (entry1.startsWith(DATA_TRIGGER)) {
                        continue;
                    }
                    String entry2 = scanner.next();
                    if (entry2.startsWith(DATA_TRIGGER)) {
                        continue;
                    }
                    String entry3 = scanner.next();
                    if (entry3.startsWith(DATA_TRIGGER)) {
                        continue;
                    }
                    scanner.nextLine();
                    if (entry1.length() == DRIVE_LEN && !entry1.equals(OK_TXT) && entry1.endsWith(COLON)) {
                        driveMap.put(entry1, entry2); // if there was no leading status, populate drive
                    } else if (entry2.length() == DRIVE_LEN && entry2.endsWith(COLON)) {
                        driveMap.put(entry2, entry3); // if there was a leading status, populate drive
                    }
                }
            }
        } catch (IOException | InterruptedException | NoSuchElementException | IllegalStateException ex) {
            // if we couldn't do it, no big deal  
            Logger.getLogger(UNCPathUtilities.class.getName()).log(Level.WARNING, "Unable to parse 'net use' output", ex); //NON-NLS
        } finally {
            try {
                Files.deleteIfExists(mappedDrive.toPath());
            } catch (IOException ex) {
                // if we couldn't do it, no big deal  
            }
        }
        return driveMap;
    }
    
    synchronized public String convertPathToUNC(String indexDir) {
        // if we can check for UNC paths, do so, otherwise just return the indexDir
        String result = mappedDriveToUNC(indexDir);
        if (result == null) {
            rescanDrives();
            result = mappedDriveToUNC(indexDir);
        }
        if (result == null) {
            return indexDir;
        }
        return result;
    }
}