/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.jkernel;

import java.io.*;

import java.net.URLStreamHandlerFactory;

import java.net.URL;

import java.net.MalformedURLException;

import java.security.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.jar.*;

import java.util.zip.*;

import sun.misc.BootClassLoaderHook;

import sun.misc.Launcher;

import sun.misc.URLClassPath;

import sun.net.www.ParseUtil;

/**

 * Handles the downloading of additional JRE components.  The bootstrap class

 * loader automatically invokes DownloadManager when it comes across a resource

 * that can't be located.

 *

 *@author Ethan Nicholas

 */

public class DownloadManager extends BootClassLoaderHook {

    public static final String KERNEL_DOWNLOAD_URL_PROPERTY =

            "kernel.download.url";

    public static final String KERNEL_DOWNLOAD_ENABLED_PROPERTY =

            "kernel.download.enabled";

    public static final String KERNEL_DOWNLOAD_DIALOG_PROPERTY =

            "kernel.download.dialog";

    public static final String KERNEL_DEBUG_PROPERTY = "kernel.debug";

    // disables JRE completion when set to true, used as part of the build

    // process

    public static final String KERNEL_NOMERGE_PROPERTY = "kernel.nomerge";

    public static final String KERNEL_SIMULTANEOUS_DOWNLOADS_PROPERTY =

            "kernel.simultaneous.downloads";

    // used to bypass some problems with JAR entry modtimes not matching.

    // originally was set to zero, but apparently the epochs are different

    // for zip and pack so the pack/unpack cycle was causing the modtimes

    // to change.  With some recent changes to the reconstruction, I'm

    // not sure if this is actually necessary anymore.

    public static final int KERNEL_STATIC_MODTIME = 10000000;

    // indicates that bundles should be grabbed using getResource(), rather

    // than downloaded from a network path -- this is used during the build

    // process

    public static final String RESOURCE_URL = "internal-resource/";

    public static final String REQUESTED_BUNDLES_PATH = "lib" + File.separator +

            "bundles" + File.separator + "requested.list";

    private static final boolean disableDownloadDialog = "false".equals(

            System.getProperty(KERNEL_DOWNLOAD_DIALOG_PROPERTY));

    static boolean debug = "true".equals(

            System.getProperty(KERNEL_DEBUG_PROPERTY));

    // points to stderr in case we need to println before System.err is

    // initialized

    private static OutputStream errorStream;

    private static OutputStream logStream;

    static String MUTEX_PREFIX;

    static boolean complete;

    // 1 if jbroker started; 0 otherwise

    private static int _isJBrokerStarted = -1;

    // maps bundle names to URL strings

    private static Properties bundleURLs;

    public static final String JAVA_HOME = System.getProperty("java.home");

    public static final String USER_HOME = System.getProperty("user.home");

    public static final String JAVA_VERSION =

            System.getProperty("java.version");

    static final int BUFFER_SIZE = 2048;

    static volatile boolean jkernelLibLoaded = false;

    public static String DEFAULT_DOWNLOAD_URL =

        "http://javadl.sun.com/webapps/download/GetList/"

        +  System.getProperty("java.runtime.version") + "-kernel/windows-i586/";

    private static final String CUSTOM_PREFIX = "custom";

    private static final String KERNEL_PATH_SUFFIX = "-kernel";

    public static final String JAR_PATH_PROPERTY = "jarpath";

    public static final String SIZE_PROPERTY = "size";

    public static final String DEPENDENCIES_PROPERTY = "dependencies";

    public static final String INSTALL_PROPERTY = "install";

    private static boolean reportErrors = true;

    static final int ERROR_UNSPECIFIED = 0;

    static final int ERROR_DISK_FULL   = 1;

    static final int ERROR_MALFORMED_BUNDLE_PROPERTIES = 2;

    static final int ERROR_DOWNLOADING_BUNDLE_PROPERTIES = 3;

    static final int ERROR_MALFORMED_URL = 4;

    static final int ERROR_RETRY_CANCELLED = 5;

    static final int ERROR_NO_SUCH_BUNDLE = 6;

    // tracks whether the current thread is downloading.  A count of zero means

    // not currently downloading, >0 means the current thread is downloading or

    // installing a bundle.

    static ThreadLocal<Integer> downloading = new ThreadLocal<Integer>() {

        protected Integer initialValue() {

            return 0;

        }

    };

    private static File[] additionalBootStrapPaths = { };

    private static String[] bundleNames;

    private static String[] criticalBundleNames;

    private static String downloadURL;

    private static boolean visitorIdDetermined;

    private static String visitorId;

    /**

     * File and path where the Check value properties are gotten from

     */

    public static String CHECK_VALUES_FILE = "check_value.properties";

    static String CHECK_VALUES_DIR = "sun/jkernel/";

    static String CHECK_VALUES_PATH = CHECK_VALUES_DIR + CHECK_VALUES_FILE;

    /**

     * The contents of the bundle.properties file, which contains various

     * information about individual bundles.

     */

    private static Map<String, Map<String, String>> bundleProperties;

    /**

     * The contents of the resource_map file, which maps resources

     * to their respective bundles.

     */

    private static Map<String, String> resourceMap;

    /**

     * The contents of the file_map file, which maps files

     * to their respective bundles.

     */

    private static Map<String, String> fileMap;

    private static boolean extDirDetermined;

    private static boolean extDirIncluded;

    static {

        AccessController.doPrivileged(new PrivilegedAction() {

            public Object run() {

                if (debug)

                    println("DownloadManager startup");

                 // this mutex is global and will apply to all different

                // version of java kernel installed on the local machine

                MUTEX_PREFIX = "jkernel";

                boolean downloadEnabled = !"false".equals(

                        System.getProperty(KERNEL_DOWNLOAD_ENABLED_PROPERTY));

                complete = !getBundlePath().exists() ||

                        !downloadEnabled;

                // only load jkernel.dll if we are not "complete".

                // DownloadManager will be loaded during build time, before

                // jkernel.dll is built.  We only need to load jkernel.dll

                // when DownloadManager needs to download something, which is

                // not necessary during build time

                if (!complete) {

                    loadJKernelLibrary();

                    log("Log opened");

                    if (isWindowsVista()) {

                        getLocalLowTempBundlePath().mkdirs();

                    }

                    new Thread() {

                        public void run() {

                            startBackgroundDownloads();

                        }

                    }.start();

                    try {

                        String dummyPath;

                        if (isWindowsVista()) {

                            dummyPath = USER_HOME +

                                    "\\appdata\\locallow\\dummy.kernel";

                        } else {

                            dummyPath = USER_HOME + "\\dummy.kernel";

                        }

                        File f = new File(dummyPath);

                        FileOutputStream out = new FileOutputStream(f, true);

                        out.close();

                        f.deleteOnExit();

                    } catch (IOException e) {

                        log(e);

                    }

                    // end of warm up code

                    new Thread("BundleDownloader") {

                        public void run() {

                            downloadRequestedBundles();

                        }

                    }.start();

                }

                return null;

            }

        });

    }

    static synchronized void loadJKernelLibrary() {

        if (!jkernelLibLoaded) {

            try {

                System.loadLibrary("jkernel");

                jkernelLibLoaded = true;

                debug = getDebugProperty();

            } catch (Exception e) {

                throw new Error(e);

            }

        }

    }

    static String appendTransactionId(String url) {

        StringBuilder result = new StringBuilder(url);

        String visitorId = DownloadManager.getVisitorId();

        if (visitorId != null) {

            if (url.indexOf("?") == -1)

                result.append('?');

            else

                result.append('&');

            result.append("transactionId=");

            result.append(DownloadManager.getVisitorId());

        }

        return result.toString();

    }

    /**

     * Returns the URL for the directory from which bundles should be

     * downloaded.

     */

    static synchronized String getBaseDownloadURL() {

        if (downloadURL == null) {

            log("Determining download URL...");

            loadJKernelLibrary();

            /*

             * First check if system property has been set - system

             * property should take over registry key setting.

             */

            downloadURL = System.getProperty(

                          DownloadManager.KERNEL_DOWNLOAD_URL_PROPERTY);

            log("System property kernel.download.url = " + downloadURL);

            /*

             * Now check if registry key has been set

             */

            if (downloadURL == null){

                downloadURL = getUrlFromRegistry();

                log("getUrlFromRegistry = " + downloadURL);

            }

            /*

             * Use default download url

             */

            if (downloadURL == null)

                downloadURL = DEFAULT_DOWNLOAD_URL;

            log("Final download URL: " + downloadURL);

        }

        return downloadURL;

    }

    /**

     * Loads a file representing a node tree.  The format is described in

     * SplitJRE.writeTreeMap().  The node paths (such as

     * core/java/lang/Object.class) are interpreted with the root node as the

     * value and the remaining nodes as

     * the key, so the mapping for this entry would be java/lang/Object.class =

     * core.

     */

    static Map<String, String> readTreeMap(InputStream rawIn)

            throws IOException {

        // "token level" refers to the 0-31 byte that occurs prior to every

        // token in the stream, and would be e.g. <0> core <1> java <2> lang

        // <3> Object.class <3> String.class, which gives us two mappings:

        // java/lang/Object.class = core, and java/lang/String.class = core.

        // See the format description in SplitJRE.writeTreeMap for more details.

        Map<String, String> result = new HashMap<String, String>();

        InputStream in = new BufferedInputStream(rawIn);

        // holds the current token sequence,

        // e.g. {"core", "java", "lang", "Object.class"}

        List<String> tokens = new ArrayList<String>();

        StringBuilder currentToken = new StringBuilder();

        for (;;) {

            int c = in.read();

            if (c  == -1) // eof

                break;

            if (c < 32) { // new token level

                if (tokens.size() > 0) {

                    // replace the null at the end of the list with the token

                    // we just finished reading

                    tokens.set(tokens.size() - 1, currentToken.toString());

                }

                currentToken.setLength(0);

                if (c > tokens.size()) {

                    // can't increase by more than one token level at a step

                    throw new InternalError("current token level is " +

                            (tokens.size() - 1) + " but encountered token " +

                            "level " + c);

                }

                else if (c == tokens.size()) {

                    // token level increased by 1; this means we are still

                    // adding tokens for the current mapping -- e.g. we have

                    // read "core", "java", "lang" and are just about to read

                    // "Object.class"

                    // add a placeholder for the new token

                    tokens.add(null);

                }

                else {

                    // we just stayed at the same level or backed up one or more

                    // token levels; this means that the current sequence is

                    // complete and needs to be added to the result map

                    StringBuilder key = new StringBuilder();

                    // combine all tokens except the first into a single string

                    for (int i = 1; i < tokens.size(); i++) {

                        if (i > 1)

                            key.append('/');

                        key.append(tokens.get(i));

                    }

                    // map the combined string to the first token, e.g.

                    // java/lang/Object.class = core

                    result.put(key.toString(), tokens.get(0));

                    // strip off tokens until we get back to the current token

                    // level

                    while (c < tokens.size())

                        tokens.remove(c);

                    // placeholder for upcoming token

                    tokens.add(null);

                }

            }

            else if (c < 254) // character

                currentToken.append((char) c);

            else if (c == 255)

                currentToken.append(".class");

            else { // out-of-band value

                throw new InternalError("internal error processing " +

                        "resource_map (can't-happen error)");

            }

        }

        if (tokens.size() > 0) // add token we just finished reading

            tokens.set(tokens.size() - 1, currentToken.toString());

        StringBuilder key = new StringBuilder();

        // add the last entry to the map

        for (int i = 1; i < tokens.size(); i++) {

            if (i > 1)

                key.append('/');

            key.append(tokens.get(i));

        }

        if (!tokens.isEmpty())

            result.put(key.toString(), tokens.get(0));

        in.close();

        return Collections.unmodifiableMap(result);

    }

    /**

     * Returns the contents of the resource_map file, which maps

     * resources names to their respective bundles.

     */

    public static Map<String, String> getResourceMap() throws IOException {

        if (resourceMap == null) {

            InputStream in = DownloadManager.class.getResourceAsStream("resource_map");

            if (in != null) {

                in = new BufferedInputStream(in);

                try {

                    resourceMap = readTreeMap(in);

                    in.close();

                }

                catch (IOException e) {

                    // turns out we can be returned a broken stream instead of

                    // just null

                    resourceMap = new HashMap<String, String>();

                    complete = true;

                    log("Can't find resource_map, forcing complete to true");

                }

                in.close();

            }

            else {

                resourceMap = new HashMap<String, String>();

                complete = true;

                log("Can't find resource_map, forcing complete to true");

            }

            for (int i = 1; ; i++) { // run through the numbered custom bundles

                String name = CUSTOM_PREFIX + i;

                File customPath = new File(getBundlePath(), name + ".jar");

                if (customPath.exists()) {

                    JarFile custom = new JarFile(customPath);

                    Enumeration entries = custom.entries();

                    while (entries.hasMoreElements()) {

                        JarEntry entry = (JarEntry) entries.nextElement();

                        if (!entry.isDirectory())

                            resourceMap.put(entry.getName(), name);

                    }

                }

                else

                    break;

            }

        }

        return resourceMap;

    }

    /**

     * Returns the contents of the file_map file, which maps

     * file names to their respective bundles.

     */

    public static Map<String, String> getFileMap() throws IOException {

        if (fileMap == null) {

            InputStream in = DownloadManager.class.getResourceAsStream("file_map");

            if (in != null) {

                in = new BufferedInputStream(in);

                try {

                    fileMap = readTreeMap(in);

                    in.close();

                }

                catch (IOException e) {

                    // turns out we can be returned a broken stream instead of

                    // just null

                    fileMap = new HashMap<String, String>();

                    complete = true;

                    log("Can't find file_map, forcing complete to true");

                }

                in.close();

            }

            else {

                fileMap = new HashMap<String, String>();

                complete = true;

                log("Can't find file_map, forcing complete to true");

            }

        }

        return fileMap;

    }

    /**

     * Returns the contents of the bundle.properties file, which maps

     * bundle names to a pipe-separated list of their properties.  Properties

     * include:

     * jarpath - By default, the JAR files (unpacked from classes.pack in the

     *           bundle) are stored under lib/bundles.  The jarpath property

     *           overrides this default setting, causing the JAR to be unpacked

     *           at the specified location.  This is used to preserve the

     *           identity of JRE JAR files such as lib/deploy.jar.

     * size    - The size of the download in bytes.

     */

    private static synchronized Map<String, Map<String, String>> getBundleProperties()

            throws IOException {

        if (bundleProperties == null) {

            InputStream in = DownloadManager.class.getResourceAsStream("bundle.properties");

            if (in == null) {

                complete = true;

                log("Can't find bundle.properties, forcing complete to true");

                return null;

            }

            in = new BufferedInputStream(in);

            Properties tmp = new Properties();

            tmp.load(in);

            bundleProperties = new HashMap<String, Map<String, String>>();

            for (Map.Entry e : tmp.entrySet()) {

                String key = (String) e.getKey();

                String[] properties = ((String) e.getValue()).split("\\|");

                Map<String, String> map = new HashMap<String, String>();

                for (String entry : properties) {

                    int equals = entry.indexOf("=");

                    if (equals == -1)

                        throw new InternalError("error parsing bundle.properties: " +

                            entry);

                    map.put(entry.substring(0, equals).trim(),

                        entry.substring(equals + 1).trim());

                }

                bundleProperties.put(key, map);

            }

            in.close();

        }

        return bundleProperties;

    }

    /**

     * Returns a single bundle property value loaded from the bundle.properties

     * file.