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         __dirPath = 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, __dirPath.GetLength() > 0 && __dirPath.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(__dirPath)));
 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         size_t len = strlen(pDirPath.get()) + strlen(pDirEnt->d_name) + 2;
 146         unique_ptr<char[]> pEntryPath(new (std::nothrow) char[len]);
 147         SysTryReturnResult(NID_IO, pEntryPath != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 148
 149         memset(pEntryPath.get(), 0, len);
 150         strcpy(pEntryPath.get(), pDirPath.get());
 151         if (__dirPath.EndsWith(L"/") == false)
 152         {
 153                 strncat(pEntryPath.get(), "/", 1);
 154         }
 155         strncat(pEntryPath.get(), pDirEnt->d_name, strlen(pDirEnt->d_name));
 156
 157         struct stat64 statbuf;
 158         int ret = stat64(pEntryPath.get(), &statbuf);
 159         SysSecureTryReturnResult(NID_IO, ret == 0, __ConvertNativeErrorToResult(errno),
 160                         "Failed to get attributes for directory entry (%s), errno: %d (%s)", pEntryPath.get(), errno, strerror(errno));
 161
 162         struct tm resultTm;
 163         struct tm* pTm = localtime_r(&statbuf.st_mtime, &resultTm);
 164         SysTryReturnResult(NID_IO, pTm != null, E_SYSTEM, "Failed to get local time (%s).", strerror(errno));
 165
 166         DateTime dateTime;
 167         r = dateTime.SetValue(_BASE_YEAR + pTm->tm_year, 1 + pTm->tm_mon, pTm->tm_mday, pTm->tm_hour, pTm->tm_min, pTm->tm_sec);
 168         SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
 169
 170         if (__pCurDirEntry == null)
 171         {
 172                 __pCurDirEntry = _DirEntryImpl::CreateDirEntryInstanceN();
 173                 SysTryReturnResult(NID_IO, __pCurDirEntry != null, E_OUT_OF_MEMORY,
 174                                    "DirEntry allocation failed.");
 175         }
 176
 177         // check for a hidden file/directory including . and ..
 178         bool hidden = false;
 179         if (pDirEnt->d_name[0] == '.')
 180         {
 181                 hidden = true;
 182         }
 183
 184         _DirEntryImpl::GetInstance(__pCurDirEntry)->Set(dateTime, statbuf.st_size, String(pDirEnt->d_name),
 185                         S_ISDIR(statbuf.st_mode), (statbuf.st_mode & S_IWUSR) ? false : true, hidden);
 186
 187         return E_SUCCESS;
 188 }
 189
 190 result
 191 _DirEnumeratorImpl::Reset(void)
 192 {
 193         result r = E_SUCCESS;
 194
 195         if (__pCurDirEntry)
 196         {
 197                 delete __pCurDirEntry;
 198                 __pCurDirEntry = null;
 199         }
 200
 201         // close and reopen the dir
 202         if (__pFileFindInfo)
 203         {
 204                 closedir(static_cast <DIR*>(__pFileFindInfo));
 205         }
 206
 207         unique_ptr<char[]> pDirPathName(_StringConverter::CopyToCharArrayN(__dirPath));
 208         SysTryReturn(NID_IO, pDirPathName != null, GetLastResult(), GetLastResult(),
 209                         "[%s] Failed to close file.", GetErrorMessage(GetLastResult()));
 210
 211         __pFileFindInfo = opendir(pDirPathName.get());
 212         if (__pFileFindInfo == null)
 213         {
 214                 r = __ConvertNativeErrorToResult(errno);
 215                 SysLog(NID_IO, "[%s] Failed to open directory (%s).", GetErrorMessage(r), pDirPathName.get());
 216         }
 217
 218         return r;
 219 }
 220
 221 _DirEnumeratorImpl*
 222 _DirEnumeratorImpl::GetInstance(DirEnumerator& dirEnumerator)
 223 {
 224         return dirEnumerator.__pDirEnumeratorImpl;
 225 }
 226
 227 const _DirEnumeratorImpl*
 228 _DirEnumeratorImpl::GetInstance(const DirEnumerator& dirEnumerator)
 229 {
 230         return dirEnumerator.__pDirEnumeratorImpl;
 231 }
 232
 233 DirEnumerator*
 234 _DirEnumeratorImpl::CreateDirEnumeratorInstanceN(const String& dirPath)
 235 {
 236         unique_ptr<DirEnumerator> pDirEnumerator(new (std::nothrow) DirEnumerator(dirPath));
 237         SysTryReturn(NID_IO, pDirEnumerator != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 238         return pDirEnumerator.release();
 239 }
 240
 241 }} // Tizen::Io
 242