anonymous_namespace{Quarantine.cpp} Namespace Reference

Functions
bool	is_regular_file_without_following_symlinks (const fs::path &path, std::error_code &ec)
fs::path	normalize_path (const fs::path &path, std::error_code &ec)
bool	is_path_inside (const fs::path &candidate, const fs::path &directory)
void	remove_without_throwing (const fs::path &path)
bool	copy_then_remove (const fs::path &source, const fs::path &destination)

Function Documentation

copy_then_remove()

bool anonymous_namespace{Quarantine.cpp}::copy_then_remove	(	const fs::path &	source,
		const fs::path &	destination )

Definition at line 90 of file Quarantine.cpp.

{
    std::error_code copy_ec;
    fs::copy_file(source, destination, fs::copy_options::none, copy_ec);
    if (copy_ec) {
        std::cerr << _("❌ Errore copia in quarantena: ")
                  << copy_ec.message() << std::endl;
        return false;
    }
 
    std::error_code remove_ec;
    fs::remove(source, remove_ec);
    if (remove_ec) {
        std::cerr << _("❌ Impossibile rimuovere il file originale dopo la copia: ")
                  << remove_ec.message() << std::endl;
 
        // La quarantena non è riuscita: non lasciare una copia che possa
        // essere interpretata come isolamento completato.
        remove_without_throwing(destination);
        return false;
    }
 
    return true;
}

References _, copy_then_remove(), and remove_without_throwing().

Referenced by copy_then_remove().

is_path_inside()

bool anonymous_namespace{Quarantine.cpp}::is_path_inside	(	const fs::path &	candidate,
		const fs::path &	directory )

Definition at line 60 of file Quarantine.cpp.

{
    std::error_code candidate_ec;
    std::error_code directory_ec;
 
    const fs::path normalized_candidate = normalize_path(candidate, candidate_ec);
    const fs::path normalized_directory = normalize_path(directory, directory_ec);
 
    if (candidate_ec || directory_ec || normalized_directory.empty())
        return false;
 
    auto candidate_it = normalized_candidate.begin();
    for (auto directory_it = normalized_directory.begin();
         directory_it != normalized_directory.end();
         ++directory_it, ++candidate_it) {
        if (candidate_it == normalized_candidate.end() ||
            *candidate_it != *directory_it) {
            return false;
        }
    }
 
    return true;
}

References is_path_inside(), and normalize_path().

Referenced by is_path_inside().

is_regular_file_without_following_symlinks()

bool anonymous_namespace{Quarantine.cpp}::is_regular_file_without_following_symlinks	(	const fs::path &	path,
		std::error_code &	ec )

Definition at line 37 of file Quarantine.cpp.

{
    ec.clear();
    const fs::file_status status = fs::symlink_status(path, ec);
    return !ec && fs::exists(status) && fs::is_regular_file(status);
}

References is_regular_file_without_following_symlinks().

Referenced by is_regular_file_without_following_symlinks().

normalize_path()

fs::path anonymous_namespace{Quarantine.cpp}::normalize_path	(	const fs::path &	path,
		std::error_code &	ec )

Definition at line 45 of file Quarantine.cpp.

{
    ec.clear();
    fs::path normalized = fs::weakly_canonical(path, ec);
    if (!ec)
        return normalized.lexically_normal();
 
    ec.clear();
    normalized = fs::absolute(path, ec);
    if (!ec)
        return normalized.lexically_normal();
 
    return path.lexically_normal();
}

References normalize_path().

Referenced by is_path_inside(), and normalize_path().

remove_without_throwing()

void anonymous_namespace{Quarantine.cpp}::remove_without_throwing

(

const fs::path &

path

)

Definition at line 84 of file Quarantine.cpp.

{
    std::error_code ec;
    fs::remove(path, ec);
}

References remove_without_throwing().

Referenced by copy_then_remove(), and remove_without_throwing().