libi2ncommon: (tomj) fix typo

[libi2ncommon] / src / filefunc.cpp

/***************************************************************************
                          escape.cpp  -  escaping of strings
                             -------------------
    begin                : Sun Nov 14 1999
    copyright            : (C) 1999 by Intra2net AG
    email                : info@intra2net.com
 ***************************************************************************/

#include <string>
#include <sstream>
#include <iostream>
#include <stdexcept>

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <pwd.h>
#include <grp.h>
#include <unistd.h>
#include <errno.h>

#include <filefunc.hxx>

using namespace std;

bool file_exists (const string &name)
{
    struct stat statbuff;

    if (stat(name.c_str(), &statbuff) < 0)
        return false;
    else
        return true;
}

long fsize (const string &name)
{
    long iReturn = -1;

    struct stat statbuff;

    if (lstat(name.c_str(), &statbuff) < 0)
        return -1;

    if (!S_ISREG(statbuff.st_mode))
        return -1;

    iReturn=statbuff.st_size;

    return iReturn;
}

string load_file(const string &name)
{
    FILE *f;
    string s;

    if (name.find ("..") != string::npos)
        return ("can't load file (..): " + name);

    f=::fopen(name.c_str(),"rb");
    if (!f)
    {
        return ("");
    }

    ::fseek(f,0,SEEK_END);
    int size=::ftell(f);
    ::fseek(f,0,SEEK_SET);
    char *c=new char[size+1];
    ::fread(c,1,size,f);
    s.assign(c,size);
    delete[] c;
    ::fclose (f);

    return s;
}

bool chown(const char* file,const char* owner, const char* group)
{
    struct passwd *p;
    struct group *g;
    uid_t uid;
    gid_t gid;

    p = getpwnam(owner);
    if (p == NULL)
        return false;
    uid=p->pw_uid;

    g = getgrnam(group);
    if (g == NULL)
        return false;
    gid=g->gr_gid;

    if (!::chown(file,uid,gid))
        return true;
    else
        return false;
}

/**
 * Recursive delete of files and directories
 * @param path File or directory to delete
 * @param error Will contain the error if the return value is false
 * @return true on success, false otherwise
 */
bool recursive_delete(const std::string &path, std::string *error)
{
    bool rtn = true;

    try {
        struct stat my_stat;
        if (stat(path.c_str(), &my_stat) != 0) {
            throw runtime_error("can't stat " + path);
        }

        if (S_ISDIR(my_stat.st_mode)) {
            DIR *dir = opendir(path.c_str());
            if (!dir) {
                throw runtime_error("can't open directory " + path);
            }

            struct dirent *entry;
            while ((entry = readdir(dir))) {
                string filename = entry->d_name;
                if (filename == "." || filename == "..") {
                    continue;
                }

                // Delete subdir or file.
                rtn = recursive_delete(path + "/" + filename, error);
                if (rtn == false) {
                    break;
                }
            }

            closedir(dir);
            if (rmdir(path.c_str()) != 0) {
                throw runtime_error("can't remove directory " + path);
            }
        } else {
            if (unlink(path.c_str()) != 0) {
                throw runtime_error("can't unlink " + path);
            }
        }
    } catch (exception &e) {
        if (error) {
            ostringstream out;
            out << e.what() << " (" << strerror(errno) << ")";
            *error = out.str();
        }
        rtn = false;
    } catch (...) {
        if (error) {
            ostringstream out;
            out << "unknown error (" << strerror(errno) << ")";
            *error = out.str();
        }
        rtn = false;
    }

    return rtn;
}