CRNIO.cpp

Go to the documentation of this file.

/* Copyright 2006-2014 Yann LEYDIER, INSA-Lyon, CoReNum
 *
 * This file is part of libcrn.
 *
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libcrn 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 *
 * file: CRNIO.cpp
 * \author Yann LEYDIER
 */

#include <CRNIO/CRNIO.h>
#include <CRNIO/CRNConsoleMessenger.h>

#include <cstdio>
#include <sys/stat.h>
#include <fstream>
#include <CRNException.h>
#include <CRNIO/CRNFileShield.h>
#include <CRNUtils/CRNAtScopeExit.h>
#ifdef _MSC_VER
#   include "./3rdParty/_msvc_only_/dirent.hh"
#   include <direct.h> // for mkdir & rmdir
#   define access _access
#else
#   include <dirent.h>
#   include <unistd.h>
#endif
#include <string.h>
#include <CRNi18n.h>

using namespace crn;

bool& IO::IsQuiet()
{
    static bool quiet = false;
    return quiet;
}

bool& IO::IsVerbose()
{
    static bool verbose = false;
    return verbose;
}


std::shared_ptr<Messenger>& IO::CurrentMessenger()
{
    static std::shared_ptr<Messenger> messenger(std::make_shared<ConsoleMessenger>());
    return messenger;
}

/*****************************************************************************/
void IO::Debug(const String &msg)
{
    if (!IsQuiet())
    {
        CurrentMessenger()->PrintDebug(msg);
    }
}

/*****************************************************************************/
void IO::Warning(const String &msg)
{
    if (!IsQuiet())
    {
        CurrentMessenger()->PrintWarning(msg);
    }
}

/*****************************************************************************/
void IO::Verbose(const String &msg)
{
    if (IsVerbose() && !IsQuiet())
    {
        CurrentMessenger()->PrintVerbose(msg);
    }
}

/*****************************************************************************/
void IO::Error(const String &msg)
{
    if (!IsQuiet())
    {
        CurrentMessenger()->PrintError(msg);
    }
}

void IO::Mkdir(const Path &name)
{
    int res = 0;
#if defined(_MSC_VER)
    Path winname(name);
    winname.ToWindows();
    res = _mkdir(winname.CStr());
#else
    Path unixname(name);
    unixname.ToUnix();
    res = mkdir(unixname.CStr(), S_IRWXU|S_IRWXG|S_IRGRP|S_IXGRP); // user and group can write. other can read & execute
#endif
    if (res)
        throw ExceptionIO(_("Cannot create directory: ") + StringUTF8(name));
}

bool IO::Access(const Path &name, int mode)
{
    Path lname(name);
    lname.ToLocal();
    return access(lname.CStr(), mode) == 0 ? true : false;
}

void IO::Rm(const Path &name)
{
    bool ok;
    Path lname(name);
    lname.ToLocal();
    ok = remove(lname.CStr()) == 0;
    if (!ok)
        throw ExceptionIO(_("Cannot remove: ") + StringUTF8(name));

}

void IO::ShieldRm(const Path &name)
{
    std::lock_guard<std::mutex> lock(FileShield::GetMutex(name));
    Rm(name);
}

void IO::Rmdir(const Path &name)
{
    Path lname(name);
    lname.ToLocal();
    DIR* d=opendir(lname.CStr());
    if(!d)
    {
        throw ExceptionIO(_("Cannot open directory: ") + StringUTF8(lname));
    }
    AtScopeExit([d](){ closedir(d); });
    struct dirent* diren=readdir(d);
    while(diren)
    {

        if((!strcmp(diren->d_name,"."))||(!strcmp(diren->d_name,"..")))
        {
            diren=readdir(d);
            continue;
        }
        char fname[1024];
        snprintf(fname,1024,"%s/%s", lname.CStr(), diren->d_name);
        DIR *tempdir;
        tempdir = opendir(fname);
        if (tempdir)
        {
            closedir(tempdir); tempdir = nullptr;
            strcat(fname,"/");
            Rmdir(fname);
        }
        else
        {
            if(remove(fname) !=0)
            {
                throw ExceptionIO(_("Cannot remove file: ") + StringUTF8(fname));
            }
        }
        diren=readdir(d);
    }
    int ret;
#ifdef _MSC_VER
    ret = _rmdir(lname.CStr());
#else
    ret = remove(lname.CStr());
#endif
    if (ret)
        throw ExceptionIO(_("Cannot remove directory: ") + StringUTF8(name));

}

void IO::Copy(const Path &src, const Path &dst)
{
    if (src == dst)
        throw ExceptionInvalidArgument(_("Cannot copy a file over itself."));

    std::ifstream s;
    std::ofstream d;

    Path locsrc(src);
    locsrc.ToLocal();
    Path locdst(dst);
    locdst.ToLocal();
    s.open(locsrc.CStr(), std::ios::binary);
    if (!s.is_open())
        throw ExceptionInvalidArgument(_("Cannot open source file: ") + StringUTF8(locsrc));
    d.open(locdst.CStr(), std::ios::binary);
    if (!d.is_open())
        throw ExceptionInvalidArgument(_("Cannot open destination file: ") + StringUTF8(locdst));

    d << s.rdbuf();
    d.close();
    s.close();
}

void IO::ShieldCopy(const Path &src, const Path &dst)
{
    if (src == dst) // check before creating the mutex to avoid dead lock!
        throw ExceptionInvalidArgument(_("Cannot copy a file over itself."));
    std::lock_guard<std::mutex> locks(FileShield::GetMutex(src));
    std::lock_guard<std::mutex> lockd(FileShield::GetMutex(dst));
    Copy(src, dst);
}

IO::Directory::Directory(const Path &path)
{
    Path lname(path);
    lname.ToLocal();
    DIR* d = opendir(lname.CStr());
    if(!d)
    {
        throw ExceptionIO(StringUTF8(_("Cannot open directory: ")) + StringUTF8(lname));
    }
    struct dirent* diren=readdir(d);
    while(diren)
    {

        if((!strcmp(diren->d_name,"."))||(!strcmp(diren->d_name,"..")))
        {
            diren=readdir(d);
            continue;
        }
        Path fname(lname);
        fname /= diren->d_name;
        DIR *tempdir;
        tempdir = opendir(fname.CStr());
        if (tempdir)
        {
            closedir(tempdir); tempdir = nullptr;
            directories.push_back(fname);
        }
        else
        {
            files.push_back(fname);
        }
        diren = readdir(d);
    }
    closedir(d);

}