Fix emulator hanging on game closure

Author: Raytwo

include/nn/socket.h

@@ -29,5 +29,14 @@ class Config;
     u32 Listen(s32 socket, s32 backlog);
     u32 Accept(s32 socket, sockaddr* addrOut, u32* addrLenOut);
     s32 Close(s32 socket);
+    s32 Shutdown(s32 socket, s32 how);
+
+    struct PollFd {
+        s32 fd;
+        s16 events;
+        s16 revents;
+    };
+
+    s32 Poll(PollFd* fds, u64 nfds, s32 timeout);
 };  // namespace socket
 };  // namespace nn

include/skyline/logger/DualLogger.hpp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <string>
-
 #include <arpa/inet.h>
 
 #include "alloc.h"
@@ -12,13 +10,28 @@
 #include "skyline/inlinehook/And64InlineHook.hpp"
 #include "skyline/logger/Logger.hpp"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "skyline/nx/kernel/svc.h"
+
+#ifdef __cplusplus
+}
+#endif
+
 namespace skyline::logger {
+
+// Logger that sends to both svcOutputDebugString and a TCP socket
 class DualLogger : public Logger {
    public:
-    DualLogger(std::string);
-
     virtual void Initialize();
+    virtual bool ShouldFlush() override;
     virtual void SendRaw(void*, size_t);
     virtual std::string FriendlyName() { return "DualLogger"; }
 };
-};  // namespace skyline::logger
+
+    void setup_socket_hooks();
+    void skyline_socket_init();
+    void start_listen_thread();
+};  // namespace skyline::logger

include/skyline/logger/TcpLogger.hpp

@@ -22,6 +22,7 @@ class TcpLogger : public Logger {
 
     void setup_socket_hooks();
     void skyline_socket_init();
+    void skyline_socket_finalize();
     void start_listen_thread();
 };  // namespace skyline::logger
 

source/main.cpp

@@ -1,6 +1,6 @@
 #include "main.hpp"
 
-#include "skyline/logger/TcpLogger.hpp"
+#include "skyline/logger/DualLogger.hpp"
 #include "skyline/utils/ipc.hpp"
 #include "skyline/utils/cpputils.hpp"
 #include "skyline/utils/utils.h"
@@ -104,7 +104,7 @@ void skyline_main() {
 
     // initialize logger
     nn::fs::MountSdCardForDebug("sd");
-    skyline::logger::s_Instance = new skyline::logger::TcpLogger();
+    skyline::logger::s_Instance = new skyline::logger::DualLogger();
     skyline::logger::s_Instance->StartThread();
     skyline::logger::s_Instance->Log("[skyline_main] Beginning initialization.\n");
 

source/skyline/logger/DualLogger.cpp

@@ -1,74 +1,121 @@
-
 #include "skyline/logger/DualLogger.hpp"
+
+#include <atomic>
+
 #include "skyline/utils/cpputils.hpp"
-#include "nn/fs.h"
 
 #define PORT 6969
+#define POLLIN 0x01
 
-extern "C" void skyline_dual_send_raw(char* data, size_t size) __attribute__((visibility("default")));
+extern "C" void skyline_tcp_send_raw(char* data, size_t size) __attribute__((visibility("default")));
 
-void skyline_dual_send_raw(char* data, u64 size) { skyline::logger::s_Instance->Log(data, size); }
+void skyline_tcp_send_raw(char* data, u64 size) { skyline::logger::s_Instance->Log(data, size); }
 
 namespace skyline::logger {
-nn::fs::FileHandle dualfileHandle;
-s64 Dualoffset;
-int g_dualtcpSocket;
-
-DualLogger::DualLogger(std::string path) {
-    nn::fs::DirectoryEntryType type;
-    Result rc = nn::fs::GetEntryType(&type, path.c_str());
-
-    if (rc == 0x202) {  // Path does not exist
-        rc = nn::fs::CreateFile(path.c_str(), 0);
-    } else if (R_FAILED(rc))
-        return;
-
-    if (type == nn::fs::DirectoryEntryType_Directory) return;
-
-    R_ERRORONFAIL(nn::fs::OpenFile(&dualfileHandle, path.c_str(), nn::fs::OpenMode_ReadWrite | nn::fs::OpenMode_Append));
-}
+int g_tcpSocket = -1;
+static std::atomic<bool> g_loggerInit{false};
 
-void DualLogger::Initialize() {
-    // Sockets are already initialized by skyline_socket_init() in TcpLogger.cpp.
-    // Just set up the TCP accept for this logger's socket.
+Result stub() { return 0; };
 
+void init_socket_thing(void*) {
     struct sockaddr_in serverAddr;
-    g_dualtcpSocket = nn::socket::Socket(AF_INET, SOCK_STREAM, 0);
-    if (g_dualtcpSocket < 0) return;
+    s32 listenSocket = nn::socket::Socket(AF_INET, SOCK_STREAM, 0);
+    if (listenSocket < 0) return;
 
     int flags = 1;
-    nn::socket::SetSockOpt(g_dualtcpSocket, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags));
+    nn::socket::SetSockOpt(listenSocket, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags));
 
     serverAddr.sin_family = AF_INET;
     serverAddr.sin_addr.s_addr = INADDR_ANY;
     serverAddr.sin_port = nn::socket::InetHtons(PORT);
 
-    int rval = nn::socket::Bind(g_dualtcpSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
+    int rval = nn::socket::Bind(listenSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
     if (rval < 0) {
-        nn::socket::Close(g_dualtcpSocket);
+        nn::socket::Close(listenSocket);
         return;
     }
 
-    rval = nn::socket::Listen(g_dualtcpSocket, 1);
+    rval = nn::socket::Listen(listenSocket, 1);
     if (rval < 0) {
-        nn::socket::Close(g_dualtcpSocket);
+        nn::socket::Close(listenSocket);
         return;
     }
 
-    u32 addrLen = sizeof(serverAddr);
-    s32 listenSocket = g_dualtcpSocket;
-    g_dualtcpSocket = nn::socket::Accept(listenSocket, (struct sockaddr*)&serverAddr, &addrLen);
+    // Poll with a 1-second timeout to let the thread exit cleanly on emulator
+    s32 clientSocket = -1;
+    while (true) {
+        nn::socket::PollFd pfd;
+        pfd.fd = listenSocket;
+        pfd.events = POLLIN;
+        pfd.revents = 0;
+
+        s32 pollResult = nn::socket::Poll(&pfd, 1, 1000);
+        if (pollResult > 0 && (pfd.revents & POLLIN)) {
+            u32 addrLen = sizeof(serverAddr);
+            clientSocket = nn::socket::Accept(listenSocket, (struct sockaddr*)&serverAddr, &addrLen);
+            break;
+        }
+    }
+
     nn::socket::Close(listenSocket);
+
+    if (clientSocket < 0) return;
+    g_tcpSocket = clientSocket;
+
+    char* message = "TCP Socket Connected.\n";
+    nn::socket::Send(g_tcpSocket, (void*)message, strlen(message), 0);
 }
 
-void DualLogger::SendRaw(void* data, size_t size) {
-    nn::fs::SetFileSize(dualfileHandle, Dualoffset + size);
+void skyline_socket_init() {
+    const size_t poolSize = 0x600000;
+    void* socketPool = memalign(0x4000, poolSize);
+    nn::socket::Initialize(socketPool, poolSize, 0x20000, 14);
+
+    g_loggerInit.store(true, std::memory_order_release);
+}
 
-    nn::socket::Send(g_dualtcpSocket, data, size, 0);
+void start_listen_thread() {
+    const size_t stackSize = 0x4000;
+    void* threadStack = memalign(0x1000, stackSize);
 
-    nn::fs::WriteFile(dualfileHandle, Dualoffset, data, size,
-                      nn::fs::WriteOption::CreateOption(nn::fs::WriteOptionFlag_Flush));
+    nn::os::ThreadType* thread = new nn::os::ThreadType;
+    nn::os::CreateThread(thread, init_socket_thing, nullptr, threadStack, stackSize, 16, 0);
+    nn::os::StartThread(thread);
+}
+
+Result init_normal(void* arg1, ulong arg2, ulong arg3, int arg4) {
+    return 0;
+}
+
+Result init_config(nn::socket::Config const& config) {
+    return 0;
+}
+
+void setup_socket_hooks() {
+    Result (*socketInitWithPool)(void*, ulong, ulong, int) = nn::socket::Initialize;
+    A64HookFunction(reinterpret_cast<void*>(socketInitWithPool), reinterpret_cast<void*>(init_normal),
+                    NULL);
+
+    Result (*socketInitWithConfig)(nn::socket::Config const&) = nn::socket::Initialize;
+    A64HookFunction(reinterpret_cast<void*>(socketInitWithConfig), reinterpret_cast<void*>(init_config),
+                    NULL);
+
+    A64HookFunction(reinterpret_cast<void*>(nn::socket::Finalize), reinterpret_cast<void*>(stub),
+                    NULL);
+}
+
+void DualLogger::Initialize() {}
+
+bool DualLogger::ShouldFlush() {
+    return true;
+}
 
-    Dualoffset += size;
-};
+void DualLogger::SendRaw(void* data, size_t size) {
+    svcOutputDebugString((const char*)data, size);
+
+    // Also send to TCP if a client is connected
+    if (g_loggerInit.load(std::memory_order_acquire) && g_tcpSocket != -1) {
+        nn::socket::Send(g_tcpSocket, data, size, 0);
+    }
+}
 };  // namespace skyline::logger