gfile_unix.cpp

Go to the documentation of this file.

//
// Copyright (C) 2017 Graeme Walker
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===
//
// gfile_unix.cpp
//
    
#include "gdef.h"
#include "glimits.h"
#include "gfile.h"
#include "gprocess.h"
#include "gdebug.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <vector>
#include <sstream>

namespace
{
    G::EpochTime mtime( struct stat & statbuf )
    {
#if GCONFIG_HAVE_STATBUF_NSEC
        return G::EpochTime( statbuf.st_mtime , statbuf.st_mtim.tv_nsec/1000U ) ;
#else
        return G::EpochTime( statbuf.st_mtime ) ;
#endif
    }
}

bool G::File::mkdir( const Path & dir , const NoThrow & )
{
    // open permissions, but limited by umask
    return 0 == ::mkdir( dir.str().c_str() , 0777 ) ;
}

bool G::File::exists( const char * path , bool & enoent , bool & eaccess )
{
    struct stat statbuf ;
    if( 0 == ::stat( path , &statbuf ) )
    {
        return true ;
    }
    else
    {
        int error = G::Process::errno_() ;
        enoent = error == ENOENT || error == ENOTDIR ;
        eaccess = error == EACCES ;
        return false ;
    }
}

bool G::File::isDirectory( const Path & path )
{
    struct stat statbuf ;
    return 0 == ::stat( path.str().c_str() , &statbuf ) && (statbuf.st_mode & S_IFDIR) ;
}

bool G::File::executable( const Path & path )
{
    struct stat statbuf ;
    if( 0 == ::stat( path.str().c_str() , &statbuf ) )
    {
        bool x = !!( statbuf.st_mode & S_IXUSR ) ;
        bool r = 
            ( statbuf.st_mode & S_IFMT ) == S_IFREG ||
            ( statbuf.st_mode & S_IFMT ) == S_IFLNK ;
        return x && r ; // indicitive only
    }
    else
    {
        return false ;
    }
}

std::string G::File::sizeString( const Path & path )
{
    struct stat statbuf ;
    if( 0 != ::stat( path.str().c_str() , &statbuf ) )
        return std::string() ;

    std::ostringstream ss ;
    ss << statbuf.st_size ;
    return ss.str() ;
}

G::EpochTime G::File::time( const Path & path )
{
    struct stat statbuf ;
    if( 0 != ::stat( path.str().c_str() , &statbuf ) )
        throw TimeError( path.str() ) ;
    return mtime( statbuf ) ;
}

G::EpochTime G::File::time( const Path & path , const NoThrow & )
{
    struct stat statbuf ;
    if( ::stat( path.str().c_str() , &statbuf ) != 0 ) 
        return EpochTime( 0 ) ;
    return mtime( statbuf ) ;
}

bool G::File::chmodx( const Path & path , bool do_throw )
{
    mode_t mode = 0 ;
    struct stat statbuf ;
    if( 0 == ::stat( path.str().c_str() , &statbuf ) )
    {
        mode = statbuf.st_mode | S_IRUSR | S_IXUSR ; // add user-read and user-executable
        if( mode & S_IRGRP ) mode |= S_IXGRP ; // add group-executable iff group-read
        if( mode & S_IROTH ) mode |= S_IXOTH ; // add world-executable iff world-read
    }
    else
    {
        // shouldnt really get here -- default to open permissions, but limited by umask
        mode = 0777 ;
    }

    // apply the current umask
    mode_t mask = ::umask( ::umask(0) ) ;
    mode &= ~mask ;

    bool ok = 0 == ::chmod( path.str().c_str() , mode ) ;
    if( !ok && do_throw )
        throw CannotChmod( path.str() ) ;
    return ok ;
}

void G::File::link( const Path & target , const Path & new_link )
{
    if( !link(target,new_link,NoThrow()) )
    {
        int error = G::Process::errno_() ; // keep first
        std::ostringstream ss ;
        ss << "[" << new_link << "] -> [" << target << "] " "(" << error << ")" ;
        throw CannotLink( ss.str() ) ;
    }
}

bool G::File::link( const Path & target , const Path & new_link , const NoThrow & )
{
    // see if already linked correctly, as an optimisation - errors and overflows are not fatal
    std::vector<char> buffer( limits::path , '\0' ) ;
    ssize_t rc = ::readlink( new_link.str().c_str() , &buffer[0] , buffer.size() ) ;
    size_t n = rc < 0 ? size_t(0U) : static_cast<size_t>(rc) ;
    if( rc > 0 && n != buffer.size() )
    {
        std::string old_target( &buffer[0] , n ) ;
        if( target.str() == old_target )
            return true ;
    }

    if( exists(new_link) )
        remove( new_link , NoThrow() ) ;

    rc = ::symlink( target.str().c_str() , new_link.str().c_str() ) ;
    // dont put anything here (preserve errno)
    return rc == 0 ;
}

/// \file gfile_unix.cpp