/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.impl.file;

import java.util.Hashtable;

import java.util.Vector;

import com.nokia.mj.impl.rt.support.ApplicationInfo;

public class FileAccessHelper implements FileConstants

{

    public static int PATHS_EQUAL = 0;

    public static int PATHS_NO_MATCH = 1;

    public static int PATH_ABOVEIN_HIERARCHY = 2;

    public static int PATH_BELOWIN_HIERARCHY = 3;

    private static String PATH_PRIVATE = "private";

    private static String PATH_SYSTEM = "system";

    private static String[] iRestrictedPathList;

    private static String[] iForbiddenPathList;

    static

    {

        // Populate forbidden path list.

        Vector forbidden = FileSystemUtils.getForbiddenPaths();

        iForbiddenPathList = new String[forbidden.size()];

        for (int index = 0; index < forbidden.size(); index++)

        {

            iForbiddenPathList[index] = (String) forbidden.elementAt(index);

        }

        // Populate restricted path list.

        Vector restricted = FileSystemUtils.getRestrictedPaths();

        iRestrictedPathList = new String[restricted.size() + 1];

        for (int index = 0; index < restricted.size(); index++)

        {

            iRestrictedPathList[index] = (String) restricted.elementAt(index);

        }

        // Add midlet's private directory also to restricted path list.

        iRestrictedPathList[restricted.size()] = FileSystemUtils

                .getAppPrivateDir();

    }

    /**

     * Checks to see if the application has access to a specific path.

     *

     * @param aPath

     *            path which the application is trying to access.

     * @param aIntent

     *            mode in which the application wants to access the target.

     * @param aDomain

     *            domain of the application

     * @param aIsOpening

     *            if the operation being performed is equivalent to opening a

     *            connection.

     * @return true in case access is allowed. False otherwise

     */

    public static boolean accessAllowed(String aPath, String aIntent,

                                        String aDomain, boolean aIsOpening)

    {

        FileLogger.Log("FileAccessHelper.accessAllowed: Checking access: \n");

        if (isHomeDir(aPath))

        {

            return true;

        }

        if (isForbidden(aPath))

        {

            return false;

        }

        if (isIllegalAccessToRestrictedDir(aPath, aIntent, aIsOpening, aDomain))

        {

            return false;

        }

        if (aDomain.equals(ApplicationInfo.MANUFACTURER_DOMAIN))

        {

            return manufacturerDomainChecks(aPath, aIntent, aIsOpening);

        }

        else

        {

            return otherDomainChecks(aPath, aIntent, aIsOpening);

        }

    }

    /**

     * To be used in case of list. If list is done on a directory that is equal

     * to, or higher in path hierarchy than one of the restricted paths, then we

     * need to check for access for all files, if not, then no need.

     */

    public static boolean isDirRestricted(String aPath)

    {

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            int matchResult = matchPaths(aPath, iRestrictedPathList[index]);

            if ((matchResult != PATHS_NO_MATCH)

                    && (matchResult != PATH_BELOWIN_HIERARCHY))

            {

                return true;

            }

        }

        return false;

    }

    /**

     * Checks to see if the path being accessed in forbidden.

     *

     * @param aPath

     *            path being accessed

     * @return true in case the path is forbidden, false otherwise

     */

    private static boolean isForbidden(String aPath)

    {

        for (int index = 0; index < iForbiddenPathList.length; index++)

        {

            int matchPathResult = matchPaths(aPath, iForbiddenPathList[index]);

            // Forbidden paths should match exactly or should be such that the

            // path must be lower in hierarchy.

            // Example: e:/system is forbidden, e:/ is not.

            // e:/system is forbidden, e:/system/dir is also forbidden

            if ((matchPathResult == PATHS_EQUAL)

                    || (matchPathResult == PATH_BELOWIN_HIERARCHY))

            {

                return true;

            }

        }

        return false;

    }

    /**

     * Checks if the access to restricted paths is being made in correct intent

     * based on the domain.

     *

     * @param aPath

     *            path of the file/directory being accessed

     * @param aIntent

     *            intent with which it is being accessed (read or write)

     * @param aOpening

     *            set to true in case it is being used by Connector.open or

     *            setFileConnection. Both are considered as open and not as

     *            acutal read or write operations.

     * @param aDomain

     *            domain of the application.

     * @return true in case there is an access violation, false if the access is

     *         allowed.

     */

    public static boolean isIllegalAccessToRestrictedDir(String aPath,

            String aIntent, boolean aOpening, String aDomain)

    {

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            int matchResult = matchPaths(aPath, iRestrictedPathList[index]);

            if ((matchResult != PATHS_NO_MATCH)

                    && (matchResult != PATH_BELOWIN_HIERARCHY))

            {

                if (aIntent.equals(INTENT_WRITE)

                        || aIntent.equals(INTENT_READ_WRITE))

                {

                    if (!aOpening)

                    {

                        return true;

                    }

                }

            }

        }

        return false;

    }

    /**

     * Performs manufacturer domain specific checks. Manufacturer domain apps

     * are not allowed to access any path in C:/private apart from its private

     * directory. Other checks are forbidden directories and restricted paths.

     * This is done before (accessAllowed()) So, no need to check once again.

     *

     * @param aPath

     *            path which is being accessed

     * @param aIntent

     *            intent with which access is being made. read, write

     * @param aIsOpening

     *            true in case its an open operation (open, setFileConnection)

     * @return true in case access is allowed. false otherwise.

     */

    public static boolean manufacturerDomainChecks(String aPath,

            String aIntent, boolean aIsOpening)

    {

        // Check if it is private directory.

        if (aPath.indexOf(PATH_PRIVATE) == 3)

        {

            if (matchPaths(aPath, FileSystemUtils.getAppPrivateDir()) == PATHS_NO_MATCH)

            {

                return false;

            }

        }

        return true;

    }

    /**

     * Performs domains other than manufacturer domain.

     *

     * @param aPath

     *            path which is being accessed

     * @param aIntent

     *            intent with which access is being made. read, write

     * @param aIsOpening

     *            true in case its an open operation (open, setFileConnection)

     * @return true in case access is allowed. false otherwise.

     */

    private static boolean otherDomainChecks(String aPath, String aIntent,

            boolean aIsOpening)

    {

        if (aPath.length() < 3)

        {

            // Path will be valid. This will be only in case file:///c: is given

            aPath += "/";

        }

        String rom = FileSystemUtils.getRomDrive().toLowerCase()

                     .substring(0, 2);

        String temp = FileSystemUtils.getTemporaryDrive().toLowerCase()

                      .substring(0, 2);

        if (aPath.toLowerCase().startsWith(rom)

                || aPath.toLowerCase().startsWith(temp))

        {

            return false;

        }

        // Other domains can access only below restricted paths or

        // in other drives.

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            int matchResult = matchPaths(aPath, iRestrictedPathList[index]);

            if ((matchResult != PATH_BELOWIN_HIERARCHY)

                    && (matchResult != PATHS_NO_MATCH))

            {

                if ((!aIntent.equals(INTENT_READ)) && (!aIsOpening))

                {

                    // Anything other than read operation on par or above

                    // restricted path hierarchy is not allowed when not opening

                    return false;

                }

            }

        }

        if (partialMatchWithRestrictedPaths(aPath))

        {

            return false;

        }

        return true;

    }

    private static boolean partialMatchWithRestrictedPaths(String aPath)

    {

        String path1 = aPath;

        boolean initialNoMatch = true;

        // Partial match is only when path is not a substring initially,

        // but when stripped, becomes a substring of one of the restricted paths

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            int matchResult = matchPaths(aPath, iRestrictedPathList[index]);

            if (matchResult == PATH_BELOWIN_HIERARCHY

                    || matchResult == PATH_ABOVEIN_HIERARCHY

                    || matchResult == PATHS_EQUAL)

            {

                return false;

            }

        }

        if (path1.length() > 3)

        {

            path1 = path1.substring(0, path1.lastIndexOf('/'));

        }

        // path1 is stripped to know in case the file is being created inside

        // root.

        while (path1.length() > 3)

        {

            for (int index = 0; index < iRestrictedPathList.length; index++)

            {

                if (iRestrictedPathList[index].toLowerCase().startsWith(

                            path1.toLowerCase()))

                {

                    return true;

                }

            }

            path1 = path1.substring(0, path1.lastIndexOf('/'));

        }

        // C:/data/somefile should be matched with c:/data/images,c:/data/videos

        // and must return true but c:/data or c:/ must not return as true

        return false;

    }

    /**

     * Resolves a path to a one of the following categories:

     *

     * <pre>

     * PUBLIC_DIRS - C:/Data/Images

     *               C:/Data/Videos

     *               C:/Data/Graphics

     *               C:/Data/Sounds

     *               C:/Data/Music

     *               C:/Data/Recordings and all files therein

     * HOME_DIR - App's private directory

     * PRIVATE_USER_FILES - All files and directories higher in path hierarchy

     *                      of PUBLIC_DIRS

     * SYSTEM_FILES - Z drive

     * </pre>

     *

     * @param aPath

     *            path that has to be mapped to a particular category.

     * @return category of the path specified.<br/> One of the following:

     *         SYSTEM_FILES, PRIVATE_USER_FILES, PUBLIC_DIRS, HOME_DIR

     */

    public static String getCategory(String aPath)

    {

        FileLogger.Log("+ FileAccessHelper: getCategory: " + aPath);

        // SYSTEM_FILES, PRIVATE_USER_FILES, PUBLIC_DIRS, HOME_DIR

        if (aPath.equals(SYSTEM_FILES) || aPath.equals(PRIVATE_USER_FILES)

                || aPath.equals(PUBLIC_DIRS) || aPath.equals(HOME_DIR)

                || aPath.equals(RESTRICTED_PUBLIC_FILES))

        {

            // if it is already mapped

            FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                           + aPath);

            return aPath;

        }

        if (aPath.equals(""))

        {

            // Used in case of FileSystemRegistry

            return PUBLIC_DIRS;

        }

        // First check for Home directory. Restricted paths list contains

        // app's private directory too.

        if (isHomeDir(aPath))

        {

            return HOME_DIR;

        }

        int matchResult = PATHS_NO_MATCH;

        // Paths below restricted paths in hierarchy are part of Public files

        // Paths above in hierarchy are part of private used files.

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            matchResult = matchPaths(aPath, iRestrictedPathList[index]);

            if (PATH_BELOWIN_HIERARCHY == matchResult)

            {

                FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                               + PUBLIC_DIRS);

                return PUBLIC_DIRS;

            }

            if (PATHS_EQUAL == matchResult)

            {

                return PUBLIC_DIRS;

            }

            // Do we need this at all? Restricted PUBLIC Files can be removed

            if (PATH_ABOVEIN_HIERARCHY == matchResult)

            {

                FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                               + PUBLIC_DIRS);

                return PUBLIC_DIRS;

            }

        }

        String rom = FileSystemUtils.getRomDrive().toLowerCase()

                     .substring(0, 2);

        String temp = FileSystemUtils.getTemporaryDrive().toLowerCase()

                      .substring(0, 2);

        if (aPath.toLowerCase().startsWith(rom)

                || aPath.toLowerCase().startsWith(temp))

        {

            FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                           + SYSTEM_FILES);

            return SYSTEM_FILES;

        }

        else if (aPath.toLowerCase().startsWith(

                     FileSystemUtils.getDefaultRoot().toLowerCase()))

        {

            FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                           + RESTRICTED_PUBLIC_FILES);

            // It is however known that the default root of the device can

            // change.

            return RESTRICTED_PUBLIC_FILES;

        }

        else if ((aPath.toLowerCase().indexOf(PATH_PRIVATE) == 3)

                 || (aPath.toLowerCase().indexOf(PATH_SYSTEM) == 3))

        {

            FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                           + SYSTEM_FILES);

            return SYSTEM_FILES;

        }

        FileLogger.Log("- FileAccessHelper: getCategory: returning: "

                       + PUBLIC_DIRS);

        return PUBLIC_DIRS;

    }

    /**

     * Checks to see if the specified path is same as application's private

     * directory.

     */

    private static boolean isHomeDir(String aPath)

    {

        String appPrivateDir = FileSystemUtils.getAppPrivateDir();

        if (aPath.equalsIgnoreCase(appPrivateDir))

        {

            return true;

        }

        if (aPath.startsWith(appPrivateDir))

        {

            return true;

        }

        return false;

    }

    /**

     * Checks to see if a file/directory can be created within the specidied

     * path.

     *

     * @param aPath

     *            directory within which the application intends to create a

     *            file.

     * @param aDomain

     *            domain of the application

     * @return true in case access is allowed, false otherwise.

     */

    public static boolean isCreateAllowedWithinDir(String aPath, String aDomain)

    {

        if (aDomain.equals(ApplicationInfo.MANUFACTURER_DOMAIN))

        {

            return true;

        }

        boolean allowed = false;

        if (!aPath.startsWith(FileSystemUtils.getDefaultRoot()))

        {

            return true;

        }

        for (int index = 0; index < iRestrictedPathList.length; index++)

        {

            String path = iRestrictedPathList[index];

            int matchResult = matchPaths(aPath, path);

            // Domains other than manufacturer are allowed to create content

            // only within restricted directories.

            if ((PATHS_EQUAL == matchResult)

                    || (PATH_BELOWIN_HIERARCHY == matchResult))

            {

                allowed = true;

                break;

            }

        }

        return allowed;

    }

    /**

     * Tries to match paths. Returns how "path2" is related to "path1". Checks if

     * the path is above or below in path hierarchy. Also checks to see if paths

     * are same or are totally different.

     */

    private static int matchPaths(String aPath1, String aPath2)

    {

        // Strip trailing slash in case its present.

        String path1 = aPath1.endsWith("/") ? aPath1.substring(0, aPath1

                       .length() - 1) : aPath1;

        String path2 = aPath2.endsWith("/") ? aPath2.substring(0, aPath2

                       .length() - 1) : aPath2;

        // In case both paths are the same.

        if (path1.equalsIgnoreCase(path2))

        {

            return PATHS_EQUAL;

        }

        // Check if path1 is higher in path hierarchy

        if (path2.toLowerCase().startsWith(path1.toLowerCase()))

        {

            return PATH_ABOVEIN_HIERARCHY;

        }

        if (path1.toLowerCase().startsWith(path2.toLowerCase()))

        {

            return PATH_BELOWIN_HIERARCHY;

        }

        return PATHS_NO_MATCH;

    }

}