filesystem.h

Go to the documentation of this file.

// Copyright (C) 2021-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef KEA_UTIL_FILESYSTEM_H
#define KEA_UTIL_FILESYSTEM_H
 
#include <exceptions/exceptions.h>
#include <sys/stat.h>
#include <string>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace util {
namespace file {

class SecurityWarn : public Exception {
public:
    SecurityWarn(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};

class SecurityError : public Exception {
public:
    SecurityError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};

std::string
getContent(const std::string& file_name);

bool
exists(const std::string& path);

mode_t
getPermissions(const std::string path);

bool
hasPermissions(const std::string path, const mode_t& permissions);

bool
isDir(const std::string& path);

bool
isFile(const std::string& path);

bool
isSocket(const std::string& path);

void
setUmask();

class RelaxUmask : public boost::noncopyable {
public:
    RelaxUmask();

    ~RelaxUmask();
 
private:
    mode_t orig_umask_;
};

bool
amRunningAsRoot();

struct Path {
    Path(std::string const& path);

    std::string str() const;

    std::string parentPath() const;

    std::string parentDirectory() const;

    std::string stem() const;

    std::string extension() const;

    std::string filename() const;

    Path& replaceExtension(std::string const& replacement = std::string());

    Path& replaceParentPath(std::string const& replacement = std::string());
 
private:
    bool dir_present_;

    std::string parent_path_;

    std::string stem_;

    std::string extension_;
};
 
struct TemporaryDirectory {
    TemporaryDirectory();
    ~TemporaryDirectory();
    std::string dirName();
private:
    std::string dir_name_;
};

class PathChecker {
public:
    PathChecker(const std::string default_path, const std::string env_name = "");

    virtual ~PathChecker() {};

    std::string getPath(bool reset = false, const std::string explicit_path = "");

    std::string validatePath(const std::string input_path_str,
                             bool enforce_path = shouldEnforceSecurity()) const;

    std::string validateDirectory(const std::string input_path_str,
                                  bool enforce_path = shouldEnforceSecurity()) const;

    bool pathHasPermissions(mode_t permissions,
                            bool enforce_perms = shouldEnforceSecurity()) const;

    std::string getDefaultPath() const {
        return (default_path_);
    }

    std::string getEnvName() const {
        return (env_name_);
    }

    bool isDefaultOverridden();

    static bool shouldEnforceSecurity();

    static void enableEnforcement(bool enable);
 
private:
    std::string default_path_;

    std::string env_name_;

    std::string path_;

    bool default_overridden_;

    static bool enforce_security_;
};

typedef boost::shared_ptr<PathChecker> PathCheckerPtr;
 
}  // namespace file
}  // namespace util
}  // namespace isc
 
#endif  // KEA_UTIL_FILESYSTEM_H