Filesystem.cpp

   1 #include <sys/stat.h>
   2 #include <time.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <boost/lexical_cast.hpp>
   6 #include "Filesystem.hpp"
   7 #include "IO.hpp"
   8 #include "String.hpp"
   9
  10 Filesystem::Filesystem( const std::string& root )
  11         : m_root( root )
  12         , m_path( "/" )
  13 {
  14 #ifdef SYMBIAN
  15         m_rfs.Connect();
  16 #endif
  17 }
  18
  19 Filesystem::~Filesystem()
  20 {
  21 #ifdef SYMBIAN
  22         m_rfs.Close();
  23 #endif
  24 }
  25
  26 bool Filesystem::ChangeDirectory( const std::string& cd )
  27 {
  28         PathVector reqPath = SplitPath( cd );
  29         PathVector path = SplitProperPath( cd );
  30
  31         if( !TryChangePath( reqPath, path ) )
  32         {
  33                 return false;
  34         }
  35
  36         m_path = MakePath( path );
  37
  38         return true;
  39 }
  40
  41 bool Filesystem::FileExists( const std::string& file )
  42 {
  43         return CheckFileExists( GetFilePath( file ) );
  44 }
  45
  46 FILE* Filesystem::FileOpen( const std::string& file, Mode mode )
  47 {
  48         std::string path = m_root + GetFilePath( file );
  49
  50         switch( mode )
  51         {
  52         case M_READ:
  53                 return fopen( path.c_str(), "rb" );
  54                 break;
  55
  56         case M_WRITE:
  57                 return fopen( path.c_str(), "wb" );
  58                 break;
  59
  60         default:
  61                 break;
  62         }
  63
  64         return NULL;
  65 }
  66
  67 #ifdef SYMBIAN
  68 RFile* Filesystem::FileOpenSymbian( const std::string& file, Mode mode )
  69 {
  70         RFile* f = new RFile;
  71
  72         std::string path = m_root + GetFilePath( file );
  73
  74         for( unsigned int i=0; i<path.size(); i++ )
  75         {
  76                 if( path[i] == '/' || path[i] == '\\' )
  77                 {
  78                         if( i>0 && path[i-1] == '\\' )
  79                         {
  80                                 path.erase( i, 1 );
  81                                 i--;
  82                         }
  83                         else
  84                         {
  85                                 path[i] = '\\';
  86                         }
  87                 }
  88         }
  89
  90         TPtrC8 ptr( reinterpret_cast<const TUint8*>( path.c_str() ) );
  91         TBuf<512> buf;
  92         buf.FillZ();
  93         buf.Copy( ptr );
  94
  95         switch( mode )
  96         {
  97         case M_READ:
  98                 if( f->Open( m_rfs, buf, EFileRead | EFileStream | EFileShareReadersOnly ) != KErrNone )
  99                 {
 100                         delete f;
 101                         f = NULL;
 102                 }
 103                 break;
 104
 105         case M_WRITE:
 106                 if( f->Replace( m_rfs, buf, EFileWrite | EFileStream ) != KErrNone )
 107                 {
 108                         delete f;
 109                         f = NULL;
 110                 }
 111                 break;
 112
 113         default:
 114                 delete f;
 115                 f = NULL;
 116                 break;
 117         }
 118
 119         return f;
 120 }
 121 #endif
 122
 123 std::list<std::string> Filesystem::GetListing( const std::string& path )
 124 {
 125         std::list<std::string> ret;
 126
 127         time_t now = time( NULL );
 128
 129         std::string filePath = GetFilePath( path );
 130         if( CheckFileExists( filePath ) )
 131         {
 132                 struct stat s;
 133                 stat( ( m_root + filePath ).c_str(), &s );
 134
 135                 std::string entry = "-rw-r--r--";
 136
 137                 tm timeFile;
 138                 localtime_r( &s.st_mtime, &timeFile );
 139
 140                 char dateBuf[64];
 141                 if( now > s.st_mtime && now - s.st_mtime < 60*60*24*180 )
 142                 {
 143                         // File is "recent"
 144                         strftime( dateBuf, sizeof( dateBuf ), " %b %m %H:%M ", &timeFile );
 145                 }
 146                 else
 147                 {
 148                         strftime( dateBuf, sizeof( dateBuf ), " %b %m  %Y ", &timeFile );
 149                 }
 150
 151                 entry += " 1 root root " + boost::lexical_cast<std::string>( s.st_size ) + dateBuf + path;
 152
 153                 ret.push_back( entry );
 154
 155                 return ret;
 156         }
 157
 158         PathVector reqPath = SplitPath( path );
 159         PathVector pv = SplitProperPath( path );
 160
 161         if( !TryChangePath( reqPath, pv ) )
 162         {
 163                 return ret;
 164         }
 165
 166         std::string newPath = m_root + MakePath( pv );
 167
 168         Directory d;
 169         if( !d.Open( newPath ) )
 170         {
 171                 return ret;
 172         }
 173
 174         tm timeNow;
 175         localtime_r( &now, &timeNow );
 176
 177         // Symbian readdir() doesn't report "." and ".."
 178         bool hasDot = false;
 179         bool hasDotDot = false;
 180
 181         struct stat s;
 182         while( d )
 183         {
 184                 std::string dirName = d.GetName();
 185                 stat( ( newPath + "/" + dirName ).c_str(), &s );
 186
 187                 std::string entry;
 188
 189                 if( S_ISDIR( s.st_mode ) )
 190                 {
 191                         entry += "drwxr-xr-x";
 192                 }
 193                 else
 194                 {
 195                         entry += "-rw-r--r--";
 196                 }
 197
 198                 tm timeFile;
 199                 localtime_r( &s.st_mtime, &timeFile );
 200
 201                 char dateBuf[64];
 202                 if( now > s.st_mtime && now - s.st_mtime < 60*60*24*180 )
 203                 {
 204                         // File is "recent"
 205                         strftime( dateBuf, sizeof( dateBuf ), " %b %m %H:%M ", &timeFile );
 206                 }
 207                 else
 208                 {
 209                         strftime( dateBuf, sizeof( dateBuf ), " %b %m  %Y ", &timeFile );
 210                 }
 211
 212                 entry += " 1 root root " + boost::lexical_cast<std::string>( s.st_size ) + dateBuf + dirName;
 213
 214                 if( dirName == "." )
 215                 {
 216                         hasDot = true;
 217                 }
 218                 else if( dirName == ".." )
 219                 {
 220                         hasDotDot = true;
 221                 }
 222
 223                 ret.push_back( entry );
 224
 225                 ++d;
 226         }
 227
 228         if( !hasDotDot )
 229         {
 230                 ret.push_front( "drwxr-xr-x 1 root root 0 Jan  1  1970 .." );
 231         }
 232         if( !hasDot )
 233         {
 234                 ret.push_front( "drwxr-xr-x 1 root root 0 Jan  1  1970 ." );
 235         }
 236
 237         return ret;
 238 }
 239
 240 bool Filesystem::Delete( const std::string& file )
 241 {
 242         std::string path = m_root + GetFilePath( file );
 243
 244         return unlink( path.c_str() ) == 0;
 245 }
 246
 247 std::string Filesystem::MkDir( const std::string& dir )
 248 {
 249         std::string filePath = GetFilePath( dir );
 250         if( filePath == "" )
 251         {
 252                 return "";
 253         }
 254
 255         std::string path = m_root + filePath;
 256
 257         if( !IO::MkDir( path ) )
 258         {
 259                 return "";
 260         }
 261
 262         return path;
 263 }
 264
 265 bool Filesystem::RmDir( const std::string& dir )
 266 {
 267         std::string filePath = GetFilePath( dir );
 268         if( filePath == "" )
 269         {
 270                 return false;
 271         }
 272
 273         std::string path = m_root + filePath;
 274
 275         if( !IO::RmDir( path ) )
 276         {
 277                 return false;
 278         }
 279
 280         return true;
 281 }
 282
 283 std::string Filesystem::MakePath( const PathVector& pv )
 284 {
 285         std::string ret;
 286
 287         if( pv.size() == 0 )
 288         {
 289                 ret = "/";
 290         }
 291         else
 292         {
 293                 for( PathVector::const_iterator it = pv.begin(); it != pv.end(); ++it )
 294                 {
 295                         ret.append( "/" );
 296                         ret.append( *it );
 297                 }
 298         }
 299
 300         return ret;
 301 }
 302
 303 bool Filesystem::DirectoryExists( const std::string& dir )
 304 {
 305         std::string path = m_root + dir;
 306         struct stat s;
 307
 308         if( stat( path.c_str(), &s ) == -1 )
 309         {
 310                 return false;
 311         }
 312
 313         return S_ISDIR( s.st_mode );
 314 }
 315
 316 bool Filesystem::TryChangePath( const PathVector& reqPath, PathVector& path )
 317 {
 318         for( PathVector::const_iterator it = reqPath.begin(); it != reqPath.end(); ++it )
 319         {
 320                 if( *it == "." )
 321                 {
 322                         continue;
 323                 }
 324                 else if( *it == ".." )
 325                 {
 326                         if( path.size() == 0 )
 327                         {
 328                                 // Can't go below the root directory.
 329                                 // Or maybe it should be possible as no-op?
 330                                 return false;
 331                         }
 332                         else
 333                         {
 334                                 path.pop_back();
 335                         }
 336                 }
 337                 else
 338                 {
 339                         if( DirectoryExists( MakePath( path ) + "/" + *it ) )
 340                         {
 341                                 path.push_back( *it );
 342                         }
 343                         else
 344                         {
 345                                 return false;
 346                         }
 347                 }
 348         }
 349
 350         return true;
 351 }
 352
 353 bool Filesystem::CheckFileExists( const std::string& file )
 354 {
 355         std::string path = m_root + file;
 356         struct stat s;
 357
 358         if( stat( path.c_str(), &s ) == -1 )
 359         {
 360                 return false;
 361         }
 362
 363         return S_ISREG( s.st_mode );
 364 }
 365
 366 std::string Filesystem::GetFilePath( const std::string& file )
 367 {
 368         PathVector reqPath = SplitPath( file );
 369
 370         if( reqPath.size() == 0 )
 371         {
 372                 return "";
 373         }
 374
 375         // Remove filename from path
 376         std::string fname = reqPath.back();
 377         reqPath.pop_back();
 378
 379         PathVector path = SplitProperPath( file );
 380
 381         if( !TryChangePath( reqPath, path ) )
 382         {
 383                 return "";
 384         }
 385
 386         return MakePath( path ) + "/" + fname;
 387 }
 388
 389 PathVector Filesystem::SplitProperPath( const std::string& path )
 390 {
 391         PathVector ret;
 392
 393         if( path.length() > 0 &&
 394             ( path[0] == '/' ||
 395             ( path.length() > 1 && ( path[0] == '~' && path[1] == '/' ) ) ) )
 396         {
 397                 ret = SplitPath( "/" );
 398         }
 399         else
 400         {
 401                 ret = SplitPath( m_path );
 402         }
 403
 404         return ret;
 405 }