File.cpp

/*
** libutil++
** $Id: File.cpp 1669 2016-04-09 20:07:12Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: File.cpp 1669 2016-04-09 20:07:12Z sella $";

#include "File.h"
#include "CommonMacro.h"
#include "String.h"

#include <dirent.h>

#include <fstream>

using namespace sella::util;

const std::string File::any = "^.*";
const std::set<uint8_t> File::all = { DT_BLK, DT_CHR, DT_DIR, DT_FIFO, DT_LNK, DT_REG, DT_SOCK, DT_UNKNOWN };
const std::set<uint8_t> File::regular = { DT_LNK, DT_REG, DT_UNKNOWN };
const std::set<uint8_t> File::files = { DT_BLK, DT_CHR, DT_FIFO, DT_LNK, DT_REG, DT_SOCK, DT_UNKNOWN };
const std::set<uint8_t> File::dirs = { DT_DIR };

std::string File::getBaseName(const std::string &fullpath) throw () {
        if (fullpath.empty()) {
                return fullpath;
        }

        return fullpath.substr(fullpath.rfind('/') + 1);
}

std::string File::getDirName(const std::string &fullpath) throw () {
        if (fullpath.empty()) {
                return fullpath;
        }

        return fullpath.substr(0, fullpath.rfind('/'));
}

std::string File::getRealPath(const std::string &fullpath) throw (FileException) {
        char realPath[PATH_MAX];

        if (fullpath.empty()) {
                return fullpath;
        }

        if (::realpath(fullpath.c_str(), realPath) != NULL) {
                return std::string(realPath);
        }

        THROW2(FileException, "realpath()");
}

std::vector<std::string> File::getDirectory(const std::string &path, const std::string &regex, const std::set<uint8_t> &types) throw (FileException) {
        std::vector<std::string> results;
        struct dirent entry, *result;
        DIR *dir;
        int e;

        if ((dir = opendir(path.c_str())) == NULL) {
                THROW(FileException, "failed to open %s", path.c_str());
        }

        try {
                boost::regex re(regex);

                for (;;) {
                        if ((e = readdir_r(dir, &entry, &result)) != 0) {
                                closedir(dir);

                                THROW2(FileException, "Failed to read directory %s", path.c_str());
                        }

                        if (result == NULL) {
                                break;
                        }

                        if (types.count(result->d_type) > 0) {
                                if (String::regex_search(result->d_name, re)) {
                                        results.push_back(result->d_name);
                                }
                        }
                }
        } catch (RegexException &e) {
                closedir(dir);

                RETHROW(FileException, e);
        }

        closedir(dir);

        return results;
}

std::string File::read(const std::string &fullpath, size_t limit, std::ios_base::openmode mode) throw (FileException) {
        std::ifstream file(fullpath, mode);

        if (!file.is_open() || !file.good()) {
                THROW(FileException, "Failed to open file %s for reading", fullpath.c_str());
        }

        file.seekg(0, std::ios::end);
        std::streamsize size = file.tellg();
        file.seekg(0, std::ios::beg);

        if (size == -1) { /* Slow path - /proc entries need this */
                std::string buf((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());

                if (limit > 0 && buf.size() > limit) {
                        buf.resize(limit);
                }

                return buf;
        } else { /* Fast path */
                size_t len = (limit == 0 || (size_t) size < limit) ? size : limit;
                std::string buf(len, '\0'); /* Reserve and set string size */

                if (!file.read((char*) buf.data(), len)) {
                        THROW(FileException, "Failed to read file %s", fullpath.c_str());
                }

                return buf;
        }
}

std::string File::readline(const std::string &fullpath, char delim, std::ios_base::openmode mode) throw (FileException) {
        std::ifstream file(fullpath, mode);

        if (!file.is_open() || !file.good()) {
                THROW(FileException, "Failed to open file %s for reading", fullpath.c_str());
        }

        std::string buf;

        std::getline(file, buf, delim);

        return buf;
}

std::vector<std::string> File::readlines(const std::string &fullpath, size_t limit, char delim, std::ios_base::openmode mode) throw (FileException) {
        std::ifstream file(fullpath, mode);

        if (!file.is_open() || !file.good()) {
                THROW(FileException, "Failed to open file %s for reading", fullpath.c_str());
        }

        size_t count = 0;
        std::string buf;
        std::vector<std::string> lines;

        lines.reserve((limit > 0) ? limit : 32);

        //for (std::string line; std::getline(file, buf, delim);) {
        while (std::getline(file, buf, delim)) {
                lines.push_back(buf);

                if (limit > 0 && ++count > limit) {
                        break;
                }
        }

        return lines;
}

void File::write(const std::string &fullpath, const std::string &data, std::ios_base::openmode mode) throw (FileException) {
        std::ofstream file(fullpath, mode);

        if (!file.is_open() || !file.good()) {
                THROW(FileException, "Failed to open file %s for writing", fullpath.c_str());
        }

        if (!file.write((char*) data.data(), data.size())) {
                THROW(FileException, "Failed to write to file %s", fullpath.c_str());
        }
}

bool File::exists(const std::string &fullpath, bool followSymlink) throw () {
        struct stat sb;

        if (followSymlink) {
                return (stat(fullpath.c_str(), &sb) == 0);
        } else {
                return (lstat(fullpath.c_str(), &sb) == 0);
        }
}

bool File::isReadable(const std::string &fullpath) throw () {
        std::ifstream file(fullpath);

        if (!file.is_open() || !file.good()) {
                return false;
        }

        return true;
}

bool File::isRegularFile(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISREG(File::getMode(fullpath, followSymlink));
}

bool File::isDirectory(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISDIR(File::getMode(fullpath, followSymlink));
}

bool File::isCharacterDevice(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISCHR(File::getMode(fullpath, followSymlink));
}

bool File::isBlockDevice(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISBLK(File::getMode(fullpath, followSymlink));
}

bool File::isFIFO(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISFIFO(File::getMode(fullpath, followSymlink));
}

bool File::isSymLink(const std::string &fullpath) throw (FileException) {
        return S_ISLNK(File::getMode(fullpath, false));
}

bool File::isSocket(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return S_ISSOCK(File::getMode(fullpath, followSymlink));
}

uid_t File::getUID(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_uid;
}

gid_t File::getGID(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_gid;
}

int64_t File::getSize(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return (int64_t) File::getStat(fullpath, followSymlink).st_size;
}

int64_t File::getBlocks(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return (int64_t) File::getStat(fullpath, followSymlink).st_blocks;
}

int64_t File::getBlockSize(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return (int64_t) File::getStat(fullpath, followSymlink).st_blksize;
}

time_t File::getATime(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_atime;
}

time_t File::getMTime(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_mtime;
}

time_t File::getCTime(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_ctime;
}

struct stat File::getStat(const std::string &fullpath, bool followSymlink) throw (FileException) {
        struct stat sb;

        if (followSymlink) {
                if (stat(fullpath.c_str(), &sb) < 0) {
                        THROW2(FileException, "stat()");
                }
        } else {
                if (lstat(fullpath.c_str(), &sb)) {
                        THROW2(FileException, "lstat()");
                }
        }

        return sb;
}

mode_t File::getMode(const std::string &fullpath, bool followSymlink) throw (FileException) {
        return File::getStat(fullpath, followSymlink).st_mode;
}

mode_t File::itomode(int mode) throw (FileException) {
        int ua;
        int ga;
        int oa;

        mode_t uam;
        mode_t gam;
        mode_t oam;

        if (mode >= 0 && mode <= 777) {
                oa = mode % 10;
                mode /= 10;
                ga = mode % 10;
                mode /= 10;
                ua = mode;
        } else {
                THROW2(FileException, "invalid mode %d", mode);
        }

        if (oa > 7 || ga > 7 || ua > 7) {
                THROW2(FileException, "invalid mode %d", mode);
        }

        if (ua == 7) {
                uam = S_IRWXU;
        } else if (ua == 6) {
                uam = S_IRUSR | S_IWUSR;
        } else if (ua == 5) {
                uam = S_IRUSR | S_IXUSR;
        } else if (ua == 4) {
                uam = S_IRUSR;
        } else if (ua == 3) {
                uam = S_IWUSR | S_IXUSR;
        } else if (ua == 2) {
                uam = S_IWUSR;
        } else if (ua == 1) {
                uam = S_IXUSR;
        } else {
                uam = 0;
        }

        if (ga == 7) {
                gam = S_IRWXG;
        } else if (ga == 6) {
                gam = S_IRGRP | S_IWGRP;
        } else if (ga == 5) {
                gam = S_IRGRP | S_IXGRP;
        } else if (ga == 4) {
                gam = S_IRGRP;
        } else if (ga == 3) {
                gam = S_IWGRP | S_IXGRP;
        } else if (ga == 2) {
                gam = S_IWGRP;
        } else if (ga == 1) {
                gam = S_IXGRP;
        } else {
                gam = 0;
        }

        if (oa == 7) {
                oam = S_IRWXO;
        } else if (oa == 6) {
                oam = S_IROTH | S_IWOTH;
        } else if (oa == 5) {
                oam = S_IROTH | S_IXOTH;
        } else if (oa == 4) {
                oam = S_IROTH;
        } else if (oa == 3) {
                oam = S_IWOTH | S_IXOTH;
        } else if (oa == 2) {
                oam = S_IWOTH;
        } else if (oa == 1) {
                oam = S_IXOTH;
        } else {
                oam = 0;
        }

        return (uam | gam | oam);
}

/*
** vim: noet ts=3 sw=3
*/