src/io/FIo_DirEnumeratorImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        FIo_DirEnumeratorImpl.cpp
  19  * @brief       This is the implementation file for _DirEnumeratorImpl class.
  20  */
  21
  22 #include <string.h>
  23 #include <dirent.h>
  24 #include <sys/stat.h>
  25 #include <time.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <unique_ptr.h>
  29
  30 #include <FBaseDateTime.h>
  31 #include <FIoDirEntry.h>
  32 #include <FIoDirEnumerator.h>
  33 #include <FBaseSysLog.h>
  34
  35 #include <FBase_NativeError.h>
  36 #include <FBase_StringConverter.h>
  37 #include <FIo_DirEnumeratorImpl.h>
  38 #include <FIo_DirEntryImpl.h>
  39
  40 using namespace std;
  41 using namespace Tizen::Base;
  42
  43 namespace Tizen { namespace Io
  44 {
  45
  46 static const int _BASE_YEAR = 1900;
  47
  48 _DirEnumeratorImpl::_DirEnumeratorImpl(const String& dirPath)
  49         : __validAccess(false)
  50         , __pFileFindInfo(null)
  51         , __pCurDirEntry(null)
  52 {
  53         __validAccess = true;
  54         __absoluteDirPath = dirPath;
  55 }
  56
  57 _DirEnumeratorImpl::_DirEnumeratorImpl(const _DirEnumeratorImpl& dirEnumeratorImpl)
  58         : __validAccess(false)
  59         , __pFileFindInfo(null)
  60         , __pCurDirEntry(null)
  61 {
  62         SysLogException(NID_IO, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] This copy constructor is not implemented.");
  63         SetLastResult(E_UNSUPPORTED_OPERATION);
  64 }
  65
  66 _DirEnumeratorImpl&
  67 _DirEnumeratorImpl::operator =(const _DirEnumeratorImpl& dirEnumeratorImpl)
  68 {
  69         if (this != &dirEnumeratorImpl)
  70         {
  71                 SysLogException(NID_IO, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] This assign operator is not implemented.");
  72                 SetLastResult(E_UNSUPPORTED_OPERATION);
  73         }
  74         return *this;
  75 }
  76
  77 _DirEnumeratorImpl::~_DirEnumeratorImpl(void)
  78 {
  79         if (__pFileFindInfo)
  80         {
  81                 closedir(static_cast <DIR*>(__pFileFindInfo));
  82                 __pFileFindInfo = null;
  83         }
  84
  85         delete __pCurDirEntry;
  86 }
  87
  88 DirEntry
  89 _DirEnumeratorImpl::GetCurrentDirEntry(void) const
  90 {
  91         result r = E_SUCCESS;
  92
  93         unique_ptr<DirEntry> pDirEntry(_DirEntryImpl::CreateDirEntryInstanceN());
  94         DirEntry dirEntryObject = *pDirEntry;
  95
  96         SysTryReturn(NID_IO, __pCurDirEntry != null, dirEntryObject, E_INVALID_STATE,
  97                         "[E_INVALID_STATE] Instance has not been created yet.");
  98
  99         _DirEntryImpl::GetInstance(&dirEntryObject)->Set(__pCurDirEntry->GetDateTime(),
 100                         __pCurDirEntry->GetFileSize(), __pCurDirEntry->GetName(), __pCurDirEntry->IsDirectory(),
 101                         __pCurDirEntry->IsReadOnly(), __pCurDirEntry->IsHidden());
 102
 103         SetLastResult(r);
 104         return dirEntryObject;
 105 }
 106
 107 Object*
 108 _DirEnumeratorImpl::GetCurrent(void) const
 109 {
 110         SetLastResult(E_SUCCESS);
 111         return __pCurDirEntry;
 112 }
 113
 114 result
 115 _DirEnumeratorImpl::MoveNext(void)
 116 {
 117         SysTryReturnResult(NID_IO, __validAccess == true, E_ILLEGAL_ACCESS,
 118                         "Given path cannot be accessed!");
 119         SysTryReturnResult(NID_IO, __absoluteDirPath.GetLength() > 0 && __absoluteDirPath.GetLength() <= PATH_MAX,
 120                         E_INVALID_ARG, "Invalid argument was passed. Given pattern length is not correct!");
 121         result r = E_SUCCESS;
 122
 123         unique_ptr<char[]> pDirPath(_StringConverter::CopyToCharArrayN(String(__absoluteDirPath)));
 124         SysTryReturn(NID_IO, pDirPath != null, GetLastResult(), GetLastResult(),
 125                         "[%s] Invalid argument was passed. Given pattern length is not correct!", GetErrorMessage(GetLastResult()));
 126
 127         if (__pFileFindInfo == null)
 128         {
 129                 __pFileFindInfo = opendir(pDirPath.get());
 130                 if (__pFileFindInfo == null)
 131                 {
 132                         r = _NativeError::ConvertNativeErrorToResult(errno, true);
 133                         SysLog(NID_IO, "[%s] Failed to open directory (%s), [%s].", GetErrorMessage(r),
 134                                                 GetErrorMessage((result) E_FILE_NOT_FOUND), pDirPath.get());
 135                         return r;
 136                 }
 137         }
 138
 139         errno = 0;
 140         struct dirent* pDirEnt = readdir((DIR*) __pFileFindInfo);
 141         SysTryReturnResult(NID_IO, errno == 0, __ConvertNativeErrorToResult(errno),
 142                         "Failed to the next directory entry. parent: %s, errno: %d (%s)", pDirPath.get(), errno, strerror(errno));
 143         SysTryReturnResult(NID_IO, pDirEnt != null, E_END_OF_FILE, "End of directory entries");
 144
 145         char entryPath[PATH_MAX] = { 0, };
 146         strcpy(entryPath, pDirPath.get());
 147         strncat(entryPath, "/", 1);
 148         strncat(entryPath, pDirEnt->d_name, strlen(pDirEnt->d_name));
 149
 150         struct stat64 statbuf;
 151         int ret = stat64(entryPath, &statbuf);
 152         SysSecureTryReturnResult(NID_IO, ret == 0, __ConvertNativeErrorToResult(errno),
 153                         "Failed to get attributes for directory entry (%s), errno: %d (%s)", entryPath, errno, strerror(errno));
 154
 155         struct tm* pTm = localtime(&statbuf.st_mtime);
 156         SysTryReturnResult(NID_IO, pTm != null, E_SYSTEM, "Failed to call localtime() (%s).", strerror(errno));
 157
 158         DateTime dateTime;
 159         r = dateTime.SetValue(_BASE_YEAR + pTm->tm_year, 1 + pTm->tm_mon, pTm->tm_mday, pTm->tm_hour, pTm->tm_min, pTm->tm_sec);
 160         SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
 161
 162         if (__pCurDirEntry == null)
 163         {
 164                 __pCurDirEntry = _DirEntryImpl::CreateDirEntryInstanceN();
 165                 SysTryReturnResult(NID_IO, __pCurDirEntry != null, E_OUT_OF_MEMORY,
 166                                    "DirEntry allocation failed.");
 167         }
 168
 169         // check for a hidden file/directory including . and ..
 170         bool hidden = false;
 171         if (pDirEnt->d_name[0] == '.')
 172         {
 173                 hidden = true;
 174         }
 175
 176         _DirEntryImpl::GetInstance(__pCurDirEntry)->Set(dateTime, statbuf.st_size, String(pDirEnt->d_name),
 177                         S_ISDIR(statbuf.st_mode), (statbuf.st_mode & S_IWUSR) ? false : true, hidden);
 178
 179         return E_SUCCESS;
 180 }
 181
 182 result
 183 _DirEnumeratorImpl::Reset(void)
 184 {
 185         result r = E_SUCCESS;
 186
 187         if (__pCurDirEntry)
 188         {
 189                 delete __pCurDirEntry;
 190                 __pCurDirEntry = null;
 191         }
 192
 193         // close and reopen the dir
 194         if (__pFileFindInfo)
 195         {
 196                 closedir(static_cast <DIR*>(__pFileFindInfo));
 197         }
 198
 199         unique_ptr<char[]> pDirPathName(_StringConverter::CopyToCharArrayN(__absoluteDirPath));
 200         SysTryReturn(NID_IO, pDirPathName != null, GetLastResult(), GetLastResult(),
 201                         "[%s] Failed to close file.", GetErrorMessage(GetLastResult()));
 202
 203         __pFileFindInfo = opendir(pDirPathName.get());
 204         if (__pFileFindInfo == null)
 205         {
 206                 r = __ConvertNativeErrorToResult(errno);
 207                 SysLog(NID_IO, "[%s] Failed to open directory (%s).", GetErrorMessage(r), pDirPathName.get());
 208         }
 209
 210         return r;
 211 }
 212
 213 _DirEnumeratorImpl*
 214 _DirEnumeratorImpl::GetInstance(DirEnumerator& dirEnumerator)
 215 {
 216         return dirEnumerator.__pDirEnumeratorImpl;
 217 }
 218
 219 const _DirEnumeratorImpl*
 220 _DirEnumeratorImpl::GetInstance(const DirEnumerator& dirEnumerator)
 221 {
 222         return dirEnumerator.__pDirEnumeratorImpl;
 223 }
 224
 225 DirEnumerator*
 226 _DirEnumeratorImpl::CreateDirEnumeratorInstanceN(const String& dirPath)
 227 {
 228         unique_ptr<DirEnumerator> pDirEnumerator(new (std::nothrow) DirEnumerator(dirPath));
 229         SysTryReturn(NID_IO, pDirEnumerator != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 230         return pDirEnumerator.release();
 231 }
 232
 233 }} // Tizen::Io
 234