/*!
\internal
*/
qint64 QFSFileEnginePrivate::readLineFdFh(char *data, qint64 maxlen)
{
Q_Q(QFSFileEngine);
if (!fh)
return q->QAbstractFileEngine::readLine(data, maxlen);
QT_OFF_T oldPos = 0;
#ifdef Q_OS_WIN
bool seq = q->isSequential();
if (!seq)
#endif
oldPos = QT_FTELL(fh);
// QIODevice::readLine() passes maxlen - 1 to QFile::readLineData()
// because it has made space for the '\0' at the end of data. But fgets
// does the same, so we'd get two '\0' at the end - passing maxlen + 1
// solves this.
if (!fgets(data, int(maxlen + 1), fh)) {
if (!feof(fh))
q->setError(QFile::ReadError, qt_error_string(int(errno)));
return -1; // error
}
#ifdef Q_OS_WIN
if (seq)
return qstrlen(data);
#endif
qint64 lineLength = QT_FTELL(fh) - oldPos;
return lineLength > 0 ? lineLength : qstrlen(data);
}
/*!
\overload
Opens the existing file handle \a fh in the given \a mode.
Returns true if successful; otherwise returns false.
Example:
\snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 3
When a QFile is opened using this function, close() does not actually
close the file, but only flushes it.
\bold{Warning:}
\list 1
\o If \a fh does not refer to a regular file, e.g., it is \c stdin,
\c stdout, or \c stderr, you may not be able to seek(). size()
returns \c 0 in those cases. See QIODevice::isSequential() for
more information.
\o Since this function opens the file without specifying the file name,
you cannot use this QFile with a QFileInfo.
\endlist
\note For Windows CE you may not be able to call resize().
\sa close(), {qmake Variable Reference#CONFIG}{qmake Variable Reference}
\bold{Note for the Windows Platform}
\a fh must be opened in binary mode (i.e., the mode string must contain
'b', as in "rb" or "wb") when accessing files and other random-access
devices. Qt will translate the end-of-line characters if you pass
QIODevice::Text to \a mode. Sequential devices, such as stdin and stdout,
are unaffected by this limitation.
You need to enable support for console applications in order to use the
stdin, stdout and stderr streams at the console. To do this, add the
following declaration to your application's project file:
\snippet doc/src/snippets/code/src_corelib_io_qfile.cpp 4
*/
bool QFile::open(FILE *fh, OpenMode mode)
{
Q_D(QFile);
if (isOpen()) {
qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
return false;
}
if (mode & Append)
mode |= WriteOnly;
unsetError();
if ((mode & (ReadOnly | WriteOnly)) == 0) {
qWarning("QFile::open: File access not specified");
return false;
}
if(d->openExternalFile(mode, fh)) {
QIODevice::open(mode);
if (mode & Append) {
seek(size());
} else {
qint64 pos = (qint64)QT_FTELL(fh);
if (pos != -1)
seek(pos);
}
return true;
}
return false;
}
/*!
\overload
Opens the existing file handle \a fh in the given \a mode.
\a handleFlags may be used to specify additional options.
Returns true if successful; otherwise returns false.
Example:
\snippet code/src_corelib_io_qfile.cpp 3
When a QFile is opened using this function, behaviour of close() is
controlled by the AutoCloseHandle flag.
If AutoCloseHandle is specified, and this function succeeds,
then calling close() closes the adopted handle.
Otherwise, close() does not actually close the file, but only flushes it.
\b{Warning:}
\list 1
\li If \a fh does not refer to a regular file, e.g., it is \c stdin,
\c stdout, or \c stderr, you may not be able to seek(). size()
returns \c 0 in those cases. See QIODevice::isSequential() for
more information.
\li Since this function opens the file without specifying the file name,
you cannot use this QFile with a QFileInfo.
\endlist
\note For Windows CE you may not be able to call resize().
\sa close()
\b{Note for the Windows Platform}
\a fh must be opened in binary mode (i.e., the mode string must contain
'b', as in "rb" or "wb") when accessing files and other random-access
devices. Qt will translate the end-of-line characters if you pass
QIODevice::Text to \a mode. Sequential devices, such as stdin and stdout,
are unaffected by this limitation.
You need to enable support for console applications in order to use the
stdin, stdout and stderr streams at the console. To do this, add the
following declaration to your application's project file:
\snippet code/src_corelib_io_qfile.cpp 4
*/
bool QFile::open(FILE *fh, OpenMode mode, FileHandleFlags handleFlags)
{
Q_D(QFile);
if (isOpen()) {
qWarning("QFile::open: File (%s) already open", qPrintable(fileName()));
return false;
}
if (mode & Append)
mode |= WriteOnly;
unsetError();
if ((mode & (ReadOnly | WriteOnly)) == 0) {
qWarning("QFile::open: File access not specified");
return false;
}
if (d->openExternalFile(mode, fh, handleFlags)) {
QIODevice::open(mode);
if (!(mode & Append) && !isSequential()) {
qint64 pos = (qint64)QT_FTELL(fh);
if (pos != -1) {
// Skip redundant checks in QFileDevice::seek().
QIODevice::seek(pos);
}
}
return true;
}
return false;
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::ReadError, qt_error_string(EINVAL));
return -1;
}
qint64 readBytes = 0;
bool eof = false;
if (fh) {
// Buffered stdlib mode.
size_t result;
bool retry = true;
do {
result = fread(data + readBytes, 1, size_t(len - readBytes), fh);
eof = feof(fh);
if (retry && eof && result == 0) {
// On OS X, this is needed, e.g., if a file was written to
// through another stream since our last read. See test
// tst_QFile::appendAndRead
QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET); // re-sync stream.
retry = false;
continue;
}
readBytes += result;
} while (!eof && (result == 0 ? errno == EINTR : readBytes < len));
} else if (fd != -1) {
// Unbuffered stdio mode.
SignedIOType result;
do {
// calculate the chunk size
// on Windows or 32-bit no-largefile Unix, we'll need to read in chunks
// we limit to the size of the signed type, otherwise we could get a negative number as a result
quint64 wantedBytes = quint64(len) - quint64(readBytes);
UnsignedIOType chunkSize = std::numeric_limits<SignedIOType>::max();
if (chunkSize > wantedBytes)
chunkSize = wantedBytes;
result = QT_READ(fd, data + readBytes, chunkSize);
} while (result > 0 && (readBytes += result) < len);
eof = !(result == -1);
}
if (!eof && readBytes == 0) {
readBytes = -1;
q->setError(QFile::ReadError, qt_error_string(errno));
}
return readBytes;
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::ReadError, qt_error_string(EINVAL));
return -1;
}
qint64 readBytes = 0;
bool eof = false;
if (fh) {
// Buffered stdlib mode.
size_t result;
bool retry = true;
do {
result = fread(data + readBytes, 1, size_t(len - readBytes), fh);
eof = feof(fh);
if (retry && eof && result == 0) {
// On Mac OS, this is needed, e.g., if a file was written to
// through another stream since our last read. See test
// tst_QFile::appendAndRead
QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET); // re-sync stream.
retry = false;
continue;
}
readBytes += result;
} while (!eof && (result == 0 ? errno == EINTR : readBytes < len));
} else if (fd != -1) {
// Unbuffered stdio mode.
#ifdef Q_OS_WIN
int result;
#else
ssize_t result;
#endif
do {
result = QT_READ(fd, data + readBytes, size_t(len - readBytes));
} while ((result == -1 && errno == EINTR)
|| (result > 0 && (readBytes += result) < len));
eof = !(result == -1);
}
if (!eof && readBytes == 0) {
readBytes = -1;
q->setError(QFile::ReadError, qt_error_string(errno));
}
return readBytes;
}
/*
\internal
*/
qint64 QFSFileEnginePrivate::nativeSize() const
{
Q_Q(const QFSFileEngine);
QFSFileEngine *thatQ = const_cast<QFSFileEngine *>(q);
// ### Don't flush; for buffered files, we should get away with ftell.
thatQ->flush();
// Always retrive the current information
metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
#if defined(Q_OS_WINCE)
// Buffered stdlib mode.
if (fh) {
QT_OFF_T oldPos = QT_FTELL(fh);
QT_FSEEK(fh, 0, SEEK_END);
qint64 fileSize = (qint64)QT_FTELL(fh);
QT_FSEEK(fh, oldPos, SEEK_SET);
if (fileSize == -1) {
fileSize = 0;
thatQ->setError(QFile::UnspecifiedError, qt_error_string(errno));
}
return fileSize;
}
if (fd != -1) {
thatQ->setError(QFile::UnspecifiedError, QLatin1String("Not implemented!"));
return 0;
}
#endif
bool filled = false;
if (fileHandle != INVALID_HANDLE_VALUE && openMode != QIODevice::NotOpen )
filled = QFileSystemEngine::fillMetaData(fileHandle, metaData,
QFileSystemMetaData::SizeAttribute);
else
filled = doStat(QFileSystemMetaData::SizeAttribute);
if (!filled) {
thatQ->setError(QFile::UnspecifiedError, qt_error_string(errno));
return 0;
}
return metaData.size();
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::posFdFh() const
{
if (fh)
return qint64(QT_FTELL(fh));
return QT_LSEEK(fd, 0, SEEK_CUR);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
{
Q_Q(QFSFileEngine);
// Buffered stdlib mode.
if (fh) {
qint64 readBytes = 0;
qint64 read = 0;
int retry = 0;
// Read in blocks of 4k to avoid platform limitations (Windows
// commonly bails out if you read or write too large blocks at once).
qint64 bytesToRead;
do {
if (retry == 1)
retry = 2;
bytesToRead = qMin<qint64>(4096, len - read);
do {
readBytes = fread(data + read, 1, size_t(bytesToRead), fh);
} while (readBytes == 0 && !feof(fh) && errno == EINTR);
if (readBytes > 0) {
read += readBytes;
} else if (!retry && feof(fh)) {
// Synchronize and try again (just once though).
if (++retry == 1)
QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET);
}
} while (retry == 1 || (readBytes == bytesToRead && read < len));
// Return the number of bytes read, or if nothing was read, return -1
// if an error occurred, or 0 if we detected EOF.
if (read == 0) {
q->setError(QFile::ReadError, qt_error_string(int(errno)));
if (!feof(fh))
read = -1;
}
return read;
}
// Unbuffered stdio mode.
qint64 ret = 0;
if (len) {
int result;
qint64 read = 0;
errno = 0;
// Read in blocks of 4k to avoid platform limitations (Windows
// commonly bails out if you read or write too large blocks at once).
do {
qint64 bytesToRead = qMin<qint64>(4096, len - read);
do {
result = QT_READ(fd, data + read, int(bytesToRead));
} while (result == -1 && errno == EINTR);
if (result > 0)
read += result;
} while (result > 0 && read < len);
// Return the number of bytes read, or if nothing was read, return -1
// if an error occurred.
if (read > 0) {
ret += read;
} else if (read == 0 && result < 0) {
ret = -1;
q->setError(QFile::ReadError, qt_error_string(errno));
}
}
return ret;
}
