[post build lint] Check for absolute paths

include/vcpkg/base/messages.h

@@ -309,6 +309,8 @@ namespace vcpkg::msg
     DECLARE_MSG_ARG(option, "editable");
     DECLARE_MSG_ARG(package_name, "zlib");
     DECLARE_MSG_ARG(path, "/foo/bar");
+    DECLARE_MSG_ARG(paths, "/foo/bar, /foo/bar2");
+    DECLARE_MSG_ARG(absolute_paths, "/foo/bar, /foo/bar2");
     DECLARE_MSG_ARG(row, "42");
     DECLARE_MSG_ARG(spec, "zlib:x64-windows");
     DECLARE_MSG_ARG(system_api, "CreateProcessW");
@@ -1088,6 +1090,11 @@ namespace vcpkg
                     "One or more {vendor} credential providers failed to authenticate. See '{url}' for more details "
                     "on how to provide credentials.");
     DECLARE_MESSAGE(FeedbackAppreciated, (), "", "Thank you for your feedback!");
+    DECLARE_MESSAGE(FilesContainAbsolutePath,
+                    (msg::absolute_paths, msg::paths),
+                    "The ('{absolute_paths}') part should remain unchanged, as a list of paths",
+                    "The following files contain an absolute path ('{absolute_paths}'): {paths}\n"
+                    "There should be no absolute paths in the installed package, only relative ones.");
     DECLARE_MESSAGE(FetchingBaselineInfo,
                     (msg::package_name),
                     "",

include/vcpkg/base/strings.h

@@ -12,6 +12,8 @@
 #include <algorithm>
 #include <vector>
 
+#include "vcpkg/base/fwd/span.h"
+
 namespace vcpkg::Strings::details
 {
     // first looks up to_string on `T` using ADL; then, if that isn't found,
@@ -218,6 +220,8 @@ namespace vcpkg::Strings
 
     Optional<StringView> find_at_most_one_enclosed(StringView input, StringView left_tag, StringView right_tag);
 
+    bool contains_any_ignoring_c_comments(const std::string& source, View<StringView> to_find);
+
     bool equals(StringView a, StringView b);
 
     template<class T>

include/vcpkg/base/util.h

@@ -266,6 +266,13 @@ namespace vcpkg::Util
         return std::find(begin(cont), end(cont), v);
     }
 
+    template<class Range, class T>
+    bool contains(const Range& r, const T& el)
+    {
+        using std::end;
+        return Util::find(r, el) != end(r);
+    }
+
     template<class Container, class Pred>
     auto find_if(Container&& cont, Pred pred)
     {

include/vcpkg/build.h

@@ -311,6 +311,7 @@ namespace vcpkg
         SKIP_DUMPBIN_CHECKS,
         SKIP_ARCHITECTURE_CHECK,
         CMAKE_HELPER_PORT,
+        SKIP_ABSOLUTE_PATHS_CHECK,
         // Must be last
         COUNT,
     };

locales/messages.json

@@ -403,6 +403,8 @@
   "FileNotFound": "{path}: file not found",
   "_FileNotFound.comment": "An example of {path} is /foo/bar.",
   "FileSystemOperationFailed": "Filesystem operation failed:",
+  "FilesContainAbsolutePath": "The following files contain an absolute path ('{absolute_paths}'): {paths}\nThere should be no absolute paths in the installed package, only relative ones.",
+  "_FilesContainAbsolutePath.comment": "The ('{absolute_paths}') part should remain unchanged, as a list of paths An example of {absolute_paths} is /foo/bar, /foo/bar2. An example of {paths} is /foo/bar, /foo/bar2.",
   "FilesExported": "Files exported at: {path}",
   "_FilesExported.comment": "An example of {path} is /foo/bar.",
   "FishCompletion": "vcpkg fish completion is already added at \"{path}\".",

src/vcpkg-test/strings.cpp

@@ -3,6 +3,7 @@
 #include <vcpkg/base/api_stable_format.h>
 #include <vcpkg/base/expected.h>
 #include <vcpkg/base/strings.h>
+#include <vcpkg/base/view.h>
 
 #include <stdint.h>
 
@@ -55,6 +56,23 @@ TEST_CASE ("find_first_of", "[strings]")
     REQUIRE(find_first_of("abcdefg", "gb") == std::string("bcdefg"));
 }
 
+TEST_CASE ("contains_any_ignoring_c_comments", "[strings]")
+{
+    using vcpkg::Strings::contains_any_ignoring_c_comments;
+    vcpkg::StringView to_find[] = {"abc", "wer"};
+    REQUIRE(contains_any_ignoring_c_comments(R"(abc)", to_find));
+    REQUIRE(contains_any_ignoring_c_comments(R"("abc")", to_find));
+    REQUIRE_FALSE(contains_any_ignoring_c_comments(R"("" //abc)", to_find));
+    REQUIRE_FALSE(contains_any_ignoring_c_comments(R"(/*abc*/ "")", to_find));
+    REQUIRE_FALSE(contains_any_ignoring_c_comments("// test \\\nabc", to_find));
+    REQUIRE(contains_any_ignoring_c_comments("\"//\" test \\\nabc", to_find));
+    REQUIRE(contains_any_ignoring_c_comments(R"(R"-( // abc )-")", to_find));
+    REQUIRE(contains_any_ignoring_c_comments(R"(R"-( /* abc */ )-")", to_find));
+    REQUIRE(contains_any_ignoring_c_comments(R"(R"-()- /* abc */ )-")", to_find));
+    REQUIRE(contains_any_ignoring_c_comments(R"(qwer )", to_find));
+    REQUIRE(contains_any_ignoring_c_comments("\"a\" \"g\" // er \n abc)", to_find));
+}
+
 TEST_CASE ("edit distance", "[strings]")
 {
     using vcpkg::Strings::byte_edit_distance;

src/vcpkg/base/messages.cpp

@@ -635,11 +635,12 @@ namespace vcpkg
     REGISTER_MESSAGE(FeedbackAppreciated);
     REGISTER_MESSAGE(FetchingBaselineInfo);
     REGISTER_MESSAGE(FetchingRegistryInfo);
-    REGISTER_MESSAGE(FishCompletion);
     REGISTER_MESSAGE(FloatingPointConstTooBig);
     REGISTER_MESSAGE(FileNotFound);
     REGISTER_MESSAGE(FilesExported);
     REGISTER_MESSAGE(FileSystemOperationFailed);
+    REGISTER_MESSAGE(FishCompletion);
+    REGISTER_MESSAGE(FilesContainAbsolutePath);
     REGISTER_MESSAGE(FollowingPackagesMissingControl);
     REGISTER_MESSAGE(FollowingPackagesNotInstalled);
     REGISTER_MESSAGE(FollowingPackagesUpgraded);

src/vcpkg/base/strings.cpp

@@ -382,6 +382,73 @@ Optional<StringView> Strings::find_at_most_one_enclosed(StringView input, String
     return result.front();
 }
 
+bool vcpkg::Strings::contains_any_ignoring_c_comments(const std::string& source, View<StringView> to_find)
+{
+    std::string::size_type offset = 0;
+    std::string::size_type no_comment_offset = 0;
+    while (offset != std::string::npos)
+    {
+        no_comment_offset = std::max(offset, no_comment_offset);
+        auto start = source.find_first_of("/\"", no_comment_offset);
+        if (start == std::string::npos || start + 1 == source.size() || no_comment_offset == std::string::npos)
+        {
+            return Util::any_of(to_find,
+                                [&](StringView s) { return Strings::contains(StringView(source).substr(offset), s); });
+        }
+
+        if (source[start] == '/')
+        {
+            if (source[start + 1] == '/' || source[start + 1] == '*')
+            {
+                if (Util::any_of(to_find, [&](StringView s) {
+                        return Strings::contains(StringView(source).substr(offset, start - offset), s);
+                    }))
+                {
+                    return true;
+                }
+                if (source[start + 1] == '/')
+                {
+                    offset = source.find_first_of('\n', start);
+                    while (offset != std::string::npos && source[offset - 1] == '\\')
+                        offset = source.find_first_of('\n', offset + 1);
+                    if (offset != std::string::npos) ++offset;
+                    continue;
+                }
+                offset = source.find_first_of('/', start + 1);
+                while (offset != std::string::npos && source[offset - 1] != '*')
+                    offset = source.find_first_of('/', offset + 1);
+                if (offset != std::string::npos) ++offset;
+                continue;
+            }
+        }
+        else if (source[start] == '\"')
+        {
+            if (start > 0 && source[start - 1] == 'R') // raw string literals
+            {
+                auto end = source.find_first_of('(', start);
+                if (end == std::string::npos)
+                {
+                    // invalid c++, but allowed: auto test = 'R"'
+                    no_comment_offset = start + 1;
+                    continue;
+                }
+                auto d_char_sequence = source.substr(start, end - start);
+                d_char_sequence.push_back('\"');
+                no_comment_offset = source.find(d_char_sequence, end);
+                if (no_comment_offset != std::string::npos) no_comment_offset += d_char_sequence.size();
+                continue;
+            }
+            no_comment_offset = source.find_first_of('"', start + 1);
+            while (no_comment_offset != std::string::npos && source[no_comment_offset - 1] == '\\')
+                no_comment_offset = source.find_first_of('"', no_comment_offset + 1);
+            if (no_comment_offset != std::string::npos) ++no_comment_offset;
+            continue;
+        }
+        no_comment_offset = start + 1;
+    }
+    return false;
+}
+
 bool Strings::equals(StringView a, StringView b)
 {
     if (a.size() != b.size()) return false;

src/vcpkg/build.cpp

@@ -216,6 +216,7 @@ namespace vcpkg
     static const std::string NAME_SKIP_DUMPBIN_CHECKS = "PolicySkipDumpbinChecks";
     static const std::string NAME_SKIP_ARCHITECTURE_CHECK = "PolicySkipArchitectureCheck";
     static const std::string NAME_CMAKE_HELPER_PORT = "PolicyCmakeHelperPort";
+    static const std::string NAME_SKIP_ABSOLUTE_PATHS_CHECK = "PolicySkipAbsolutePathsCheck";
 
     static std::remove_const_t<decltype(ALL_POLICIES)> generate_all_policies()
     {
@@ -246,6 +247,7 @@ namespace vcpkg
             case BuildPolicy::SKIP_DUMPBIN_CHECKS: return NAME_SKIP_DUMPBIN_CHECKS;
             case BuildPolicy::SKIP_ARCHITECTURE_CHECK: return NAME_SKIP_ARCHITECTURE_CHECK;
             case BuildPolicy::CMAKE_HELPER_PORT: return NAME_CMAKE_HELPER_PORT;
+            case BuildPolicy::SKIP_ABSOLUTE_PATHS_CHECK: return NAME_SKIP_ABSOLUTE_PATHS_CHECK;
             default: Checks::unreachable(VCPKG_LINE_INFO);
         }
     }
@@ -266,6 +268,7 @@ namespace vcpkg
             case BuildPolicy::SKIP_DUMPBIN_CHECKS: return "VCPKG_POLICY_SKIP_DUMPBIN_CHECKS";
             case BuildPolicy::SKIP_ARCHITECTURE_CHECK: return "VCPKG_POLICY_SKIP_ARCHITECTURE_CHECK";
             case BuildPolicy::CMAKE_HELPER_PORT: return "VCPKG_POLICY_CMAKE_HELPER_PORT";
+            case BuildPolicy::SKIP_ABSOLUTE_PATHS_CHECK: return "VCPKG_POLICY_SKIP_ABSOLUTE_PATHS_CHECK";
             default: Checks::unreachable(VCPKG_LINE_INFO);
         }
     }

src/vcpkg/postbuildlint.cpp

@@ -1,10 +1,12 @@
 #include <vcpkg/base/cofffilereader.h>
 #include <vcpkg/base/files.h>
+#include <vcpkg/base/messages.h>
 #include <vcpkg/base/system.print.h>
 #include <vcpkg/base/system.process.h>
 #include <vcpkg/base/util.h>
 
 #include <vcpkg/build.h>
+#include <vcpkg/installedpaths.h>
 #include <vcpkg/packagespec.h>
 #include <vcpkg/postbuildlint.buildtype.h>
 #include <vcpkg/postbuildlint.h>
@@ -1025,6 +1027,95 @@ namespace vcpkg::PostBuildLint
         return LintStatus::SUCCESS;
     }
 
+    static LintStatus check_no_absolute_paths_in(const Filesystem& fs, const Path& dir, Span<Path> absolute_paths)
+    {
+        static constexpr StringLiteral extensions[] = {"h", "hpp", "hxx", "py", "sh", "cmake", "pc", "cfg", "conf"};
+        std::vector<std::pair<Path, std::string>> files_and_contents;
+        for (auto& path : fs.get_regular_files_recursive(dir, IgnoreErrors{}))
+        {
+            if (path.extension().empty())
+            {
+                auto contents = fs.read_contents(path, VCPKG_LINE_INFO);
+                if (Strings::starts_with(contents, "#!"))
+                {
+                    files_and_contents.emplace_back(std::move(path), std::move(contents));
+                }
+            }
+            else if (Util::contains(extensions, path.extension().substr(1 /* ignore dot */)))
+            {
+                auto contents = fs.read_contents(path, VCPKG_LINE_INFO);
+                files_and_contents.emplace_back(std::move(path), std::move(contents));
+            }
+        }
+        std::vector<std::string> string_paths;
+        for (const auto& path : absolute_paths)
+        {
+#if defined(_WIN32)
+            auto path_preferred = path;
+            path_preferred.make_preferred();
+            string_paths.push_back(path_preferred.generic_u8string());
+            string_paths.push_back(std::move(path).native());
+#else
+            string_paths.push_back(path.native());
+#endif
+        }
+        const auto stringview_paths = Util::fmap(string_paths, [](std::string& s) { return StringView(s); });
+
+        std::string result;
+        for (const auto& path_and_contents : files_and_contents)
+        {
+            const auto extension = path_and_contents.first.extension().substr(1 /* ignore dot */);
+            const bool is_header = extension == "h" || extension == "hpp" || extension == "hxx";
+            bool found_absolute = false;
+            if (is_header)
+            {
+                found_absolute = Util::any_of(string_paths, [&path_and_contents](const std::string& path) {
+                    StringView sv(path);
+                    bool contains = path_and_contents.second.find(path) != std::string::npos;
+                    // First do a cheap search and then a complicated one
+                    return contains && Strings::contains_any_ignoring_c_comments(path_and_contents.second, {&sv, 1});
+                });
+            }
+            else
+            {
+                found_absolute = Util::any_of(string_paths, [&path_and_contents, extension](const std::string& path) {
+                    if (extension == "cfg" || extension == "conf")
+                    {
+                        return Strings::contains(path_and_contents.second, path);
+                    }
+                    for (size_t offset = 0;;)
+                    {
+                        const auto index = path_and_contents.second.find(path, offset);
+                        if (index == std::string::npos) return false;
+                        { // .py, .sh, .cmake or .pc file
+                            const auto before = path_and_contents.second.find_last_of("\n#", index);
+                            if (before == std::string::npos) return true;
+                            if (path_and_contents.second[before] == '\n') return true; // not a comment
+                        }
+                        offset = index + path.size();
+                    }
+                });
+            }
+            if (found_absolute)
+            {
+                result += "\n    ";
+                result += path_and_contents.first.native();
+            }
+        }
+
+        if (result.empty())
+        {
+            return LintStatus::SUCCESS;
+        }
+
+        msg::print(Color::warning,
+                   msg::format(msgFilesContainAbsolutePath,
+                               msg::absolute_paths = Strings::join("', '", absolute_paths),
+                               msg::paths = result)
+                       .append_raw("\n\n"));
+        return LintStatus::PROBLEM_DETECTED;
+    }
+
     static void operator+=(size_t& left, const LintStatus& right) { left += static_cast<size_t>(right); }
 
     static size_t perform_all_checks_and_return_error_count(const PackageSpec& spec,
@@ -1153,6 +1244,13 @@ namespace vcpkg::PostBuildLint
         error_count += check_no_files_in_dir(fs, package_dir);
         error_count += check_no_files_in_dir(fs, package_dir / "debug");
         error_count += check_pkgconfig_dir_only_in_lib_dir(fs, package_dir);
+        if (!build_info.policies.is_enabled(BuildPolicy::SKIP_ABSOLUTE_PATHS_CHECK))
+        {
+            error_count += check_no_absolute_paths_in(
+                fs,
+                package_dir,
+                std::vector<Path>{package_dir.native(), paths.installed().root().native(), paths.build_dir(spec)});
+        }
 
         return error_count;
     }