--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/fileutils/src/fileutilities.cpp Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,356 @@
+/*
+* 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);
+}