qfile_unix.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qfile_unix.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of QFile class
**
** Created : 950628
**
** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses for Unix/X11 or for Qt/Embedded may use this file in accordance
** with the Qt Commercial License Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qplatformdefs.h"

// POSIX Large File Support redefines open -> open64
static inline int qt_open(const char *pathname, int flags, mode_t mode)
{ return ::open(pathname, flags, mode); }
#if defined(open)
# undef open
#endif

// POSIX Large File Support redefines truncate -> truncate64
#if defined(truncate)
# undef truncate
#endif

#include "qfile.h"
#include <errno.h>
#include <limits.h>


bool qt_file_access( const QString& fn, int t )
{
    if ( fn.isEmpty() )
        return FALSE;
    return ::access( QFile::encodeName(fn), t ) == 0;
}

bool QFile::remove( const QString &fileName )
{
    if ( fileName.isEmpty() ) {
#if defined(QT_CHECK_NULL)
        qWarning( "QFile::remove: Empty or null file name" );
#endif
        return FALSE;
    }
    return unlink( QFile::encodeName(fileName) ) == 0;
}

#if defined(O_NONBLOCK)
# define HAS_ASYNC_FILEMODE
# define OPEN_ASYNC O_NONBLOCK
#elif defined(O_NDELAY)
# define HAS_ASYNC_FILEMODE
# define OPEN_ASYNC O_NDELAY
#endif

bool QFile::open( int m )
{
    if ( isOpen() ) {                           // file already open
#if defined(QT_CHECK_STATE)
        qWarning( "QFile::open: File already open" );
#endif
        return FALSE;
    }
    if ( fn.isNull() ) {                        // no file name defined
#if defined(QT_CHECK_NULL)
        qWarning( "QFile::open: No file name specified" );
#endif
        return FALSE;
    }
    init();                                     // reset params
    setMode( m );
    if ( !(isReadable() || isWritable()) ) {
#if defined(QT_CHECK_RANGE)
        qWarning( "QFile::open: File access not specified" );
#endif
        return FALSE;
    }
    bool ok = TRUE;
    struct stat st;
    if ( isRaw() ) {
        int oflags = O_RDONLY;
        if ( isReadable() && isWritable() )
            oflags = O_RDWR;
        else if ( isWritable() )
            oflags = O_WRONLY;
        if ( flags() & IO_Append ) {            // append to end of file?
            if ( flags() & IO_Truncate )
                oflags |= (O_CREAT | O_TRUNC);
            else
                oflags |= (O_APPEND | O_CREAT);
            setFlags( flags() | IO_WriteOnly ); // append implies write
        } else if ( isWritable() ) {            // create/trunc if writable
            if ( flags() & IO_Truncate )
                oflags |= (O_CREAT | O_TRUNC);
            else
                oflags |= O_CREAT;
        }
#if defined(HAS_TEXT_FILEMODE)
        if ( isTranslated() )
            oflags |= OPEN_TEXT;
        else
            oflags |= OPEN_BINARY;
#endif
#if defined(HAS_ASYNC_FILEMODE)
        if ( isAsynchronous() )
            oflags |= OPEN_ASYNC;
#endif
        fd = qt_open( QFile::encodeName(fn), oflags, 0666 );

        if ( fd != -1 ) {                       // open successful
            ::fstat( fd, &st );                 // get the stat for later usage
        } else {
            ok = FALSE;
        }
    } else {                                    // buffered file I/O
        QCString perm;
        char perm2[4];
        bool try_create = FALSE;
        if ( flags() & IO_Append ) {            // append to end of file?
            setFlags( flags() | IO_WriteOnly ); // append implies write
            perm = isReadable() ? "a+" : "a";
        } else {
            if ( isReadWrite() ) {
                if ( flags() & IO_Truncate ) {
                    perm = "w+";
                } else {
                    perm = "r+";
                    try_create = TRUE;          // try to create if not exists
                }
            } else if ( isReadable() ) {
                perm = "r";
            } else if ( isWritable() ) {
                perm = "w";
            }
        }
        qstrcpy( perm2, perm );
#if defined(HAS_TEXT_FILEMODE)
        if ( isTranslated() )
            strcat( perm2, "t" );
        else
            strcat( perm2, "b" );
#endif
        for (;;) { // At most twice

            fh = fopen( QFile::encodeName(fn), perm2 );

            if ( !fh && try_create ) {
                perm2[0] = 'w';                 // try "w+" instead of "r+"
                try_create = FALSE;
            } else {
                break;
            }
        }
        if ( fh ) {
            ::fstat( fileno(fh), &st );         // get the stat for later usage
        } else {
            ok = FALSE;
        }
    }
    if ( ok ) {
        setState( IO_Open );
        // on successful open the file stat was got; now test what type
        // of file we have
        if ( (st.st_mode & S_IFMT) != S_IFREG ) {
            // non-seekable
            setType( IO_Sequential );
            length = INT_MAX;
            ioIndex = 0;
        } else {
            length = (Offset)st.st_size;
            ioIndex = (flags() & IO_Append) == 0 ? 0 : length;
            if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
                // try if you can read from it (if you can, it's a sequential
                // device; e.g. a file in the /proc filesystem)
                int c = getch();
                if ( c != -1 ) {
                    ungetch(c);
                    setType( IO_Sequential );
                    length = INT_MAX;
                    ioIndex = 0;
                }
            }
        }
    } else {
        init();
        if ( errno == EMFILE )                  // no more file handles/descrs
            setStatus( IO_ResourceError );
        else
            setStatus( IO_OpenError );
    }
    return ok;
}

bool QFile::open( int m, FILE *f )
{
    if ( isOpen() ) {
#if defined(QT_CHECK_RANGE)
        qWarning( "QFile::open: File already open" );
#endif
        return FALSE;
    }
    init();
    setMode( m &~IO_Raw );
    setState( IO_Open );
    fh = f;
    ext_f = TRUE;
    struct stat st;
    ::fstat( fileno(fh), &st );
#if defined(QT_LARGEFILE_SUPPORT)
    ioIndex = (Offset)ftello( fh );
#else
    ioIndex = (Offset)ftell( fh );
#endif
    if ( (st.st_mode & S_IFMT) != S_IFREG || f == stdin ) { //stdin is non seekable
        // non-seekable
        setType( IO_Sequential );
        length = INT_MAX;
        ioIndex = 0;
    } else {
        length = (Offset)st.st_size;
        if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
            // try if you can read from it (if you can, it's a sequential
            // device; e.g. a file in the /proc filesystem)
            int c = getch();
            if ( c != -1 ) {
                ungetch(c);
                setType( IO_Sequential );
                length = INT_MAX;
                ioIndex = 0;
            }
        }
    }
    return TRUE;
}

bool QFile::open( int m, int f )
{
    if ( isOpen() ) {
#if defined(QT_CHECK_RANGE)
        qWarning( "QFile::open: File already open" );
#endif
        return FALSE;
    }
    init();
    setMode( m |IO_Raw );
    setState( IO_Open );
    fd = f;
    ext_f = TRUE;
    struct stat st;
    ::fstat( fd, &st );
    ioIndex = (Offset)::lseek(fd, 0, SEEK_CUR);
    if ( (st.st_mode & S_IFMT) != S_IFREG || f == 0 ) { // stdin is not seekable...
        // non-seekable
        setType( IO_Sequential );
        length = INT_MAX;
        ioIndex = 0;
    } else {
        length = (Offset)st.st_size;
        if ( length == 0 && isReadable() ) {
            // try if you can read from it (if you can, it's a sequential
            // device; e.g. a file in the /proc filesystem)
            int c = getch();
            if ( c != -1 ) {
                ungetch(c);
                setType( IO_Sequential );
                length = INT_MAX;
                ioIndex = 0;
            }
            resetStatus();
        }
    }
    return TRUE;
}

QIODevice::Offset QFile::size() const
{
    struct stat st;
    int ret = 0;
    if ( isOpen() ) {
        ret = ::fstat( fh ? fileno(fh) : fd, &st );
    } else {
        ret = ::stat( QFile::encodeName(fn), &st );
    }
    if ( ret == -1 )
        return 0;
#if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_64BITOFFSET)
    return (uint)st.st_size > UINT_MAX ? UINT_MAX : (QIODevice::Offset)st.st_size;
#else
    return st.st_size;
#endif
}


bool QFile::at( Offset pos )
{
    if ( !isOpen() ) {
#if defined(QT_CHECK_STATE)
        qWarning( "QFile::at: File is not open" );
#endif
        return FALSE;
    }
    if ( isSequentialAccess() )
        return FALSE;
    bool ok;
    if ( isRaw() ) {
        off_t l = ::lseek( fd, pos, SEEK_SET );
        ok = ( l != -1 );
        pos = (Offset)l;
    } else {                                    // buffered file
#if defined(QT_LARGEFILE_SUPPORT)
        ok = ( ::fseeko(fh, pos, SEEK_SET) == 0 );
#else
        ok = ( ::fseek(fh, pos, SEEK_SET) == 0 );
#endif
    }
    if ( ok )
        ioIndex = pos;
#if defined(QT_CHECK_RANGE)
    else
#if defined(QT_LARGEFILE_SUPPORT) && defined(QT_ABI_64BITOFFSET)
        qWarning( "QFile::at: Cannot set file position %llu", pos );
#else
        qWarning( "QFile::at: Cannot set file position %lu", pos );
#endif
#endif
    return ok;
}

Q_LONG QFile::readBlock( char *p, Q_ULONG len )
{
#if defined(QT_CHECK_NULL)
    if ( !p )
        qWarning( "QFile::readBlock: Null pointer error" );
#endif
#if defined(QT_CHECK_STATE)
    if ( !isOpen() ) {
        qWarning( "QFile::readBlock: File not open" );
        return -1;
    }
    if ( !isReadable() ) {
        qWarning( "QFile::readBlock: Read operation not permitted" );
        return -1;
    }
#endif
    Q_ULONG nread = 0;                                  // number of bytes read
    if ( !ungetchBuffer.isEmpty() ) {
        // need to add these to the returned string.
        uint l = ungetchBuffer.length();
        while( nread < l ) {
            *p = ungetchBuffer.at( l - nread - 1 );
            p++;
            nread++;
        }
        ungetchBuffer.truncate( l - nread );
    }

    if ( nread < len ) {
        if ( isRaw() ) {                                // raw file
            nread += ::read( fd, p, len-nread );
            if ( len && nread <= 0 ) {
                nread = 0;
                setStatus(IO_ReadError);
            }
        } else {                                        // buffered file
            nread += fread( p, 1, len-nread, fh );
            if ( (uint)nread != len ) {
                if ( ferror( fh ) || nread==0 )
                    setStatus(IO_ReadError);
            }
        }
    }
    if ( !isSequentialAccess() )
        ioIndex += nread;
    return nread;
}


Q_LONG QFile::writeBlock( const char *p, Q_ULONG len )
{
#if defined(QT_CHECK_NULL)
    if ( p == 0 && len != 0 )
        qWarning( "QFile::writeBlock: Null pointer error" );
#endif
#if defined(QT_CHECK_STATE)
    if ( !isOpen() ) {                          // file not open
        qWarning( "QFile::writeBlock: File not open" );
        return -1;
    }
    if ( !isWritable() ) {                      // writing not permitted
        qWarning( "QFile::writeBlock: Write operation not permitted" );
        return -1;
    }
#endif
    Q_ULONG nwritten;                           // number of bytes written
    if ( isRaw() )                              // raw file
        nwritten = ::write( fd, (void *)p, len );
    else                                        // buffered file
        nwritten = fwrite( p, 1, len, fh );
    if ( nwritten != len ) {            // write error
        if ( errno == ENOSPC )                  // disk is full
            setStatus( IO_ResourceError );
        else
            setStatus( IO_WriteError );
        if ( !isSequentialAccess() ) {
            if ( isRaw() )                      // recalc file position
                ioIndex = (Offset)::lseek( fd, 0, SEEK_CUR );
            else
#if defined(QT_LARGEFILE_SUPPORT)
                ioIndex = (Offset)::fseeko( fh, 0, SEEK_CUR );
#else
                ioIndex = (Offset)::fseek( fh, 0, SEEK_CUR );
#endif
        }
    } else {
        if ( !isSequentialAccess() )
            ioIndex += nwritten;
    }
    if ( ioIndex > length )                     // update file length
        length = ioIndex;
    return nwritten;
}

int QFile::handle() const
{
    if ( !isOpen() )
        return -1;
    else if ( fh )
        return fileno( fh );
    else
        return fd;
}

void QFile::close()
{
    bool ok = FALSE;
    if ( isOpen() ) {                           // file is not open
        if ( fh ) {                             // buffered file
            if ( ext_f )
                ok = fflush( fh ) != -1;        // flush instead of closing
            else
                ok = fclose( fh ) != -1;
        } else {                                // raw file
            if ( ext_f )
                ok = TRUE;                      // cannot close
            else
                ok = ::close( fd ) != -1;
        }
        init();                                 // restore internal state
    }
    if (!ok)
        setStatus( IO_UnspecifiedError );

    return;
}

---