/*

 * 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 java.util.prefs;

import java.util.*;

import java.io.*;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.security.PrivilegedExceptionAction;

import java.security.PrivilegedActionException;

import sun.util.logging.PlatformLogger;

/**

 * Preferences implementation for Unix.  Preferences are stored in the file

 * system, with one directory per preferences node.  All of the preferences

 * at each node are stored in a single file.  Atomic file system operations

 * (e.g. File.renameTo) are used to ensure integrity.  An in-memory cache of

 * the "explored" portion of the tree is maintained for performance, and

 * written back to the disk periodically.  File-locking is used to ensure

 * reasonable behavior when multiple VMs are running at the same time.

 * (The file lock is obtained only for sync(), flush() and removeNode().)

 *

 * @author  Josh Bloch

 * @see     Preferences

 * @since   1.4

 */

class FileSystemPreferences extends AbstractPreferences {

    /**

     * Sync interval in seconds.

     */

    private static final int SYNC_INTERVAL = Math.max(1,

        Integer.parseInt(

            AccessController.doPrivileged(

                new sun.security.action.GetPropertyAction(

                    "java.util.prefs.syncInterval", "30"))));

    /**

     * Returns logger for error messages. Backing store exceptions are logged at

     * WARNING level.

     */

    private static PlatformLogger getLogger() {

        return PlatformLogger.getLogger("java.util.prefs");

    }

    /**

     * Directory for system preferences.

     */

    private static File systemRootDir;

    /*

     * Flag, indicating whether systemRoot  directory is writable

     */

    private static boolean isSystemRootWritable;

    /**

     * Directory for user preferences.

     */

    private static File userRootDir;

    /*

     * Flag, indicating whether userRoot  directory is writable

     */

    private static boolean isUserRootWritable;

   /**

     * The user root.

     */

    static Preferences userRoot = null;

    static synchronized Preferences getUserRoot() {

        if (userRoot == null) {

            setupUserRoot();

            userRoot = new FileSystemPreferences(true);

        }

        return userRoot;

    }

    private static void setupUserRoot() {

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                userRootDir =

                      new File(System.getProperty("java.util.prefs.userRoot",

                      System.getProperty("user.home")), ".java/.userPrefs");

                // Attempt to create root dir if it does not yet exist.

                if (!userRootDir.exists()) {

                    if (userRootDir.mkdirs()) {

                        try {

                            chmod(userRootDir.getCanonicalPath(), USER_RWX);

                        } catch (IOException e) {

                            getLogger().warning("Could not change permissions" +

                                " on userRoot directory. ");

                        }

                        getLogger().info("Created user preferences directory.");

                    }

                    else

                        getLogger().warning("Couldn't create user preferences" +

                        " directory. User preferences are unusable.");

                }

                isUserRootWritable = userRootDir.canWrite();

                String USER_NAME = System.getProperty("user.name");

                userLockFile = new File (userRootDir,".user.lock." + USER_NAME);

                userRootModFile = new File (userRootDir,

                                               ".userRootModFile." + USER_NAME);

                if (!userRootModFile.exists())

                try {

                    // create if does not exist.

                    userRootModFile.createNewFile();

                    // Only user can read/write userRootModFile.

                    int result = chmod(userRootModFile.getCanonicalPath(),

                                                               USER_READ_WRITE);

                    if (result !=0)

                        getLogger().warning("Problem creating userRoot " +

                            "mod file. Chmod failed on " +

                             userRootModFile.getCanonicalPath() +

                             " Unix error code " + result);

                } catch (IOException e) {

                    getLogger().warning(e.toString());

                }

                userRootModTime = userRootModFile.lastModified();

                return null;

            }

        });

    }

    /**

     * The system root.

     */

    static Preferences systemRoot;

    static synchronized Preferences getSystemRoot() {

        if (systemRoot == null) {

            setupSystemRoot();

            systemRoot = new FileSystemPreferences(false);

        }

        return systemRoot;

    }

    private static void setupSystemRoot() {

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                String systemPrefsDirName =

                  System.getProperty("java.util.prefs.systemRoot","/etc/.java");

                systemRootDir =

                     new File(systemPrefsDirName, ".systemPrefs");

                // Attempt to create root dir if it does not yet exist.

                if (!systemRootDir.exists()) {

                    // system root does not exist in /etc/.java

                    // Switching  to java.home

                    systemRootDir =

                                  new File(System.getProperty("java.home"),

                                                            ".systemPrefs");

                    if (!systemRootDir.exists()) {

                        if (systemRootDir.mkdirs()) {

                            getLogger().info(

                                "Created system preferences directory "

                                + "in java.home.");

                            try {

                                chmod(systemRootDir.getCanonicalPath(),

                                                          USER_RWX_ALL_RX);

                            } catch (IOException e) {

                            }

                        } else {

                            getLogger().warning("Could not create "

                                + "system preferences directory. System "

                                + "preferences are unusable.");

                        }

                    }

                }

                isSystemRootWritable = systemRootDir.canWrite();

                systemLockFile = new File(systemRootDir, ".system.lock");

                systemRootModFile =

                               new File (systemRootDir,".systemRootModFile");

                if (!systemRootModFile.exists() && isSystemRootWritable)

                try {

                    // create if does not exist.

                    systemRootModFile.createNewFile();

                    int result = chmod(systemRootModFile.getCanonicalPath(),

                                                          USER_RW_ALL_READ);

                    if (result !=0)

                        getLogger().warning("Chmod failed on " +

                               systemRootModFile.getCanonicalPath() +

                              " Unix error code " + result);

                } catch (IOException e) { getLogger().warning(e.toString());

                }

                systemRootModTime = systemRootModFile.lastModified();

                return null;

            }

        });

    }

    /**

     * Unix user write/read permission

     */

    private static final int USER_READ_WRITE = 0600;

    private static final int USER_RW_ALL_READ = 0644;

    private static final int USER_RWX_ALL_RX = 0755;

    private static final int USER_RWX = 0700;

    /**

     * The lock file for the user tree.

     */

    static File userLockFile;

    /**

     * The lock file for the system tree.

     */

    static File systemLockFile;

    /**

     * Unix lock handle for userRoot.

     * Zero, if unlocked.

     */

    private static int userRootLockHandle = 0;

    /**

     * Unix lock handle for systemRoot.

     * Zero, if unlocked.

     */

    private static int systemRootLockHandle = 0;

    /**

     * The directory representing this preference node.  There is no guarantee

     * that this directory exits, as another VM can delete it at any time

     * that it (the other VM) holds the file-lock.  While the root node cannot

     * be deleted, it may not yet have been created, or the underlying

     * directory could have been deleted accidentally.

     */

    private final File dir;

    /**

     * The file representing this preference node's preferences.

     * The file format is undocumented, and subject to change

     * from release to release, but I'm sure that you can figure

     * it out if you try real hard.

     */

    private final File prefsFile;

    /**

     * A temporary file used for saving changes to preferences.  As part of

     * the sync operation, changes are first saved into this file, and then

     * atomically renamed to prefsFile.  This results in an atomic state

     * change from one valid set of preferences to another.  The

     * the file-lock is held for the duration of this transformation.

     */

    private final File tmpFile;

    /**

     * File, which keeps track of global modifications of userRoot.

     */

    private static  File userRootModFile;

    /**

     * Flag, which indicated whether userRoot was modified by another VM

     */

    private static boolean isUserRootModified = false;

    /**

     * Keeps track of userRoot modification time. This time is reset to

     * zero after UNIX reboot, and is increased by 1 second each time

     * userRoot is modified.

     */

    private static long userRootModTime;

    /*

     * File, which keeps track of global modifications of systemRoot

     */

    private static File systemRootModFile;

    /*

     * Flag, which indicates whether systemRoot was modified by another VM

     */

    private static boolean isSystemRootModified = false;

    /**

     * Keeps track of systemRoot modification time. This time is reset to

     * zero after system reboot, and is increased by 1 second each time

     * systemRoot is modified.

     */

    private static long systemRootModTime;

    /**

     * Locally cached preferences for this node (includes uncommitted

     * changes).  This map is initialized with from disk when the first get or

     * put operation occurs on this node.  It is synchronized with the

     * corresponding disk file (prefsFile) by the sync operation.  The initial

     * value is read *without* acquiring the file-lock.

     */

    private Map<String, String> prefsCache = null;

    /**

     * The last modification time of the file backing this node at the time

     * that prefCache was last synchronized (or initially read).  This

     * value is set *before* reading the file, so it's conservative; the

     * actual timestamp could be (slightly) higher.  A value of zero indicates

     * that we were unable to initialize prefsCache from the disk, or

     * have not yet attempted to do so.  (If prefsCache is non-null, it

     * indicates the former; if it's null, the latter.)

     */

    private long lastSyncTime = 0;

   /**

    * Unix error code for locked file.

    */

    private static final int EAGAIN = 11;

   /**

    * Unix error code for denied access.

    */

    private static final int EACCES = 13;

    /* Used to interpret results of native functions */

    private static final int LOCK_HANDLE = 0;

    private static final int ERROR_CODE = 1;

    /**

     * A list of all uncommitted preference changes.  The elements in this

     * list are of type PrefChange.  If this node is concurrently modified on

     * disk by another VM, the two sets of changes are merged when this node

     * is sync'ed by overwriting our prefsCache with the preference map last

     * written out to disk (by the other VM), and then replaying this change

     * log against that map.  The resulting map is then written back

     * to the disk.

     */

    final List<Change> changeLog = new ArrayList<>();

    /**

     * Represents a change to a preference.

     */

    private abstract class Change {

        /**

         * Reapplies the change to prefsCache.

         */

        abstract void replay();

    };

    /**

     * Represents a preference put.

     */

    private class Put extends Change {

        String key, value;

        Put(String key, String value) {

            this.key = key;

            this.value = value;

        }

        void replay() {

            prefsCache.put(key, value);

        }

    }

    /**

     * Represents a preference remove.

     */

    private class Remove extends Change {

        String key;

        Remove(String key) {

            this.key = key;

        }

        void replay() {

            prefsCache.remove(key);

        }

    }

    /**

     * Represents the creation of this node.

     */

    private class NodeCreate extends Change {

        /**

         * Performs no action, but the presence of this object in changeLog

         * will force the node and its ancestors to be made permanent at the

         * next sync.

         */

        void replay() {

        }

    }

    /**

     * NodeCreate object for this node.

     */

    NodeCreate nodeCreate = null;

    /**

     * Replay changeLog against prefsCache.

     */

    private void replayChanges() {

        for (int i = 0, n = changeLog.size(); i<n; i++)

            changeLog.get(i).replay();

    }

    private static Timer syncTimer = new Timer(true); // Daemon Thread

    static {

        // Add periodic timer task to periodically sync cached prefs

        syncTimer.schedule(new TimerTask() {

            public void run() {

                syncWorld();

            }

        }, SYNC_INTERVAL*1000, SYNC_INTERVAL*1000);

        // Add shutdown hook to flush cached prefs on normal termination

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                Runtime.getRuntime().addShutdownHook(new Thread() {

                    public void run() {

                        syncTimer.cancel();

                        syncWorld();

                    }

                });

                return null;

            }

        });

    }

    private static void syncWorld() {

        /*

         * Synchronization necessary because userRoot and systemRoot are

         * lazily initialized.

         */

        Preferences userRt;

        Preferences systemRt;

        synchronized(FileSystemPreferences.class) {

            userRt   = userRoot;

            systemRt = systemRoot;

        }

        try {

            if (userRt != null)

                userRt.flush();

        } catch(BackingStoreException e) {

            getLogger().warning("Couldn't flush user prefs: " + e);

        }

        try {

            if (systemRt != null)

                systemRt.flush();

        } catch(BackingStoreException e) {

            getLogger().warning("Couldn't flush system prefs: " + e);

        }

    }

    private final boolean isUserNode;

    /**

     * Special constructor for roots (both user and system).  This constructor

     * will only be called twice, by the static initializer.

     */

    private FileSystemPreferences(boolean user) {

        super(null, "");

        isUserNode = user;

        dir = (user ? userRootDir: systemRootDir);

        prefsFile = new File(dir, "prefs.xml");

        tmpFile   = new File(dir, "prefs.tmp");

    }

    /**

     * Construct a new FileSystemPreferences instance with the specified

     * parent node and name.  This constructor, called from childSpi,

     * is used to make every node except for the two //roots.

     */

    private FileSystemPreferences(FileSystemPreferences parent, String name) {

        super(parent, name);

        isUserNode = parent.isUserNode;

        dir  = new File(parent.dir, dirName(name));

        prefsFile = new File(dir, "prefs.xml");

        tmpFile  = new File(dir, "prefs.tmp");

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                newNode = !dir.exists();

                return null;

            }

        });

        if (newNode) {

            // These 2 things guarantee node will get wrtten at next flush/sync

            prefsCache = new TreeMap<>();

            nodeCreate = new NodeCreate();

            changeLog.add(nodeCreate);

        }

    }

    public boolean isUserNode() {

        return isUserNode;

    }

    protected void putSpi(String key, String value) {

        initCacheIfNecessary();

        changeLog.add(new Put(key, value));

        prefsCache.put(key, value);

    }