* Copyright (C) 2025-2025. Huawei Technologies Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dynolog/src/utils.h"
#include <unistd.h>
#include <climits>
#include <cstdint>
#include <cstring>
#include <sys/stat.h>
#include <pwd.h>
#include <unordered_map>
#include <glog/logging.h>
#include <nlohmann/json.hpp>
namespace dynolog {
namespace {
const uint16_t MAX_PATH_SIZE = 1024;
constexpr int INPUT_DIR_CHECK_MODE = R_OK | X_OK;
constexpr mode_t OTHERS_WRITE_MASK = S_IWGRP | S_IWOTH;
const std::unordered_map<std::string, std::string> INVALID_CHAR = {
{"\n", "\\n"}, {"\f", "\\f"}, {"\r", "\\r"}, {"\b", "\\b"}, {"\t", "\\t"},
{"\v", "\\v"}, {"\u007F", "\\u007F"}, {"\"", "\\\""}, {"'", "\'"},
{"\\", "\\\\"}, {"%", "\\%"}, {">", "\\>"}, {"<", "\\<"}, {"|", "\\|"},
{"&", "\\&"}, {"$", "\\$"}
};
}
std::string Rstrip(const std::string &str1, const std::string &str2)
{
size_t end = str1.find_last_not_of(str2);
return end == std::string::npos ? "" : str1.substr(0, end + 1);
}
bool PathUtils::Access(const std::string &path, const int &mode)
{
if (path.empty()) {
LOG(ERROR) << "The file path is empty.";
return false;
}
return access(path.c_str(), mode) == 0;
}
bool PathUtils::Exist(const std::string &path)
{
return Access(path, F_OK);
}
bool PathUtils::IsSoftLink(const std::string &path)
{
if (path.empty()) {
LOG(ERROR) << "The file path is empty.";
return false;
}
std::string tmpPath = Rstrip(path, "./");
struct stat fileStat;
if (lstat(tmpPath.c_str(), &fileStat) != 0) {
LOG(ERROR) << "The file stat failed, path: " << path;
return false;
}
return S_ISLNK(fileStat.st_mode);
}
bool PathUtils::IsFile(const std::string &path)
{
if (path.empty()) {
LOG(ERROR) << "The file path is empty.";
return false;
}
struct stat fileStat;
if (stat(path.c_str(), &fileStat) != 0) {
LOG(ERROR) << "The file stat failed, path: " << path;
return false;
}
return fileStat.st_mode & S_IFREG;
}
bool PathUtils::IsWritableByOthers(const std::string &path)
{
struct stat fileStat;
if (stat(path.c_str(), &fileStat) != 0) {
LOG(ERROR) << "The file stat failed, path: " << path;
return true;
}
return (fileStat.st_mode & OTHERS_WRITE_MASK) != 0;
}
bool PathUtils::IsOwner(const std::string &path)
{
struct stat info;
if (stat(path.c_str(), &info) != 0) {
LOG(ERROR) << "The file stat failed, path: " << path;
return false;
}
uid_t current_uid = getuid();
if (info.st_uid != current_uid) {
return false;
}
return true;
}
bool PathUtils::DirPathCheck(const std::string &path)
{
if (path.empty()) {
LOG(ERROR) << "The path is empty.";
return false;
}
if (path.size() > MAX_PATH_SIZE) {
LOG(ERROR) << "The length of path is too long, max allowed: " << MAX_PATH_SIZE;
return false;
}
for (auto &item : INVALID_CHAR) {
if (path.find(item.first) != std::string::npos) {
LOG(ERROR) << "The path contains invalid character: " << item.first;
return false;
}
}
if (!Exist(path)) {
LOG(ERROR) << "The path does not exist: " << path;
return false;
}
if (IsFile(path)) {
LOG(ERROR) << "The path is a file: " << path;
return false;
}
if (IsSoftLink(path)) {
LOG(ERROR) << "The path is a soft link: " << path;
return false;
}
if (IsRoot()) {
return true;
}
if (!IsOwner(path)) {
LOG(ERROR) << "The path is not owned by current user: " << path;
return false;
}
if (!Access(path, INPUT_DIR_CHECK_MODE)) {
LOG(ERROR) << "The path is not readable: " << path;
return false;
}
if (IsWritableByOthers(path)) {
LOG(ERROR) << "The path is writable by others: " << path;
return false;
}
return true;
}
bool IsRoot()
{
return getuid() == 0;
}
class JsonDepthCheckSAX : public nlohmann::json::json_sax_t {
public:
bool null() override { return true; }
bool boolean(bool) override { return true; }
bool number_integer(nlohmann::json::number_integer_t) override { return true; }
bool number_unsigned(nlohmann::json::number_unsigned_t) override { return true; }
bool number_float(nlohmann::json::number_float_t, const std::string &) override { return true; }
bool string(nlohmann::json::string_t &) override { return true; }
bool binary(nlohmann::json::binary_t &) override { return true; }
bool key(nlohmann::json::string_t &) override { return true; }
bool parse_error(std::size_t, const std::string &, const nlohmann::json::exception &) override { return false; }
bool start_object(std::size_t) override
{
depth_++;
if (depth_ > MAX_DEPTH) {
throw std::runtime_error("JSON depth exceeds maximum allowed depth");
}
return true;
}
bool end_object() override
{
depth_--;
return true;
}
bool start_array(std::size_t) override
{
depth_++;
if (depth_ > MAX_DEPTH) {
throw std::runtime_error("JSON depth exceeds maximum allowed depth");
}
return true;
}
bool end_array() override
{
depth_--;
return true;
}
private:
int depth_ = 0;
const int MAX_DEPTH = 10;
};
bool CheckJsonDepth(const std::string &json_str)
{
JsonDepthCheckSAX sax;
try {
nlohmann::json::sax_parse(json_str, &sax);
} catch (const std::exception &e) {
LOG(ERROR) << "JSON depth check failed: " << e.what();
return false;
}
return true;
}
std::string GetCurrentUserHomePath()
{
static std::string home_path = []() -> std::string {
struct passwd *pw = getpwuid(getuid());
if (pw == nullptr || pw->pw_dir == nullptr) {
LOG(ERROR) << "Failed to get current user info";
return "";
}
return std::string(pw->pw_dir);
}();
return home_path;
}
}
