src/CFile.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 1998-2008 Vadim Zeitlin ( zeitlin@dptmaths.ens-cachan.fr )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #include "CFile.h"              // Interface declarations.
  28 #include "Logger.h"             // Needed for AddDebugLogLineM
  29 #include <common/Path.h>        // Needed for CPath
  30
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"             // Needed for HAVE_SYS_PARAM_H
  34 #endif
  35
  36
  37 #ifdef HAVE_SYS_PARAM_H
  38 #include <sys/param.h>
  39 #endif
  40
  41 // standard
  42 #if defined(__WXMSW__) && !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)
  43 #       include <io.h>
  44 #       ifndef __SALFORDC__
  45 #               define   WIN32_LEAN_AND_MEAN
  46 #               define   NOSERVICE
  47 #               define   NOIME
  48 #               define   NOATOM
  49 #               define   NOGDI
  50 #               define   NOGDICAPMASKS
  51 #               define   NOMETAFILE
  52 #               define   NOMINMAX
  53 #               define   NOMSG
  54 #               define   NOOPENFILE
  55 #               define   NORASTEROPS
  56 #               define   NOSCROLL
  57 #               define   NOSOUND
  58 #               define   NOSYSMETRICS
  59 #               define   NOTEXTMETRIC
  60 #               define   NOWH
  61 #               define   NOCOMM
  62 #               define   NOKANJI
  63 #               define   NOCRYPT
  64 #               define   NOMCX
  65 #       endif
  66 #elif (defined(__UNIX__) || defined(__GNUWIN32__))
  67 #       ifdef __GNUWIN32__
  68 #               include <windows.h>
  69 #       endif
  70 #elif (defined(__WXPM__))
  71 #       include <io.h>
  72 #elif (defined(__WXSTUBS__))
  73         // Have to ifdef this for different environments
  74 #       include <io.h>
  75 #elif (defined(__WXMAC__))
  76 #if __MSL__ < 0x6000
  77 int access( const char *path, int mode ) { return 0 ; }
  78 #else
  79 int _access( const char *path, int mode ) { return 0 ; }
  80 #endif
  81 char* mktemp( char * path ) { return path ;}
  82 #       include <stat.h>
  83 #else
  84 #       error  "Please specify the header with file functions declarations."
  85 #endif  //Win/UNIX
  86
  87 // there is no distinction between text and binary files under Unix, so define
  88 // O_BINARY as 0 if the system headers don't do it already
  89 #if defined(__UNIX__) && !defined(O_BINARY)
  90 #       define   O_BINARY    (0)
  91 #endif  //__UNIX__
  92
  93 #ifdef __WXMSW__
  94 #include <wx/msw/mslu.h>
  95 #endif
  96
  97
  98 // The following defines handle different names across platforms,
  99 // and ensures that we use 64b IO on windows (only 32b by default).
 100 #ifdef __WXMSW__
 101         #define FLUSH_FD(x)                     _commit(x)
 102         #define SEEK_FD(x, y, z)                _lseeki64(x, y, z)
 103         #define TELL_FD(x)                      _telli64(x)
 104
 105         #if (__MSVCRT_VERSION__ < 0x0601)
 106                 //#warning MSCVRT-Version smaller than 6.01
 107                 #define STAT_FD(x, y)           _fstati64(x, y)
 108                 #define STAT_STRUCT             struct _stati64
 109         #else
 110                 #define STAT_FD(x, y)           _fstat64(x, y)
 111                 #define STAT_STRUCT             struct __stat64
 112         #endif
 113 #else
 114
 115 // We don't need to sync all meta-data, just the contents,
 116 // so use fdatasync when possible (see man fdatasync).
 117         #if defined(_POSIX_SYNCHRONIZED_IO) && (_POSIX_SYNCHRONIZED_IO > 0)
 118                 #define FLUSH_FD(x)             fdatasync(x)
 119         #else
 120                 #define FLUSH_FD(x)             fsync(x)
 121         #endif
 122
 123         #define SEEK_FD(x, y, z)                lseek(x, y, z)
 124         #define TELL_FD(x)                      wxTell(x)
 125         #define STAT_FD(x, y)                   fstat(x, y)
 126         #define STAT_STRUCT                     struct stat
 127 #endif
 128
 129
 130 // This function is used to check if a syscall failed, in that case
 131 // log an appropriate message containing the errno string.
 132 inline void syscall_check(
 133         bool check,
 134         const CPath& filePath,
 135         const wxString& what)
 136 {
 137         if (!check) {
 138                 AddDebugLogLineM(true, logCFile,
 139                         CFormat(wxT("Error when %s (%s): %s"))
 140                                 % what % filePath % wxSysErrorMsg());
 141         }
 142 }
 143
 144
 145 CSeekFailureException::CSeekFailureException(const wxString& desc)
 146         : CIOFailureException(wxT("SeekFailure"), desc)
 147 {}
 148
 149
 150 CFile::CFile()
 151         : m_fd(fd_invalid)
 152 {}
 153
 154
 155 CFile::CFile(const CPath& fileName, OpenMode mode)
 156         : m_fd(fd_invalid)
 157 {
 158         Open(fileName, mode);
 159 }
 160
 161
 162 CFile::CFile(const wxString& fileName, OpenMode mode)
 163         : m_fd(fd_invalid)
 164 {
 165         Open(fileName, mode);
 166 }
 167
 168
 169 CFile::~CFile()
 170 {
 171         if (IsOpened()) {
 172                 Close();
 173         }
 174 }
 175
 176
 177 int CFile::fd() const
 178 {
 179         return m_fd;
 180 }
 181
 182
 183 bool CFile::IsOpened() const
 184 {
 185         return m_fd != fd_invalid;
 186 }
 187
 188
 189 const CPath& CFile::GetFilePath() const
 190 {
 191         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot return path of closed file."));
 192
 193         return m_filePath;
 194 }
 195
 196
 197 bool CFile::Create(const CPath& path, bool overwrite, int accessMode)
 198 {
 199         if (!overwrite && path.FileExists()) {
 200                 return false;
 201         }
 202
 203         return Open(path, write, accessMode);
 204 }
 205
 206 bool CFile::Create(const wxString& path, bool overwrite, int accessMode)
 207 {
 208         return Create(CPath(path), overwrite, accessMode);
 209 }
 210
 211
 212 bool CFile::Open(const wxString& fileName, OpenMode mode, int accessMode)
 213 {
 214         MULE_VALIDATE_PARAMS(fileName.Length(), wxT("CFile: Cannot open, empty path."));
 215
 216         return Open(CPath(fileName), mode, accessMode);
 217 }
 218
 219
 220 bool CFile::Open(const CPath& fileName, OpenMode mode, int accessMode)
 221 {
 222         MULE_VALIDATE_PARAMS(fileName.IsOk(), wxT("CFile: Cannot open, empty path."));
 223
 224 #ifdef __linux__
 225         int flags = O_BINARY | O_LARGEFILE;
 226 #else
 227         int flags = O_BINARY;
 228 #endif
 229         switch ( mode ) {
 230                 case read:
 231                         flags |= O_RDONLY;
 232                         break;
 233
 234                 case write_append:
 235                         if (fileName.FileExists())
 236                         {
 237                                 flags |= O_WRONLY | O_APPEND;
 238                                 break;
 239                         }
 240                         //else: fall through as write_append is the same as write if the
 241                         //      file doesn't exist
 242
 243                 case write:
 244                         flags |= O_WRONLY | O_CREAT | O_TRUNC;
 245                         break;
 246
 247                 case write_excl:
 248                         flags |= O_WRONLY | O_CREAT | O_EXCL;
 249                         break;
 250
 251                 case read_write:
 252                         flags |= O_RDWR;
 253                 break;
 254         }
 255
 256         if (IsOpened()) {
 257                 Close();
 258         }
 259
 260
 261
 262         Unicode2CharBuf tmpFileName = filename2char(fileName.GetRaw());
 263         wxASSERT_MSG(tmpFileName, wxT("Convertion failed in CFile::Open"));
 264
 265         m_filePath = fileName;
 266         m_fd = open(tmpFileName, flags, accessMode);
 267         syscall_check(m_fd != fd_invalid, m_filePath, wxT("opening file"));
 268
 269         return IsOpened();
 270 }
 271
 272
 273 bool CFile::Close()
 274 {
 275         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot close closed file."));
 276
 277         bool closed = (close(m_fd) != -1);
 278         syscall_check(closed, m_filePath, wxT("closing file"));
 279
 280         m_fd = fd_invalid;
 281
 282         return closed;
 283 }
 284
 285
 286 bool CFile::Flush()
 287 {
 288         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot flush closed file."));
 289
 290         bool flushed = (FLUSH_FD(m_fd) != -1);
 291         syscall_check(flushed, m_filePath, wxT("flushing file"));
 292
 293         return flushed;
 294 }
 295
 296
 297 sint64 CFile::doRead(void* buffer, size_t count) const
 298 {
 299         MULE_VALIDATE_PARAMS(buffer, wxT("CFile: Invalid buffer in read operation."));
 300         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot read from closed file."));
 301
 302         size_t totalRead = 0;
 303         while (totalRead < count) {
 304                 int current = ::read(m_fd, (char*)buffer + totalRead, count - totalRead);
 305
 306                 if (current == -1) {
 307                         // Read error, nothing we can do other than abort.
 308                         throw CIOFailureException(wxString(wxT("Error reading from file: ")) + wxSysErrorMsg());
 309                 } else if ((totalRead + current < count) && Eof()) {
 310                         // We may fail to read the specified count in a couple
 311                         // of situations: EOF and interrupts. The check for EOF
 312                         // is needed to avoid inf. loops.
 313                         break;
 314                 }
 315
 316                 totalRead += current;
 317         }
 318
 319         return totalRead;
 320 }
 321
 322
 323 sint64 CFile::doWrite(const void* buffer, size_t nCount)
 324 {
 325         MULE_VALIDATE_PARAMS(buffer, wxT("CFile: Invalid buffer in write operation."));
 326         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot write to closed file."));
 327
 328         sint64 result = ::write(m_fd, buffer, nCount);
 329
 330         if (result != (sint64)nCount) {
 331                 throw CIOFailureException(wxString(wxT("Error writing to file: ")) + wxSysErrorMsg());
 332         }
 333
 334         return result;
 335 }
 336
 337
 338 sint64 CFile::doSeek(sint64 offset) const
 339 {
 340         MULE_VALIDATE_STATE(IsOpened(), wxT("Cannot seek on closed file."));
 341         MULE_VALIDATE_PARAMS(offset >= 0, wxT("Invalid position, must be positive."));
 342
 343         sint64 result = SEEK_FD(m_fd, offset, SEEK_SET);
 344
 345         if (result == offset) {
 346                 return result;
 347         } else if (result == wxInvalidOffset) {
 348                 throw CSeekFailureException(wxString(wxT("Seeking failed: ")) + wxSysErrorMsg());
 349         } else {
 350                 throw CSeekFailureException(wxT("Seeking returned incorrect position"));
 351         }
 352 }
 353
 354
 355 uint64 CFile::GetPosition() const
 356 {
 357         MULE_VALIDATE_STATE(IsOpened(), wxT("Cannot get position in closed file."));
 358
 359         sint64 pos = TELL_FD(m_fd);
 360         if (pos == wxInvalidOffset) {
 361                 throw CSeekFailureException(wxString(wxT("Failed to retrieve position in file: ")) + wxSysErrorMsg());
 362         }
 363
 364         return pos;
 365 }
 366
 367
 368 uint64 CFile::GetLength() const
 369 {
 370         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot get length of closed file."));
 371
 372         STAT_STRUCT buf;
 373         if (STAT_FD(m_fd, &buf) == -1) {
 374                 throw CIOFailureException(wxString(wxT("Failed to retrieve length of file: ")) + wxSysErrorMsg());
 375         }
 376
 377         return buf.st_size;
 378 }
 379
 380
 381 uint64 CFile::GetAvailable() const
 382 {
 383         const uint64 length = GetLength();
 384         const uint64 position = GetPosition();
 385
 386         // Safely handle seeking past EOF
 387         if (position < length) {
 388                 return length - position;
 389         }
 390
 391         // File is at or after EOF
 392         return 0;
 393 }
 394
 395
 396 bool CFile::SetLength(size_t new_len)
 397 {
 398         MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot set length when no file is open."));
 399
 400 #ifdef __WXMSW__
 401         int result = chsize(m_fd, new_len);
 402 #else
 403         int result = ftruncate(m_fd, new_len);
 404 #endif
 405
 406         syscall_check((result != -1), m_filePath, wxT("truncating file"));
 407
 408         return (result != -1);
 409 }
 410 // File_checked_for_headers