2 // This file is part of the aMule Project.
4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5 // Copyright (c) 1998-2011 Vadim Zeitlin ( zeitlin@dptmaths.ens-cachan.fr )
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
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.
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.
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
27 #include "CFile.h" // Interface declarations.
28 #include "Logger.h" // Needed for AddDebugLogLineC
29 #include <common/Path.h> // Needed for CPath
33 #include "config.h" // Needed for HAVE_SYS_PARAM_H
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
42 #if defined(__WXMSW__) && !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)
45 # define WIN32_LEAN_AND_MEAN
50 # define NOGDICAPMASKS
66 #elif (defined(__UNIX__) || defined(__GNUWIN32__))
70 #elif (defined(__WXPM__))
72 #elif (defined(__WXSTUBS__))
73 // Have to ifdef this for different environments
75 #elif (defined(__WXMAC__))
77 int access( const char *path
, int mode
) { return 0 ; }
79 int _access( const char *path
, int mode
) { return 0 ; }
81 char* mktemp( char * path
) { return path
;}
84 # error "Please specify the header with file functions declarations."
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)
94 #include <wx/msw/mslu.h>
98 // The following defines handle different names across platforms,
99 // and ensures that we use 64b IO on windows (only 32b by default).
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)
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
110 #define STAT_FD(x, y) _fstat64(x, y)
111 #define STAT_STRUCT struct __stat64
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)
120 #define FLUSH_FD(x) fsync(x)
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
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(
134 const CPath
& filePath
,
135 const wxString
& what
)
138 AddDebugLogLineC(logCFile
,
139 CFormat(wxT("Error when %s (%s): %s"))
140 % what
% filePath
% wxSysErrorMsg());
145 CSeekFailureException::CSeekFailureException(const wxString
& desc
)
146 : CIOFailureException(wxT("SeekFailure"), desc
)
151 : m_fd(fd_invalid
), m_safeWrite(false)
155 CFile::CFile(const CPath
& fileName
, OpenMode mode
)
158 Open(fileName
, mode
);
162 CFile::CFile(const wxString
& fileName
, OpenMode mode
)
165 Open(fileName
, mode
);
172 // If the writing gets aborted, dtor is still called.
173 // In this case do NOT replace the original file with the
174 // probably broken new one!
181 int CFile::fd() const
187 bool CFile::IsOpened() const
189 return m_fd
!= fd_invalid
;
193 const CPath
& CFile::GetFilePath() const
199 bool CFile::Create(const CPath
& path
, bool overwrite
, int accessMode
)
201 if (!overwrite
&& path
.FileExists()) {
205 return Open(path
, write
, accessMode
);
208 bool CFile::Create(const wxString
& path
, bool overwrite
, int accessMode
)
210 return Create(CPath(path
), overwrite
, accessMode
);
214 bool CFile::Open(const wxString
& fileName
, OpenMode mode
, int accessMode
)
216 MULE_VALIDATE_PARAMS(fileName
.Length(), wxT("CFile: Cannot open, empty path."));
218 return Open(CPath(fileName
), mode
, accessMode
);
222 bool CFile::Open(const CPath
& fileName
, OpenMode mode
, int accessMode
)
224 MULE_VALIDATE_PARAMS(fileName
.IsOk(), wxT("CFile: Cannot open, empty path."));
231 m_filePath
= fileName
;
234 int flags
= O_BINARY
| O_LARGEFILE
;
236 int flags
= O_BINARY
;
244 if (fileName
.FileExists())
246 flags
|= O_WRONLY
| O_APPEND
;
249 //else: fall through as write_append is the same as write if the
250 // file doesn't exist
253 flags
|= O_WRONLY
| O_CREAT
| O_TRUNC
;
257 flags
|= O_WRONLY
| O_CREAT
| O_TRUNC
;
258 m_filePath
= m_filePath
.AppendExt(wxT(".new"));
263 flags
|= O_WRONLY
| O_CREAT
| O_EXCL
;
271 // Windows needs wide character file names
273 m_fd
= _wopen(m_filePath
.GetRaw().c_str(), flags
, accessMode
);
275 Unicode2CharBuf tmpFileName
= filename2char(m_filePath
.GetRaw());
276 wxASSERT_MSG(tmpFileName
, wxT("Convertion failed in CFile::Open"));
277 m_fd
= open(tmpFileName
, flags
, accessMode
);
279 syscall_check(m_fd
!= fd_invalid
, m_filePath
, wxT("opening file"));
285 void CFile::Reopen(OpenMode mode
)
287 if (!Open(m_filePath
, mode
)) {
288 throw CIOFailureException(wxString(wxT("Error reopening file")));
295 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot close closed file."));
297 bool closed
= (close(m_fd
) != -1);
298 syscall_check(closed
, m_filePath
, wxT("closing file"));
303 CPath
filePathTemp(m_filePath
);
304 m_filePath
= m_filePath
.RemoveExt(); // restore m_filePath for Reopen()
306 closed
= CPath::RenameFile(filePathTemp
, m_filePath
, true);
316 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot flush closed file."));
318 bool flushed
= (FLUSH_FD(m_fd
) != -1);
319 syscall_check(flushed
, m_filePath
, wxT("flushing file"));
325 sint64
CFile::doRead(void* buffer
, size_t count
) const
327 MULE_VALIDATE_PARAMS(buffer
, wxT("CFile: Invalid buffer in read operation."));
328 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot read from closed file."));
330 size_t totalRead
= 0;
331 while (totalRead
< count
) {
332 int current
= ::read(m_fd
, (char*)buffer
+ totalRead
, count
- totalRead
);
335 // Read error, nothing we can do other than abort.
336 throw CIOFailureException(wxString(wxT("Error reading from file: ")) + wxSysErrorMsg());
337 } else if ((totalRead
+ current
< count
) && Eof()) {
338 // We may fail to read the specified count in a couple
339 // of situations: EOF and interrupts. The check for EOF
340 // is needed to avoid inf. loops.
344 totalRead
+= current
;
351 sint64
CFile::doWrite(const void* buffer
, size_t nCount
)
353 MULE_VALIDATE_PARAMS(buffer
, wxT("CFile: Invalid buffer in write operation."));
354 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot write to closed file."));
356 sint64 result
= ::write(m_fd
, buffer
, nCount
);
358 if (result
!= (sint64
)nCount
) {
359 throw CIOFailureException(wxString(wxT("Error writing to file: ")) + wxSysErrorMsg());
366 sint64
CFile::doSeek(sint64 offset
) const
368 MULE_VALIDATE_STATE(IsOpened(), wxT("Cannot seek on closed file."));
369 MULE_VALIDATE_PARAMS(offset
>= 0, wxT("Invalid position, must be positive."));
371 sint64 result
= SEEK_FD(m_fd
, offset
, SEEK_SET
);
373 if (result
== offset
) {
375 } else if (result
== wxInvalidOffset
) {
376 throw CSeekFailureException(wxString(wxT("Seeking failed: ")) + wxSysErrorMsg());
378 throw CSeekFailureException(wxT("Seeking returned incorrect position"));
383 uint64
CFile::GetPosition() const
385 MULE_VALIDATE_STATE(IsOpened(), wxT("Cannot get position in closed file."));
387 sint64 pos
= TELL_FD(m_fd
);
388 if (pos
== wxInvalidOffset
) {
389 throw CSeekFailureException(wxString(wxT("Failed to retrieve position in file: ")) + wxSysErrorMsg());
396 uint64
CFile::GetLength() const
398 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot get length of closed file."));
401 if (STAT_FD(m_fd
, &buf
) == -1) {
402 throw CIOFailureException(wxString(wxT("Failed to retrieve length of file: ")) + wxSysErrorMsg());
409 uint64
CFile::GetAvailable() const
411 const uint64 length
= GetLength();
412 const uint64 position
= GetPosition();
414 // Safely handle seeking past EOF
415 if (position
< length
) {
416 return length
- position
;
419 // File is at or after EOF
424 bool CFile::SetLength(uint64 new_len
)
426 MULE_VALIDATE_STATE(IsOpened(), wxT("CFile: Cannot set length when no file is open."));
430 // MSVC has a 64bit version
431 bool result
= _chsize_s(m_fd
, new_len
) == 0;
433 // MingW has an old runtime without it
434 bool result
= chsize(m_fd
, new_len
) == 0;
437 bool result
= ftruncate(m_fd
, new_len
) != -1;
440 syscall_check(result
, m_filePath
, wxT("truncating file"));
444 // File_checked_for_headers