/*
* 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: Contains implementation of FileUtilities
*
*/
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stack>
#include "logger.h"
#include "javaoslayer.h"
#include "javacommonutils.h"
#include "fileutilities.h"
using namespace java::fileutils;
using namespace java::util;
OS_EXPORT bool FileUtilities::isFile(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
bool retValue = false;
// If there was no error, then go ahead and retrieve the data out of struct.
if (0 == error)
{
mode_t mode = fileStat.st_mode;
if (S_ISREG(mode))
{ // If it is regular file, return true.
retValue = true;
}
}
else
{
LOG1(EJavaFile, EInfo,
"FileUtilities::isFile: Unable to stat file: %s", utf8Name);
}
// Deallocate utf8 name
delete[] utf8Name;
return retValue;
}
OS_EXPORT bool FileUtilities::isDirectory(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
bool retValue = false;
// If there was no error, then go ahead and retrieve the data out of struct.
if (0 == error)
{
mode_t mode = fileStat.st_mode;
if (S_ISDIR(mode))
{
// If it is directory, return true.
retValue = true;
}
}
else
{
LOG1(EJavaFile, EInfo,
"FileUtilities::isDirectory: Unable to stat file: %s", utf8Name);
}
// Deallocate utf8 name
delete[] utf8Name;
return retValue;
}
OS_EXPORT bool FileUtilities::exists(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
bool retValue = false;
struct stat fileStat;
// We try to stat the file, if it succeeds, then we can say it exists.
// When we try to stat, the file is not opened. So, even if access restrictions
// are present, we can still know if it exists.
int error = lstat(utf8Name, &fileStat);
if (0 == error)
{
retValue = true;
}
else
{
LOG1(EJavaFile, EInfo, "FileUtilities::exists: Unable to stat file %s",
utf8Name);
}
delete[] utf8Name;
return retValue;
}
OS_EXPORT bool FileUtilities::canRead(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
bool retValue = false;
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
if (0 == error)
{
mode_t curMode = fileStat.st_mode;
if (curMode & (S_IRUSR))
{
retValue = true;
}
}
else
{
LOG1(EJavaFile, EInfo,
"FileUtilities::canRead: Unable to check access for %s",
utf8Name);
}
delete[] utf8Name;
return retValue;
}
OS_EXPORT bool FileUtilities::canWrite(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
bool retValue = false;
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
if (0 == error)
{
mode_t curMode = fileStat.st_mode;
if (curMode & (S_IWUSR))
{
retValue = true;
}
}
else
{
LOG2(
EJavaFile,
EInfo,
"FileUtilities::canWrite: Unable to check access for %s: Error: %d",
utf8Name, errno);
}
delete[] utf8Name;
return retValue;
}
OS_EXPORT long FileUtilities::fileSize(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
long retValue = 0;
if (0 == error)
{
retValue = fileStat.st_size;
}
else
{
ELOG2(EJavaFile,
"FileUtilities::fileSize: Unable to stat file %s: errno: ",
utf8Name, errno);
delete[] utf8Name;
int error = errno;
throw error;
}
delete[] utf8Name;
return retValue;
}
OS_EXPORT long FileUtilities::lastModified(const std::wstring& aPath)
{
JELOG2(EJavaFile);
char* utf8Name = JavaCommonUtils::wstringToUtf8(aPath);
struct stat fileStat;
int error = lstat(utf8Name, &fileStat);
long retValue = 0;
if (0 == error)
{
retValue = fileStat.st_mtime;
}
else
{
ELOG2(
EJavaFile,
"FileUtilities::lastModified: Error stating file. return = 0 %s: errno: ",
utf8Name, errno);
retValue = 0;
}
delete[] utf8Name;
return retValue;
}
OS_EXPORT long FileUtilities::getDirSize(const std::wstring& origDirName,
const bool includeSubDirs)
{
JELOG2(EJavaFile);
long totalSize = 0;
char* multiByteDirName = java::util::JavaCommonUtils::wstringToUtf8(
origDirName);
std::string dirName(multiByteDirName);
std::stack<std::string> subDirs;
subDirs.push(dirName);
while (!subDirs.empty())
{
//while stack not empty, keep stating files
dirName = subDirs.top();
subDirs.pop();
DIR* wDirHandle = opendir(dirName.c_str());
if (wDirHandle)
{
struct dirent* dir = readdir(wDirHandle);
while (dir)
{
//dirName = subDirs.top();
std::string name(dirName);
name += "/";
name += std::string(dir->d_name);
LOG1(EJavaFile, EInfo,
" FileUtilities::getDirSize(): Stating %s",
name.c_str());
struct stat buf;
if (stat(name.c_str(), &buf) == 0)
{
totalSize += buf.st_size;
if (includeSubDirs && S_ISDIR(buf.st_mode))
{
//if it is directory, put it onto stack
subDirs.push(name);
}
}
dir = readdir(wDirHandle);
}
closedir(wDirHandle);
}
}
delete[] multiByteDirName; //JavaCommonUtils Allocates Memory
return totalSize;
}
OS_EXPORT std::list<std::wstring> FileUtilities::getDirContentsList(const std::wstring& dirName)
{
JELOG2(EJavaFile);
std::list<std::wstring> contentList;
std::wstring stringContents = getDirContents(dirName);
wchar_t* delim = L"*";
wchar_t* last;
wchar_t* tok;
wchar_t* stringToTokenize = new wchar_t[ stringContents.length()+1 ];
wcscpy(stringToTokenize, stringContents.c_str());
for (tok = wcstok(stringToTokenize,delim,&last); tok!=NULL;
tok = wcstok(NULL, delim, &last))
{
LOG1(EJavaFile, EInfo, " FileUtilities::getDirContentsList(): Adding %S", tok);
contentList.push_back(std::wstring(tok));
}
delete[] stringToTokenize;
return contentList;
}
OS_EXPORT int FileUtilities::makeDirAll(const std::wstring& aDirPath)
{
JELOG2(EJavaFile);
bool ableToOpen = true;
std::wstring path;
wchar_t *last, *tok, *delim =L"/" ;
wchar_t *stringToTokenize = new wchar_t[aDirPath.length()+ 1];
wcscpy(stringToTokenize, aDirPath.c_str());
for (tok = wcstok(stringToTokenize,delim,&last); tok!=NULL;
tok = wcstok(NULL, delim, &last))
{
path += std::wstring(tok);
path += L"/";
char *dirName = JavaCommonUtils::wstringToUtf8(path);
if (ableToOpen)
{
if (!opendir(dirName))
{
ableToOpen = false;
if (mkdir(dirName,0666)<0)
{
WLOG1(EJavaFile,"FileUtilities::makeDirAll: Directory Creation Failed : %s",dirName);
delete[] dirName;
delete[] stringToTokenize;
return -1;
}
}
}
else
{
if (mkdir(dirName,0666)<0)
{
ELOG1(EJavaFile, "FileUtilities::makeDirAll: Directory Creation Failed : %s",dirName);
delete[] dirName;
delete[] stringToTokenize;
return -1;
}
}
delete[] dirName;
}
delete[] stringToTokenize;
return 0;
}
OS_EXPORT std::wstring FileUtilities::getDirContents(const std::wstring& aDirName)
{
return getDirContents(aDirName, true);
}