Fix startup

Author: timkicker

src/app/App.cpp

@@ -7,10 +7,12 @@ extern void elog(const char* msg);
 #include "ui/MainLayout.h"
 #include "util/Logger.h"
 #include <cstdarg>
+#include <cerrno>
 #include <sys/stat.h>
 #include "net/DownloadQueue.h"
 #include <sysapp/launch.h>
 #include "util/ImageCache.h"
+#include "util/TextCache.h"
 #include "app/CacheManager.h"
 
 #include <SDL2/SDL.h>
@@ -20,13 +22,11 @@ extern void elog(const char* msg);
 #include <SDL2/SDL_image.h>
 
 #ifdef __WUT__
-#if BUILD_HW
 #include <nn/ac.h>
 extern "C" {
     void socket_lib_init();
 }
 #endif
-#endif
 
 App::App() = default;
 
@@ -37,6 +37,8 @@ App::~App() {
     m_screens.clear();
     elog("~App: ImageCache clear");
     if (m_renderer) ImageCache::get().clear(m_renderer);
+    elog("~App: TextCache clear");
+    TextCache::get().clear();
     elog("~App: DestroyRenderer");
     if (m_renderer) SDL_DestroyRenderer(m_renderer);
     elog("~App: DestroyWindow");
@@ -53,12 +55,14 @@ App::~App() {
 bool App::init() {
     elog("Network init...");
 #ifdef __WUT__
-#if BUILD_HW
+    // Initialize the WUT network stack on both hardware AND Cemu builds.
+    // Without these calls, Cemu's emulated socket layer never finishes
+    // setup and curl connect() hangs. The previous BUILD_HW gate broke
+    // cemu mode entirely (app stuck on "Loading repos...").
     nn::ac::Initialize();
     nn::ac::Connect();
     socket_lib_init();
     elog("Network ready");
-#endif
 #endif
 
     if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) != 0) {
@@ -97,7 +101,9 @@ bool App::init() {
     elog("Renderer OK");
 
     elog("before logger");
-    mkdir((Paths::modstoreBase()).c_str(), 0755);
+    if (mkdir((Paths::modstoreBase()).c_str(), 0755) != 0 && errno != EEXIST) {
+        elog("mkdir for app dir failed - logger may not work");
+    }
     elog("mkdir done");
     Logger::get().init(Paths::modstoreBase() + "/app.log");
     elog("logger init done");
@@ -115,13 +121,17 @@ bool App::init() {
 
 void App::run() {
     m_running = true;
+    int pruneCounter = 0;
     while (m_running && !m_screens.empty() && WHBProcIsRunning()) {
         SDL_Event event;
         while (SDL_PollEvent(&event)) {
             if (event.type == SDL_QUIT) m_running = false;
         }
         update();
         render();
+        TextCache::get().tick();
+        // Prune unused text textures every ~5 seconds (at 60fps).
+        if (++pruneCounter > 300) { TextCache::get().prune(); pruneCounter = 0; }
     }
 #ifdef __WUT__
     // Drain ProcUI until Aroma confirms exit - required for WHBProcShutdown to work

src/app/CacheManager.cpp

@@ -1,6 +1,7 @@
 #include "CacheManager.h"
 #include "app/Paths.h"
 #include "util/Logger.h"
+#include "net/DownloadManager.h"
 
 #include <dirent.h>
 #include <sys/stat.h>
@@ -65,25 +66,12 @@ void CacheManager::cleanupCorruptMods() {
                 struct stat st;
                 if (stat(modinfoPath.c_str(), &st) == 0) continue; // ok
 
-                // No modinfo.json - corrupt/partial install, remove it
+                // No modinfo.json - corrupt/partial install, remove it.
+                // Use the proper recursive rmrf -- the inline single-level
+                // delete here used to leave nested subdirectories behind.
                 LOG_WARN("CacheManager: corrupt mod folder (no modinfo.json): %s/%s - removing",
                          titleId.c_str(), modId.c_str());
-
-                // rmrf the mod folder
-                // Simple recursive delete
-                std::string cmd = modPath; // we'll do it manually
-                DIR* d2 = opendir(modPath.c_str());
-                if (d2) {
-                    struct dirent* f;
-                    while ((f = readdir(d2)) != nullptr) {
-                        std::string fn = f->d_name;
-                        if (fn == "." || fn == "..") continue;
-                        std::string fp = modPath + "/" + fn;
-                        remove(fp.c_str());
-                    }
-                    closedir(d2);
-                }
-                if (rmdir(modPath.c_str()) == 0) removed++;
+                if (DownloadManager::rmrf(modPath)) removed++;
             }
             closedir(modDir);
         }

src/app/Config.cpp

@@ -4,6 +4,8 @@
 #include <json.hpp>
 #include <fstream>
 #include <sys/stat.h>
+#include <cerrno>
+#include <cstring>
 
 bool Config::loadFrom(const std::string& path) {
     LOG_INFO("Loading config from: %s", path.c_str());
@@ -49,6 +51,8 @@ bool Config::load() {
 
 bool Config::save() {
     std::string base = Paths::modstoreBase();
-    mkdir(base.c_str(), 0755);
+    if (mkdir(base.c_str(), 0755) != 0 && errno != EEXIST) {
+        LOG_WARN("Config: mkdir(%s) failed: %s", base.c_str(), strerror(errno));
+    }
     return saveTo(configPath());
 }

src/audio/AudioManager.cpp

@@ -43,7 +43,10 @@ void AudioManager::shutdown() {
     stopMusic();
     for (auto& [id, chunk] : m_sounds) Mix_FreeChunk(chunk);
     m_sounds.clear();
-    if (m_music) { Mix_FreeMusic(m_music); m_music = nullptr; }
+    {
+        std::lock_guard<std::mutex> lock(m_musicMutex);
+        if (m_music) { Mix_FreeMusic(m_music); m_music = nullptr; }
+    }
     Mix_CloseAudio();
     Mix_Quit();
     m_initialized = false;
@@ -58,6 +61,7 @@ void AudioManager::playSound(SoundId id) {
 void AudioManager::playMusic(MusicTrack track) {
     if (!m_initialized || !m_musicEnabled) return;
     const char* file = (track == MusicTrack::Main) ? "theme_main.ogg" : "theme_alt.ogg";
+    std::lock_guard<std::mutex> lock(m_musicMutex);
     if (Mix_PlayingMusic() && m_currentTrack == track) return;
     if (m_music) { Mix_FreeMusic(m_music); m_music = nullptr; }
     m_music = Mix_LoadMUS(sndPath(file).c_str());
@@ -67,9 +71,23 @@ void AudioManager::playMusic(MusicTrack track) {
     m_currentTrack = track;
 }
 
+void AudioManager::playMusicFadeIn(MusicTrack track, int fadeMs) {
+    if (!m_initialized || !m_musicEnabled) return;
+    const char* file = (track == MusicTrack::Main) ? "theme_main.ogg" : "theme_alt.ogg";
+    std::lock_guard<std::mutex> lock(m_musicMutex);
+    if (Mix_PlayingMusic() && m_currentTrack == track) return;
+    if (m_music) { Mix_FreeMusic(m_music); m_music = nullptr; }
+    m_music = Mix_LoadMUS(sndPath(file).c_str());
+    if (!m_music) { LOG_WARN("AudioManager: failed to load %s: %s", file, Mix_GetError()); return; }
+    Mix_VolumeMusic(64);
+    Mix_FadeInMusic(m_music, -1, fadeMs);
+    m_currentTrack = track;
+}
+
 void AudioManager::stopMusic() {
     if (!m_initialized) return;
     Mix_HaltMusic();
+    std::lock_guard<std::mutex> lock(m_musicMutex);
     if (m_music) { Mix_FreeMusic(m_music); m_music = nullptr; }
 }
 

src/audio/AudioManager.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <string>
 #include <unordered_map>
+#include <mutex>
 #include <SDL2/SDL_mixer.h>
 
 enum class SoundId {
@@ -23,6 +24,7 @@ class AudioManager {
     void shutdown();
     void playSound(SoundId id);
     void playMusic(MusicTrack track);
+    void playMusicFadeIn(MusicTrack track, int fadeMs);
     void stopMusic();
     bool musicEnabled() const { return m_musicEnabled; }
     bool soundEnabled() const { return m_soundEnabled; }
@@ -36,4 +38,5 @@ class AudioManager {
     MusicTrack m_currentTrack = MusicTrack::Main;
     std::unordered_map<int, Mix_Chunk*> m_sounds;
     Mix_Music* m_music = nullptr;
+    std::mutex m_musicMutex; // protects m_music + m_currentTrack
 };

src/main.cpp

@@ -20,16 +20,31 @@ extern "C" {
 }
 #endif
 
-static FILE* g_elog = nullptr;
+static const char* g_elog_path = nullptr;
 void elog(const char* msg) {
-    if (g_elog) { 
-        fprintf(g_elog, "%s\n", msg); 
-        fflush(g_elog);
-        fsync(fileno(g_elog));
+    // Always send via WHBLog so udplogserver picks it up.
+    WHBLogPrintf("[elog] %s", msg);
+    // On Cemu, FILE buffers don't reliably reach the host before kill, even
+    // with fflush+fsync. Reopen+append+close per call is slower but durable.
+    if (g_elog_path) {
+        FILE* f = fopen(g_elog_path, "a");
+        if (f) {
+            fprintf(f, "%s\n", msg);
+            fclose(f);
+        }
     }
 }
 
 int main(int argc, char** argv) {
+    // Diagnostic: prove main() was called before ANY WHB/SDL init.
+    {
+        FILE* probe = fopen("/vol/external01/wiiu/apps/coffeeshop/main_called.txt", "w");
+        if (probe) {
+            fprintf(probe, "main reached\n");
+            fclose(probe);
+        }
+    }
+
     WHBProcInit();
     WHBLogUdpInit();
 
@@ -43,7 +58,21 @@ int main(int argc, char** argv) {
     Paths::sdMounted = false;
 #endif
 
-    g_elog = fopen("fs:/vol/external01/wiiu/apps/coffeeshop/early.log", "w");
+    // On hardware the SD mounts at "fs:/vol/external01/..." (Aroma WHB mount).
+    // In Cemu the prefix is invalid -- pick whichever opens.
+    {
+        FILE* probe = fopen("fs:/vol/external01/wiiu/apps/coffeeshop/early.log", "w");
+        if (probe) {
+            fclose(probe);
+            g_elog_path = "fs:/vol/external01/wiiu/apps/coffeeshop/early.log";
+        } else {
+            probe = fopen("/vol/external01/wiiu/apps/coffeeshop/early.log", "w");
+            if (probe) {
+                fclose(probe);
+                g_elog_path = "/vol/external01/wiiu/apps/coffeeshop/early.log";
+            }
+        }
+    }
     elog("START");
     elog(Paths::sdMounted ? "SD mounted" : "SD failed");
 
@@ -76,8 +105,8 @@ int main(int argc, char** argv) {
     elog("ac::Finalize");
     nn::ac::Finalize();
 #endif
-    elog("WHBProcShutdown");
-    if (g_elog) { fflush(g_elog); fclose(g_elog); g_elog = nullptr; }
-    WHBProcShutdown();
+    // elog uses open+write+close per call; nothing to fclose at exit.
+    // WHBProcShutdown intentionally omitted (CLAUDE.md): App::run drains
+    // ProcUI and SYSLaunchMenu hands control back to the OS.
     return 0;
 }

src/mods/InstalledScanner.cpp

@@ -13,26 +13,66 @@ static bool isDir(const std::string& path) {
     return stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode);
 }
 
+// Iterate "/"-delimited boundaries instead of running mkdir at every char index.
+// Saves O(path-length) syscalls on slow SD-card filesystems.
 static void mkdirp(const std::string& path) {
-    for (size_t i = 1; i <= path.size(); i++) {
-        if (i == path.size() || path[i] == '/')
-            mkdir(path.substr(0, i).c_str(), 0755);
+    size_t pos = 1;
+    while (pos < path.size()) {
+        size_t slash = path.find('/', pos);
+        if (slash == std::string::npos) break;
+        mkdir(path.substr(0, slash).c_str(), 0755);
+        pos = slash + 1;
     }
+    mkdir(path.c_str(), 0755);
 }
 
-static bool rmrf(const std::string& path) {
+// Recursive delete with symlink-loop protection.
+// - Uses lstat (not stat) so symlinks are detected before recursion.
+// - Tracks visited (dev,inode) pairs so a directory hardlinked or
+//   symlinked-into-itself can't trap us in infinite recursion.
+// - Caps recursion depth at 64 -- Wii U mods don't go that deep, anything
+//   beyond is malicious or corrupt.
+#include <set>
+struct VisitedKey { dev_t dev; ino_t ino; };
+static bool operator<(const VisitedKey& a, const VisitedKey& b) {
+    if (a.dev != b.dev) return a.dev < b.dev;
+    return a.ino < b.ino;
+}
+
+static bool rmrfImpl(const std::string& path, std::set<VisitedKey>& visited, int depth) {
+    if (depth > 64) {
+        LOG_WARN("rmrf: depth limit hit at %s -- aborting", path.c_str());
+        return false;
+    }
+    struct stat st;
+    if (lstat(path.c_str(), &st) != 0) return true; // already gone
+    if (!S_ISDIR(st.st_mode)) {
+        // Symlink or regular file -- remove without following.
+        return remove(path.c_str()) == 0;
+    }
+    VisitedKey key{st.st_dev, st.st_ino};
+    if (!visited.insert(key).second) {
+        LOG_WARN("rmrf: cycle detected at %s -- aborting", path.c_str());
+        return false;
+    }
+
     DIR* d = opendir(path.c_str());
-    if (!d) { remove(path.c_str()); return true; }
+    if (!d) return false;
+    bool ok = true;
     struct dirent* e;
     while ((e = readdir(d)) != nullptr) {
         std::string name = e->d_name;
         if (name == "." || name == "..") continue;
-        std::string child = path + "/" + name;
-        if (isDir(child)) rmrf(child);
-        else ::remove(child.c_str());
+        if (!rmrfImpl(path + "/" + name, visited, depth + 1)) ok = false;
     }
     closedir(d);
-    return rmdir(path.c_str()) == 0;
+    if (rmdir(path.c_str()) != 0) ok = false;
+    return ok;
+}
+
+static bool rmrf(const std::string& path) {
+    std::set<VisitedKey> visited;
+    return rmrfImpl(path, visited, 0);
 }
 
 static std::vector<std::string> listDirs(const std::string& path) {
@@ -115,6 +155,17 @@ bool InstalledScanner::setActive(InstalledMod& mod, bool active) {
 
     mkdirp(dstDir);
 
+    // Some platforms refuse rename() if dst exists. If a stale folder is in
+    // the way (e.g. previous failed activation), remove it first.
+    struct stat st;
+    if (stat(dst.c_str(), &st) == 0) {
+        LOG_WARN("InstalledScanner: rename target exists, removing first: %s", dst.c_str());
+        if (!rmrf(dst)) {
+            LOG_ERROR("InstalledScanner: could not clear rename target: %s", dst.c_str());
+            return false;
+        }
+    }
+
     if (rename(src.c_str(), dst.c_str()) != 0) {
         LOG_ERROR("InstalledScanner: rename failed: %s -> %s", src.c_str(), dst.c_str());
         return false;