Fix check against symlinks causing errors on Wine

Sunrise/src/client/content/activity/activity_sdk_generation_worker.cpp

@@ -163,7 +163,7 @@ void log_stage_duration(std::string_view stage,
     return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
-/** Accepts only a missing or empty ordinary output root for the internal offline pass. */
+/** Accepts only a missing or empty output root for the internal offline pass. */
 [[nodiscard]] bool isolated_output_ready(std::wstring_view path) noexcept {
     if (path.empty()) {
         return false;
@@ -175,8 +175,7 @@ void log_stage_duration(std::string_view stage,
             const DWORD error = GetLastError();
             return error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND;
         }
-        if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-            || (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+        if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
             return false;
         }
         WIN32_FIND_DATAW entry{};

Sunrise/src/client/content/activity/activity_sdk_live_publication.cpp

@@ -42,7 +42,7 @@ struct Marker final {
     std::array<std::uint8_t, 3> reserved{};
 };
 
-[[nodiscard]] bool ordinary_directory(const wchar_t* path) noexcept;
+[[nodiscard]] bool is_directory(const wchar_t* path) noexcept;
 
 /** Resolves one null-terminated lexical path into normalized absolute storage. */
 [[nodiscard]] bool full_path(const wchar_t* input, std::wstring& output) noexcept {
@@ -77,7 +77,7 @@ struct Marker final {
     if (directory.size() < 3U || directory[1] != L':' || directory[2] != L'\\') {
         return false;
     }
-    if (!ordinary_directory(directory.substr(0, 3U).c_str())) {
+    if (!is_directory(directory.substr(0, 3U).c_str())) {
         return false;
     }
     std::size_t cursor = 3U;
@@ -85,7 +85,7 @@ struct Marker final {
         const std::size_t separator = directory.find(L'\\', cursor);
         const std::size_t end = separator == std::wstring::npos ? directory.size() : separator;
         const std::wstring prefix = directory.substr(0, end);
-        if (!ordinary_directory(prefix.c_str())) {
+        if (!is_directory(prefix.c_str())) {
             return false;
         }
         if (separator == std::wstring::npos) {
@@ -141,24 +141,23 @@ split(std::wstring_view path, std::wstring_view& parent, std::wstring_view& leaf
     return MoveFileExW(source, target, MOVEFILE_WRITE_THROUGH) != FALSE;
 }
 
-/** Requires one ordinary directory and rejects a junction or symbolic-link leaf. */
-[[nodiscard]] bool ordinary_directory(const wchar_t* path) noexcept {
+/** Requires one ordinary directory. */
+[[nodiscard]] bool is_directory(const wchar_t* path) noexcept {
     if (path == nullptr || path[0] == L'\0') {
         return false;
     }
     const DWORD attributes = GetFileAttributesW(path);
-    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-           && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0;
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
 /** Requires one ordinary file and rejects a reparse-backed leaf. */
-[[nodiscard]] bool ordinary_file(const wchar_t* path) noexcept {
+[[nodiscard]] bool is_file(const wchar_t* path) noexcept {
     if (path == nullptr || path[0] == L'\0') {
         return false;
     }
     const DWORD attributes = GetFileAttributesW(path);
     return attributes != INVALID_FILE_ATTRIBUTES
-           && (attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)) == 0;
+           && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
 }
 
 /** Accepts a missing final path or checks its exact expected ordinary kind. */
@@ -170,8 +169,7 @@ split(std::wstring_view path, std::wstring_view& parent, std::wstring_view& leaf
         return error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND;
     }
     exists = true;
-    return (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0
-           && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) == directory;
+    return ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) == directory;
 }
 
 /** Creates one empty ordinary directory or accepts an existing ordinary directory. */
@@ -179,7 +177,7 @@ split(std::wstring_view path, std::wstring_view& parent, std::wstring_view& leaf
     if (CreateDirectoryW(path.c_str(), nullptr) != FALSE) {
         return true;
     }
-    return GetLastError() == ERROR_ALREADY_EXISTS && ordinary_directory(path.c_str());
+    return GetLastError() == ERROR_ALREADY_EXISTS && is_directory(path.c_str());
 }
 
 /** Builds one collision-resistant sibling backup path without consulting global artifact state. */
@@ -216,7 +214,7 @@ split(std::wstring_view path, std::wstring_view& parent, std::wstring_view& leaf
 /** Reads one exact marker without accepting extra bytes or alternate state. */
 [[nodiscard]] bool read_marker(const std::wstring& path, Marker& output) noexcept {
     output = {};
-    if (!ordinary_file(path.c_str())) {
+    if (!is_file(path.c_str())) {
         return false;
     }
     const HANDLE file = CreateFileW(path.c_str(),
@@ -443,7 +441,6 @@ split(std::wstring_view path, std::wstring_view& parent, std::wstring_view& leaf
         }
         const std::wstring path = parent + L"\\" + std::wstring(name);
         if ((entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-            || (entry.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
             || !tree_publication::discard(path.c_str())) {
             complete = false;
         }
@@ -501,8 +498,8 @@ Status allocate(const wchar_t* finalPackPath, Stage& output) noexcept {
         }
         const std::wstring finalSdkDirectory = parentPath + L"\\sdk";
         const std::wstring finalCatalogPath = finalSdkDirectory + L"\\catalog.bin";
-        if (!ordinary_directory(parentPath.c_str())
-            || !ordinary_directory(finalSdkDirectory.c_str())
+        if (!is_directory(parentPath.c_str())
+            || !is_directory(finalSdkDirectory.c_str())
             || !recover(finalSdkDirectory.c_str(), normalizedPack.c_str(), finalCatalogPath.c_str())
             || !discard_stale_stages(parentPath)) {
             return Status::invalidInput;
@@ -579,8 +576,8 @@ Status publish(const Stage& stage,
         || !full_path(stage.catalogPath.c_str(), canonicalStageCatalog)
         || !full_path(finalPackPath, canonicalFinalPack)
         || !full_path(finalCatalogPath, canonicalFinalCatalog)
-        || !ordinary_file(canonicalStagePack.c_str())
-        || !ordinary_file(canonicalStageCatalog.c_str())) {
+        || !is_file(canonicalStagePack.c_str())
+        || !is_file(canonicalStageCatalog.c_str())) {
         return Status::invalidInput;
     }
     const std::wstring expectedStageSdk = canonicalStageRoot + L"\\sdk";

Sunrise/src/client/content/activity/activity_sdk_lua_publish.cpp

@@ -158,7 +158,7 @@ private:
     }
     const DWORD attributes = GetFileAttributesW(path);
     if (attributes == INVALID_FILE_ATTRIBUTES
-        || (attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)) != 0) {
+        || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
         return false;
     }
     const HANDLE file = CreateFileW(path,

Sunrise/src/client/content/activity/activity_sdk_one_shot.cpp

@@ -118,8 +118,7 @@ void report(OfflineProgressSink sink,
             const std::wstring prefix = directory.substr(0, end);
             const DWORD attributes = GetFileAttributesW(prefix.c_str());
             if (attributes == INVALID_FILE_ATTRIBUTES
-                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-                || (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
                 return false;
             }
             if (separator == std::wstring::npos) {
@@ -132,15 +131,14 @@ void report(OfflineProgressSink sink,
     }
 }
 
-/** Canonicalizes one existing directory after rejecting reparse points in its ancestry. */
+/** Canonicalizes one existing directory. */
 [[nodiscard]] bool final_directory_path(std::wstring_view input, std::wstring& output) noexcept {
     std::wstring lexical;
     if (!full_path(input, lexical) || !ordinary_ancestry(lexical)) {
         return false;
     }
     const DWORD attributes = GetFileAttributesW(lexical.c_str());
-    if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-        || (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+    if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
         return false;
     }
     const HANDLE directory = CreateFileW(lexical.c_str(),
@@ -191,7 +189,6 @@ void report(OfflineProgressSink sink,
     const DWORD attributes = GetFileAttributesW(lexical.c_str());
     if (attributes != INVALID_FILE_ATTRIBUTES) {
         return (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-               && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0
                && final_directory_path(lexical, output);
     }
     const std::size_t separator = lexical.find_last_of(L"\\/");

Sunrise/src/client/content/activity/activity_sdk_one_shot_export.cpp

@@ -120,8 +120,7 @@ void copy_result(Status status, const Result& source, public_abi::Result& output
             const std::wstring prefix = directory.substr(0, end);
             const DWORD attributes = GetFileAttributesW(prefix.c_str());
             if (attributes == INVALID_FILE_ATTRIBUTES
-                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-                || (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
                 return false;
             }
             if (separator == std::wstring::npos) {
@@ -155,10 +154,8 @@ void copy_result(Status status, const Result& source, public_abi::Result& output
     const DWORD estateAttributes = GetFileAttributesW(output.c_str());
     return ordinary_ancestry(output) && artifactAttributes != INVALID_FILE_ATTRIBUTES
            && (artifactAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-           && (artifactAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0
            && estateAttributes != INVALID_FILE_ATTRIBUTES
-           && (estateAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-           && (estateAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0;
+           && (estateAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
 /**
@@ -197,8 +194,7 @@ void copy_result(Status status, const Result& source, public_abi::Result& output
         }
         const DWORD attributes = GetFileAttributesW(requestedPath.c_str());
         return attributes == INVALID_FILE_ATTRIBUTES
-               || ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-                   && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0);
+               || ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
     } catch (...) {
         return false;
     }

Sunrise/src/client/content/activity/activity_sdk_shard_cleanup.cpp

@@ -13,7 +13,7 @@ namespace {
 namespace generated = state::activity_sdk::generated_world;
 namespace manifest = state::activity_sdk::generated_world::manifest;
 
-/** Resolves one directory and rejects every reparse-backed ancestor component. */
+/** Resolves one directory. */
 [[nodiscard]] bool ordinary_directory_path(const std::wstring& input,
                                            std::wstring& output) noexcept {
     output.clear();
@@ -40,8 +40,7 @@ namespace manifest = state::activity_sdk::generated_world::manifest;
             const std::wstring prefix = output.substr(0, end);
             const DWORD attributes = GetFileAttributesW(prefix.c_str());
             if (attributes == INVALID_FILE_ATTRIBUTES
-                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
-                || (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+                || (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
                 output.clear();
                 return false;
             }
@@ -148,10 +147,6 @@ bool clean_stale_shards(const std::wstring& directory,
         std::uint32_t scenarioTag = 0;
         generated::Digest digest{};
         if (parse_shard_leaf(leaf, scenarioTag, digest)) {
-            if ((found.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
-                complete = false;
-                continue;
-            }
             const auto record =
                 std::lower_bound(active.begin(),
                                  active.end(),

Sunrise/src/client/content/activity/activity_sdk_tree_publication.cpp

@@ -53,31 +53,30 @@ struct Marker final {
     }
 }
 
-/** Requires one existing ordinary directory and rejects a reparse-backed leaf. */
-[[nodiscard]] bool ordinary_directory(const wchar_t* path) noexcept {
+/** Requires one existing ordinary directory. */
+[[nodiscard]] bool is_directory(const wchar_t* path) noexcept {
     const DWORD attributes = GetFileAttributesW(path);
-    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-           && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0;
+    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
-/** Requires one existing ordinary file and rejects a reparse-backed leaf. */
-[[nodiscard]] bool ordinary_file(const wchar_t* path) noexcept {
+/** Requires one existing ordinary file. */
+[[nodiscard]] bool is_file(const wchar_t* path) noexcept {
     const DWORD attributes = GetFileAttributesW(path);
     return attributes != INVALID_FILE_ATTRIBUTES
-           && (attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT)) == 0;
+           && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
 }
 
 /** Requires every existing drive-path directory component to be ordinary. */
 [[nodiscard]] bool ordinary_ancestry(const std::wstring& directory) noexcept {
     if (directory.size() < 3U || directory[1] != L':' || directory[2] != L'\\'
-        || !ordinary_directory(directory.substr(0, 3U).c_str())) {
+        || !is_directory(directory.substr(0, 3U).c_str())) {
         return false;
     }
     std::size_t cursor = 3U;
     while (cursor < directory.size()) {
         const std::size_t separator = directory.find(L'\\', cursor);
         const std::size_t end = separator == std::wstring::npos ? directory.size() : separator;
-        if (!ordinary_directory(directory.substr(0, end).c_str())) {
+        if (!is_directory(directory.substr(0, end).c_str())) {
             return false;
         }
         if (separator == std::wstring::npos) {
@@ -192,7 +191,7 @@ sibling_path(std::wstring_view output, std::wstring_view suffix, std::wstring& s
 /** Reads one exact marker without accepting trailing bytes or noncanonical fields. */
 [[nodiscard]] bool read_marker(const std::wstring& path, Marker& output) noexcept {
     output = {};
-    if (!ordinary_file(path.c_str())) {
+    if (!is_file(path.c_str())) {
         return false;
     }
     const HANDLE file = CreateFileW(path.c_str(),
@@ -225,8 +224,7 @@ sibling_path(std::wstring_view output, std::wstring_view suffix, std::wstring& s
         return error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND;
     }
     exists = true;
-    return (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0
-           && (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0;
+    return (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
 /** Restores or finalizes one interrupted transaction before any new publication begins. */
@@ -324,7 +322,7 @@ Status publish(const wchar_t* stage,
     } catch (...) {
         return Status::invalidInput;
     }
-    if (!ordinary_ancestry(parent) || !ordinary_directory(canonicalStage.c_str())) {
+    if (!ordinary_ancestry(parent) || !is_directory(canonicalStage.c_str())) {
         return Status::invalidInput;
     }
     std::wstring backup;