/*

* 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:  JNI Layer for FileUtility

 *

*/

#include <errno.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/param.h>

#include <sys/stat.h>

#include "logger.h"

#include "javajniutils.h"

#include "javacommonutils.h"

#include "fileextendedcommon.h" // To be removed once common utility is fixed

#include "fileutilities.h"

#include "com_nokia_mj_impl_fileutils_FileUtility.h"

using namespace std;

using namespace java::util;

using namespace java::fileutils;

using namespace java::fileutility;

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _exists

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1exists(

    JNIEnv *aJni, jclass, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::exists(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: exists caught exception. Return false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _getRealPath

 * Signature: (Ljava/lang/String;)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1getRealPath(

    JNIEnv *aJni, jclass, jstring aPath)

{

    std::wstring wName = L"";

    try

    {

        std::wstring path = FileUtil::jstringToWstring(aJni, aPath);

        char* utf8Name = JavaCommonUtils::wstringToUtf8(path);

        char resolvepath[PATH_MAX];

        char *rpath = NULL;

        rpath = realpath(utf8Name, resolvepath);

        delete[] utf8Name;

        utf8Name = NULL;

        if (rpath == NULL)

        {

            if ((errno!=ENOENT) && (errno != EACCES))

            {

                ELOG1(EJavaFile,"FileUtility: JNI: getRealPath: Unable to resolve. Throw IOException %d", errno);

                JniUtils::throwNewException(aJni, "java/io/IOException", "");

                return NULL;

            }

            else

            {

                return aPath;

            }

        }

        else

        {

            wName = JavaCommonUtils::utf8ToWstring(rpath);

        }

    }

    catch (...)

    {

        ELOG(EJavaFile, "FileUtility: JNI: getRealPath: Exception occurred. Returning empty");

    }

    jstring retValue = JniUtils::wstringToJstring(aJni, wName);

    return retValue;

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _availableSize

 * Signature: (Ljava/lang/String;)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1availableSize(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::availableSize(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: availableSize caught exception. Return -1");

        return -1;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _canRead

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1canRead(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::canRead(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: canRead caught exception. Return false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _canWrite

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1canWrite(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::canWrite(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: canWrite caught exception. Return false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _createNewDirectory

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1createNewDirectory(

    JNIEnv *aJni, jobject, jstring fileName)

{

    JELOG2(EJavaFile);

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        char* utf8Name = JavaCommonUtils::wstringToUtf8(name);

        int error = mkdir(utf8Name, 0777);

        delete[] utf8Name;

        if (error < 0)

        {

            ELOG2(

                EJavaFile,

                "FileUtility: JNI: createNewDirectory: Error: %d: Name: %S",

                errno, name.c_str());

            if ((EEXIST == errno))

            {

                // It already exists

                return false;

            }

            if ((EACCES == errno) || (EPERM == errno))

            {

                ELOG(EJavaFile,

                     "JNI: CreateNewDirectory: throwing sec exception");

                JniUtils::throwNewException(aJni,

                                            "java/lang/SecurityException", "Permission denied");

            }

            else

            {

                ELOG(EJavaFile, "JNI: CreateNewDirectory: ioexception");

                JniUtils::throwNewException(aJni, "java/io/IOException", "Unable to create directory");

            }

        }

        return true;

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "JNI: CreateNewDirectory: Exception occured returning false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _createNewFile

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1createNewFile(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        JELOG2(EJavaFile);

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        char* utf8Name = JavaCommonUtils::wstringToUtf8(name);

        //jboolean iscopy;

        //const char* utf8Name = (aJni->GetStringUTFChars(fileName, &iscopy));

        int fileDes = open(utf8Name, O_CREAT | O_EXCL, 0666);

        delete[] utf8Name;

        if (fileDes < 0)

        {

            WLOG1(EJavaFile, "FileUtility: JNI: createNewFile: Error: %d", errno);

            if ((EEXIST == errno))

            {

                // It already exists

                return false;

            }

            if ((EACCES == errno) || (EPERM == errno))

            {

                JniUtils::throwNewException(aJni,

                                            "java/lang/SecurityException", "Permission denied");

            }

            else

            {

                // Add also string from the posix utility that gives cause as an error string.

                JniUtils::throwNewException(aJni, "java/io/IOException", "Unable to create file");

            }

        }

        else

        {

            close(fileDes);

        }

        return true;

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "JNI: createNewFile: unknown exception. returning false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _delete

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1delete(

    JNIEnv *aJni, jobject, jstring fileName)

{

    JELOG2(EJavaFile);

    try

    {

        const char* tempName = aJni->GetStringUTFChars(fileName, 0);

        string name(tempName);

        aJni->ReleaseStringUTFChars(fileName, tempName);

        int error = remove(name.c_str());

        if (error < 0)

        {

            WLOG2(EJavaFile, "FileUtility: JNI: delete: Error: %d: Name:%S",

                  errno, name.c_str());

            if ((EACCES == errno) || (EPERM == errno))

            {

                JniUtils::throwNewException(aJni,

                                            "java/lang/SecurityException", "Permission denied");

            }

            else

            {

                return false;

            }

        }

        return true;

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: delete: unknown exception occured. Returning false");

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _dirSize

 * Signature: (Ljava/lang/String;Z)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1dirSize(

    JNIEnv *aJni, jobject, jstring fileName, jboolean subDirs)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        int retVal = FileUtilities::getDirSize(name, subDirs);

        return (retVal < 0) ? 0 : retVal;

    }

    catch (...)

    {

        ELOG(EJavaFile, "FileUtility: JNI: dirSize threw exception. Return 0");

        return 0;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _fileSize

 * Signature: (Ljava/lang/String;)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1fileSize(

    JNIEnv *aJni, jobject, jstring fileName)

{

    std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

    int ret = 0;

    try

    {

        ret = FileUtilities::fileSize(name);

    }

    catch (int err)

    {

        ELOG2(EJavaFile, "FileUtility: JNI: fileSize: Error: %d: Name: %S",

              err, name.c_str());

        if ((EACCES == err) || (EPERM == err))

        {

            JniUtils::throwNewException(aJni, "java/lang/SecurityException",

                                        "Permission denied");

        }

        else

        {

            JniUtils::throwNewException(aJni, "java/io/IOException", "Unable to determine file size");

        }

    }

    catch (...)

    {

        ELOG1(EJavaFile,

              "FileUtility: JNI: fileSize: Unknown error caught: Name: %S",

              name.c_str());

        JniUtils::throwNewException(aJni, "java/io/IOException", "");

    }

    return ret;

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _isDirectory

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1isDirectory(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::isDirectory(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: isDirectory: Unknown error caught: return false");

        // Unknown error

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _isFile

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1isFile(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::isFile(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: isFile: Unknown error caught: return false");

        // Unknown error

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _isHidden

 * Signature: (Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1isHidden(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::isHidden(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: isHidden: Unknown error caught: return false");

        // Unknown error

        return false;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _lastModified

 * Signature: (Ljava/lang/String;)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1lastModified(

    JNIEnv *aJni, jobject, jstring fileName)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        return FileUtilities::lastModified(name);

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: lastModified: Unknown error caught: return 0");

        // Unknown error

        return 0;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _listDirContents

 * Signature: (Ljava/lang/String;Z)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1listDirContents

(JNIEnv *aJni, jobject, jstring fileName, jboolean includeHidden)

{

    try

    {

        std::wstring name = FileUtil::jstringToWstring(aJni, fileName);

        std::wstring result = FileUtilities::getDirContents(name, includeHidden);

        jstring retValue = JniUtils::wstringToJstring(aJni, result);

        return retValue;

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: listDirContents: Unknown error caught: return null");

        // Unknown error

        return NULL;

    }

}

/*

 * Class:     com_nokia_mj_impl_fileutils_FileUtility

 * Method:    _renameFile

 * Signature: (Ljava/lang/String;Ljava/lang/String;)Z

 */

JNIEXPORT jboolean JNICALL Java_com_nokia_mj_impl_fileutils_FileUtility__1renameFile(

    JNIEnv *aJni, jobject, jstring aOldName, jstring aNewName)

{

    try

    {

        const char* oldName = aJni->GetStringUTFChars(aOldName, 0);

        const char* newName = aJni->GetStringUTFChars(aNewName, 0);

        int error = rename(oldName, newName);

        aJni->ReleaseStringUTFChars(aOldName, oldName);

        aJni->ReleaseStringUTFChars(aNewName, newName);

        if (error < 0)

        {

            WLOG1(EJavaFile, "FileUtility: JNI: renameFile Error: %d", error);

            if ((EACCES == errno) || (EPERM == errno))

            {

                JniUtils::throwNewException(aJni,

                                            "java/lang/SecurityException", "Permission denied");

            }

            else

            {

                JniUtils::throwNewException(aJni, "java/io/IOException", "Unable to rename file or directory");

            }

        }

        return true;

    }

    catch (...)

    {

        ELOG(EJavaFile,

             "FileUtility: JNI: renameFile: UNknown exception occured. Returning false ");

        return false;