libi2ncommon: (tomj) modified filefunc according to our new style guide.

[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 <list>
#include <string>
#include <fstream>
#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 <boost/scoped_array.hpp>
#include "filefunc.hxx"
#include "stringfunc.hxx"

// TODO: Remove me once libi2ncommon is completly switched to I2n
using namespace i2n;

namespace I2n
{

using namespace std;

/*
** implementation of Stat
*/

Stat::Stat()
: Valid(false)
{
   clear();
} // eo Stat::Stat()


Stat::Stat(const std::string& path, bool follow_links)
{
    stat(path,follow_links);
} // eo Stat::Stat(const std::string&,bool)


Stat::~Stat()
{
} // eo Stat::~Stat()


/**
 * @brief updates the internal data.
 *
 * In other words: stat()'s the file again.
 */
void Stat::recheck()
{
    if (! Path.empty())
    {
        stat(Path, FollowLinks);
    }
} // eo Stat::recheck()


/**
 * @brief calls stat() or lstat() to get the information for the given path
 *  and stores that information.
 * @param path the path which should be checked
 * @param follow_links determine if (symbalic) links should be followed.
 */
void Stat::stat(const std::string& path, bool follow_links)
{
    clear();
    Path= path;
    FollowLinks= follow_links;
    struct stat stat_info;
    int res;
    res = ( follow_links ? ::stat(path.c_str(), &stat_info) : ::lstat(path.c_str(), &stat_info) );
    if ( 0 == res )
    {
        Device = stat_info.st_dev;
        Inode  = stat_info.st_ino;
        Mode   = (stat_info.st_mode & ~(S_IFMT));
        NumLinks = stat_info.st_nlink;
        Uid    = stat_info.st_uid;
        Gid    = stat_info.st_gid;
        DeviceType = stat_info.st_rdev;
        Size   = stat_info.st_size;
        Atime  = stat_info.st_atime;
        Mtime  = stat_info.st_mtime;
        Ctime  = stat_info.st_atime;

        IsLink=          S_ISLNK( stat_info.st_mode );
        IsRegular=       S_ISREG( stat_info.st_mode );
        IsDirectory=     S_ISDIR( stat_info.st_mode );
        IsCharacterDevice= S_ISCHR( stat_info.st_mode );
        IsBlockDevice=  S_ISBLK( stat_info.st_mode );
        IsFifo=          S_ISFIFO( stat_info.st_mode );
        IsSocket=        S_ISSOCK( stat_info.st_mode );
    }
    Valid = (0 == res);
} // eo Stat::stat(const std::string&,bool)


/**
 * @brief clears the internal data.
 */
void Stat::clear()
{
    Path.clear();
    Valid= false;

    Device = 0;
    Inode  = 0;
    Mode   = 0;
    NumLinks = 0;
    Uid    = 0;
    Gid    = 0;
    DeviceType = 0;
    Size   = 0;
    Atime  = 0;
    Mtime  = 0;
    Ctime  = 0;

    IsLink= false;
    IsRegular= false;
    IsDirectory= false;
    IsCharacterDevice= false;
    IsBlockDevice= false;
    IsFifo= false;
    IsSocket= false;
} // eo Stat::clear()


/**
 * @brief checks if another instance describes the same file.
 * @param rhs the other instance.
 * @return @a true iff the other instance describes the same file.
 * @note
 * The "same file" means that the files are located on the same device and use the same inode.
 * They might still have two different directory entries (different paths)!
 */
bool Stat::is_same_as(const Stat& rhs)
{
    return Valid and rhs.Valid
        and ( Device == rhs.Device)
        and ( Inode == rhs.Inode);
} // eo Stat::is_same_as(const Stat& rhs);


/**
 * @brief checks if this and the other instance describe the same device.
 * @param rhs the other instance.
 * @return @a true if we and the other instance describe a device and the same device.
 *
 * "Same device" means that the devices have the same type and the same major and minor id.
 */
bool Stat::is_same_device_as(const Stat& rhs)
{
    return is_device() and rhs.is_device()
        and ( IsBlockDevice == rhs.IsBlockDevice )
        and ( IsCharacterDevice == rhs.IsCharacterDevice )
        and ( DeviceType == rhs.DeviceType);
} // eo Stat::is_same_device_as(const Stat&)

/**
 * @brief check existence of a path.
 * @param path path which should be tested.
 * @return @a true iff path exists.
 */
bool path_exists(const std::string& path)
{
    struct stat stat_info;
    int res = ::stat(path.c_str(), &stat_info);
    if (res) return false;
    return true;
} // eo path_exists(const std::string&)

/**
 * @brief check existence of a regular file.
 * @param path path which should be tested.
 * @return @a true if path exists and is a regular file (or a link pointing to a regular file).
 * @note this checks for regular files; not for the pure exitsnace of a path; use pathExists() for that.
 * @see pathExists
 */
bool file_exists(const std::string& path)
{
    struct stat stat_info;
    int res = ::stat(path.c_str(), &stat_info);
    if (res) return false;
    return S_ISREG(stat_info.st_mode);
} // eo file_exists(const std::string&)

// TODO: Use Stat class
/**
 * Get size of file
 * @param name filename to get size for
 * @return file size or -1 if file does not exist
 */
long file_size (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;
}

/**
 * @brief tests the last modification time stamp of a path.
 * @param path path which should be tested.
 * @return the last modification time or 0 if the path doen't exist.
 */
time_t file_mtime(const std::string& path)
{
    struct stat stat_info;
    int res = ::stat(path.c_str(), &stat_info);
    if (res) return 0;
    return stat_info.st_mtime;
} // eo fileMTime(const std::string&)


/**
 * @brief reads the contents of a directory.
 * @param path the path to the directory whose contents should be read.
 * @param[out] result the resulting list of names.
 * @param include_dot_names determines if dot-files should be included in the list.
 * @return @a true if reading the directory was succesful, @a false on error.
 */
bool get_dir(
    const std::string& path,
    std::vector< std::string >& result,
    bool include_dot_names )
{
    DIR* dir = ::opendir( path.c_str());
    if (!dir)
    {
        return false;
    }
    struct dirent *entry;
    while ( NULL != (entry = ::readdir(dir)) )
    {
        std::string name( entry->d_name );
        if (! include_dot_names && (name[0] == '.') )
        {
            continue;
        }
        result.push_back( name );
    }
    ::closedir(dir);
    return true;
} // eo getDir(const std::string&,std::vector< std::string >&,bool)


/**
 * @brief reads the contents of a directory
 * @param path the path to the directory whose contents should be read.
 * @param include_dot_names determines if dot-files should be included in the list.
 * @return the list of names (empty on error).
 */
std::vector< std::string > get_dir(const std::string& path, bool include_dot_names )
{
    std::vector< std::string > result;
    get_dir(path,result,include_dot_names);
    return result;
} // eo getDir(const std::string&,bool)



/**
 * @brief removes a file from a filesystem.
 * @param path path to the file.
 * @return @a true iff the unlink was successful.
 */
bool unlink( const std::string& path )
{
    int res = ::unlink( path.c_str() );
    return (res == 0);
} // eo unlink(const std::string&)



/**
 * @brief creates a symbolic link named @a link_name to @a target.
 * @param target the target the link should point to.
 * @param link_name the name of the link.
 * @param force if @a true, the (file or link) @a link_name is removed if it exists.
 * @return @a true iff the symlink was successfully created.
 */
bool symlink(const std::string& target, const std::string& link_name, bool force)
{
    int res= -1;
    if (target.empty() or link_name.empty() or target == link_name)
    {
        // no, we don't do this!
        return false;
    }
    std::string n_target;
    if (target[0] == '/') // absolute target?
    {
        n_target= target;
    }
    else // relative target
    {
        // for stat'ing: prepend dir of link_name:
        n_target= dirname(link_name)+"/"+ target;
    }
    Stat target_stat(n_target, false);
    Stat link_name_stat(link_name, false);
    if (target_stat.exists() && link_name_stat.exists())
    {
        if (link_name_stat.is_same_as(target_stat)
            or link_name_stat.is_same_device_as(target_stat) )
        {
            return false;
        }
        //TODO: more consistency checks?!
    }
    if (link_name_stat.exists())
    {
        // the link name already exists.
        if (force)
        {
            // "force" as given, so try to remove the link_name:
            unlink(link_name);
            // update the stat:
            link_name_stat.recheck();
        }
    }
    if (link_name_stat.exists())
    {
        // well, if the link_name still exists; we cannot create that link:
        errno = EEXIST;
        return false;
    }
    res= ::symlink(target.c_str(), link_name.c_str());
    return (0 == res);
} // eo symlink(const std::string&,const std::string&,bool)



/**
 * @brief reads the target of a symbolic link.
 * @param path path to the symbolic link
 * @return the target of the link or an empty string on error.
 */
std::string read_link(const std::string& path)
{
    errno= 0;
    Stat stat(path,false);
    if (!stat || !stat.is_link())
    {
        return std::string();
    }
    int buffer_size= PATH_MAX+1 + 128;
    boost::scoped_array<char> buffer_ptr( new char[buffer_size] );
    int res= ::readlink( path.c_str(), buffer_ptr.get(), buffer_size-1 );
    if (res >= 0)
    {
        return std::string( buffer_ptr.get(), res );
    }
    return std::string();
} // eo readLink(const std::string&)



/**
 * @brief returns content of a file as string.
 *
 * A simple (q'n'd) function for retrieving content of a file as string.<br>
 * Also able to read special (but regular) files which don't provide a size when stat'ed
 * (like files in the /proc filesystem).
 *
 * @param path path to the file.
 * @return the content of the file as string (empty if file could be opened).
 */
std::string read_file(const std::string& path)
{
    Stat stat(path);
    if (!stat.is_reg())
    {
        return std::string();
    }
    std::ifstream f( path.c_str(), std::ios::in | std::ios::binary );
    std::string result;
    if (f.is_open())
    {
        // NOTE: there are cases where we don't know the correct size (/proc files...)
        // therefore we only use the size for reserving space if we know it, but don't
        // use it when reading the file!
        if (stat.size() > 0)
        {
            // if we know the size, we reserve enough space.
            result.reserve( stat.size() );
        }
        char buffer[2048];
        while (f.good())
        {
            f.read(buffer, sizeof(buffer));
            result.append(buffer, f.gcount());
        }
    }
    return result;
} // eo readFile


/**
 * @brief writes a string to a file.
 * @param path path to the file
 * @param data the data which should be written into the file
 * @return @a true if the data was written to the file.
 *
 * A simple (q'n'd) function for writing a string to a file.
 */
bool write_file(const std::string& path, const std::string& data)
{
    std::ofstream f( path.c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
    if (f.good())
    {
        f.write( data.data(), data.size() );
        return f.good();
    }
    else
    {
        return false;
    }
} // eo writeFile


/**
 * @brief returns the filename part of a path (last component)
 * @param path the path.
 * @return the last component of the path.
 */
std::string basename(const std::string& path)
{
    std::string::size_type pos= path.rfind('/');
    if (pos != std::string::npos)
    {
        return path.substr(pos+1);
    }
    return path;
} // eo basename(const std::string&)


/**
 * @brief returns the directory part of a path.
 * @param path the path.
 * @return the directory part of the path.
 */
std::string dirname(const std::string& path)
{
    std::string::size_type pos= path.rfind('/');
    if (pos != std::string::npos)
    {
        std::string result(path,0,pos);
        if (result.empty())
        {
            return ".";
        }
        return result;
    }
    return ".";
} // eo dirname(const std::string&)


/**
 * @brief normalizes a path.
 *
 * This method removes empty and "." elements.
 * It also resolves ".." parts by removing previous path elements if possible.
 * Leading ".." elements are preserved when a relative path was given; else they are removed.
 * Trailing slashes are removed.
 *
 * @param path the path which should be normalized.
 * @return the normalized path.
 */

std::string normalize_path(const std::string& path)
{
    if (path.empty())
    {
        return std::string();
    }
    // remember if the given path was absolute since this information vanishes when
    // we split the path (since we split with omitting empty parts...)
    bool is_absolute= (path[0]=='/');
    std::list< std::string >  parts;
    std::list< std::string >  result_parts;
    
    splitString(path,parts,"/",true);
    
    for(std::list< std::string >::const_iterator it_parts= parts.begin();
        it_parts != parts.end();
        ++it_parts)
    {
        std::string part(*it_parts); //convenience..
        if (part == std::string(".") )
        {
            // single dot is "current path"; ignore!
            continue;
        }
        if (part == std::string("..") )
        {
            // double dot is "one part back"
            if (result_parts.empty())
            {
                if (is_absolute)
                {
                    // ignore since we cannot move behind / on absolute paths...
                }
                else
                {
                    // on relative path, we need to store the "..":
                    result_parts.push_back(part);
                }
            }
            else if (result_parts.back() == std::string("..") )
            {
                // if last element was already "..", we need to store the new one again...
                // (PS: no need for "absolute" check; this can only be the case on relative path)
                result_parts.push_back(part);
            }
            else
            {
                // remove last element.
                result_parts.pop_back();
            }
            continue;
        }
        result_parts.push_back(part);
    }
    std::string result;
    if (is_absolute)
    {
        result= "/";
    }
    result+= joinString(result_parts,"/");
    return result;
} // eo normalizePath(const std::string&)


/**
 * @brief changes the file(/path) mode.
 * @param path the path to change the mode for.
 * @param mode the new file mode.
 * @return @a true iff the file mode was sucessfully changed.
 */
bool chmod(const std::string& path, int mode)
{
    int res= ::chmod(path.c_str(), mode);
    return (res==0);
} // eo chmod(const std::string&,int)


/**
 * @brief changed the owner of a file(/path)
 * @param path the path to change the owner for.
 * @param user the new file owner.
 * @param group the new file group.
 * @return @a true iff the file owner was succesfully changed.
 *
 * @note
 * the validity of user and group within the system is not checked.
 * This is intentional since this way we can use id's which are not assigned.
 */
bool chown(const std::string& path, const I2n::User& user, const I2n::Group& group)
{
    uid_t uid= user.Uid;
    if (uid<0) return false;
    gid_t gid= group.Gid;
    if (gid<0) gid= user.Gid;
    if (gid<0) return false;
    int res= ::chown( path.c_str(), uid, gid);
    return (res==0);
} // eo chown(const std::string&,const User&,const Group&)

/**
 * 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;
}

}