How do I “normalize” a pathname using boost::filesystem?

by

Boost v1.48 and above

You can use boost::filesystem::canonical:

path canonical(const path& p, const path& base = current_path());
path canonical(const path& p, system::error_code& ec);
path canonical(const path& p, const path& base, system::error_code& ec);

http://www.boost.org/doc/libs/1_48_0/libs/filesystem/v3/doc/reference.html#canonical

v1.48 and above also provide the boost::filesystem::read_symlink function for resolving symbolic links.

Boost versions prior to v1.48

As mentioned in other answers, you can’t normalise because boost::filesystem can’t follow symbolic links. However, you can write a function that normalises “as much as possible” (assuming “.” and “..” are treated normally) because boost offers the ability to determine whether or not a file is a symbolic link.

That is to say, if the parent of the “..” is a symbolic link then you have to retain it, otherwise it is probably safe to drop it and it’s probably always safe to remove “.”.

It’s similar to manipulating the actual string, but slightly more elegant.

boost::filesystem::path resolve(
    const boost::filesystem::path& p,
    const boost::filesystem::path& base = boost::filesystem::current_path())
{
    boost::filesystem::path abs_p = boost::filesystem::absolute(p,base);
    boost::filesystem::path result;
    for(boost::filesystem::path::iterator it=abs_p.begin();
        it!=abs_p.end();
        ++it)
    {
        if(*it == "..")
        {
            // /a/b/.. is not necessarily /a if b is a symbolic link
            if(boost::filesystem::is_symlink(result) )
                result /= *it;
            // /a/b/../.. is not /a/b/.. under most circumstances
            // We can end up with ..s in our result because of symbolic links
            else if(result.filename() == "..")
                result /= *it;
            // Otherwise it should be safe to resolve the parent
            else
                result = result.parent_path();
        }
        else if(*it == ".")
        {
            // Ignore
        }
        else
        {
            // Just cat other path entries
            result /= *it;
        }
    }
    return result;
}

More Related Contents:

  1. Can I use a mask to iterate files in a directory with Boost?
  2. Why do I need strand per connection when using boost::asio?
  3. Weighted random numbers
  4. Example for boost shared_mutex (multiple reads/one write)?
  5. How do you iterate through every file/directory recursively in standard C++?
  6. Magic number in boost::hash_combine
  7. boost_1_60_0 .zip installation in windows
  8. demote boost::function to a plain function pointer
  9. C++ – Why is boost::hash_combine the best way to combine hash-values?
  10. Boost C++ Serialization overhead
  11. How to get list of files with a specific extension in a given folder?
  12. Boost random number generator
  13. boost asio ssl async_shutdown always finishes with an error?
  14. Boost async_* functions and shared_ptr’s
  15. Does delete work with pointers to base class?
  16. Self-unrolling macro loop in C/C++
  17. boost.python not supporting parallelism?
  18. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  19. C++11 equivalent to boost shared_mutex
  20. boost::property_tree XML pretty printing
  21. How to serialize derived template classes with Boost.serialize?
  22. Constraining the existing Boost.Spirit real_parser (with a policy)
  23. want to efficiently overcome mismatch between key types in a map in Boost.Interprocess shared memory
  24. Cut set of a graph, Boost Graph Library
  25. Why can’t I use with g++ 4.9.2?
  26. Boost.Asio as header-only
  27. How do I take ownership of an abandoned boost::interprocess::interprocess_mutex?
  28. Boost::Spirit::QI parser: index of parsed element
  29. How to enable_shared_from_this of both parent and derived
  30. How can I find the size of all files located inside a folder?

Leave a Comment