clip: use xclip on linux

reason: launching 2 instances of oshot will make the last instance freeze until the original exits on X11

removing the socket on next commit

Author: Toni500github

src/clipboard.cpp

@@ -5,52 +5,61 @@
 #include <cstring>
 
 #include "clip/clip.h"
+#include "screen_capture.hpp"
 #include "socket.hpp"
 
 #ifdef __linux__
 #  include <sys/wait.h>
 #  include <unistd.h>
 #endif
 
-// Starts wlcopy in the background, forgetting it.
-// Sets wlcopy_pid, and returns an stdin pipe on success.
-Result<int> start_wlcopy(const std::string_view mime_type = "text/plain;charset=utf-8")
+// Starts wlcopy/xclip in the background, forgetting it.
+// Sets wlcopy_pid/xclip_pid, and returns an stdin pipe on success.
+Result<int> start_linux_copy(SessionType session, const std::string_view mime_type = "text/plain;charset=utf-8")
 {
 #ifdef __linux__
-    static int wlcopy_pid = -1;
+    static pid_t clip_pid = -1;
 
-    // stop if already launched
-    if (wlcopy_pid > 0)
+    // stop if already launched wlcopy
+    if (clip_pid > 0)
     {
-        kill(wlcopy_pid, SIGINT);
+        kill(clip_pid, SIGINT);
 
         // we need to do this on Linux, because the process will be defunct otherwise.
-        waitpid(wlcopy_pid, NULL, 0);
+        waitpid(clip_pid, NULL, 0);
 
-        wlcopy_pid = -1;
+        clip_pid = -1;
     }
 
     int copy_pipe[2];
     if (pipe(copy_pipe) == -1)
         return Err("Failed to open stdin pipe: " + std::string(strerror(errno)));
 
-    wlcopy_pid = fork();
+    clip_pid = fork();
 
-    if (wlcopy_pid == 0)
+    if (clip_pid == 0)
     {
         close(copy_pipe[1]);
         dup2(copy_pipe[0], STDIN_FILENO);
         close(copy_pipe[0]);
 
-        const char* args[] = { "wl-copy", "--foreground", "--type", mime_type.data(), nullptr };
-        execvp("wl-copy", const_cast<char* const*>(args));
+        if (session == SessionType::Wayland)
+        {
+            const char* args[] = { "wl-copy", "--foreground", "--type", mime_type.data(), nullptr };
+            execvp("wl-copy", const_cast<char* const*>(args));
+        }
+        else
+        {
+            const char* args[] = { "xclip", "-selection", "clipboard", "-t", mime_type.data(), "-i", nullptr };
+            execvp("xclip", const_cast<char* const*>(args));
+        }
 
         exit(-1);
     }
 
     close(copy_pipe[0]);
 
-    if (wlcopy_pid < 0)
+    if (clip_pid < 0)
     {
         close(copy_pipe[1]);
         return Err("Failed to fork: " + std::string(strerror(errno)));
@@ -64,9 +73,9 @@ Result<int> start_wlcopy(const std::string_view mime_type = "text/plain;charset=
 
 Result<> Clipboard::CopyText(const std::string& text)
 {
-    if (m_session == SessionType::Wayland)
+    if (m_session == SessionType::Wayland || m_session == SessionType::X11)
     {
-        const Result<int>& res = start_wlcopy();
+        const Result<int>& res = start_linux_copy(m_session);
         if (!res.ok())
             return res.error();
 
@@ -82,15 +91,6 @@ Result<> Clipboard::CopyText(const std::string& text)
         return Ok();
     }
 
-    // Linux only, external client with systray already running
-    if (!g_is_systray && !OSHOT_TOOL_ON_MAIN_THREAD && g_sender->IsConnected())
-    {
-        const Result<>& res = g_sender->Send(text);
-        if (res.ok())
-            return Ok();
-        return Err("Failed to send text to copy: " + res.error_v());
-    }
-
     if (clip::set_text(text))
         return Ok();
     return Err("Failed to copy text into clipboard");
@@ -101,9 +101,9 @@ Result<> Clipboard::CopyImage(const capture_result_t& cap)
     if (cap.w <= 0 || cap.h <= 0)
         return Err("Image size is empty");
 
-    if (m_session == SessionType::Wayland)
+    if (m_session == SessionType::Wayland || m_session == SessionType::X11)
     {
-        const Result<int>& res = start_wlcopy("image/png");
+        const Result<int>& res = start_linux_copy(m_session, "image/png");
         if (!res.ok())
             return res.error();
 
@@ -121,23 +121,6 @@ Result<> Clipboard::CopyImage(const capture_result_t& cap)
         return Ok();
     }
 
-    // Linux only, external client with systray already running
-    if (!g_is_systray && !OSHOT_TOOL_ON_MAIN_THREAD && g_sender->IsConnected())
-    {
-        const size_t         size = static_cast<size_t>(cap.w) * cap.h * 4;
-        std::vector<uint8_t> payload;
-        payload.resize(8 + size);
-
-        std::memcpy(payload.data() + 0, &cap.w, 4);
-        std::memcpy(payload.data() + 4, &cap.h, 4);
-        std::memcpy(payload.data() + 8, cap.view().data(), size);
-
-        const Result<>& res = g_sender->Send(SendMsg::Image, payload.data(), payload.size());
-        if (res.ok())
-            return Ok();
-        return Err("Failed to send image to copy: " + res.error_v());
-    }
-
     clip::image_spec spec;
     spec.width          = cap.w;
     spec.height         = cap.h;

src/main.cpp

@@ -14,6 +14,8 @@
 #include <thread>
 #include <utility>
 
+#include "fmt/format.h"
+
 #ifndef _WIN32
 #  include <netdb.h>
 #  include <netinet/in.h>
@@ -197,7 +199,7 @@ static bool                    do_capture = false;
 static capture_result_t        pending_image;
 static bool                    do_copy_image = false;
 
-void exit_handler(int _)
+void exit_handler(int)
 {
     quit.store(true);
     cv.notify_all();
@@ -207,6 +209,12 @@ void exit_handler(int _)
 #endif
     extern_glfwTerminate();
     trayMaker.Exit();
+    std::error_code ec;
+    fs::remove(fs::temp_directory_path(ec) / fmt::format("oshot_{}.log", getpid()));
+}
+void exit_handler_nc()
+{
+    exit_handler(0);
 }
 
 int run_main_tool(const std::string& imgui_ini_path);
@@ -333,7 +341,7 @@ int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
 #else
 int main(int argc, char* argv[])
 {
-    const fs::path& log_path = fs::temp_directory_path(ec) / "oshot.log";
+    const fs::path& log_path = fs::temp_directory_path(ec) / fmt::format("oshot_{}.log", getpid());
     fs::create_directories(log_path.parent_path(), ec);
     auto file = std::make_shared<spdlog::sinks::basic_file_sink_mt>(log_path.string(), true);
 #endif
@@ -356,6 +364,7 @@ int main(int argc, char* argv[])
     XInitThreads();
 #endif
 
+    atexit(exit_handler_nc);
     signal(SIGINT, exit_handler);
     signal(SIGTERM, exit_handler);
     signal(SIGABRT, exit_handler);
@@ -376,6 +385,13 @@ int main(int argc, char* argv[])
 
     // [2026-03-10 17:24:07.593] [DEBUG] XRandR capturing: monitor 1920x1080+0+0 (cursor at 1130,682)
     logger.set_pattern("[%Y-%m-%d %T.%e] [%l] %^%v%$");
+    logger.flush_on(spdlog::level::trace);
+
+    logger.info("=== oshot starting ===");
+    logger.info("Log file path: {}", log_path.string());
+    logger.flush();
+
+    spdlog::flush_every(std::chrono::seconds(1));
 
     // Check if demo build.
     // removing it once the hackaton has ended
@@ -439,15 +455,28 @@ int main(int argc, char* argv[])
                 continue;
             }
 
+            // Set receive timeout
+            struct timeval tv;
+            tv.tv_sec  = 2;
+            tv.tv_usec = 0;
+            setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
             auto recv_all = [](int fd, void* dst, size_t n) {
-                uint8_t* p = static_cast<uint8_t*>(dst);
-                while (n)
+                uint8_t* p         = static_cast<uint8_t*>(dst);
+                size_t   remaining = n;
+                while (remaining > 0)
                 {
-                    const ssize_t r = ::recv(fd, p, n, 0);
+                    const ssize_t r = ::recv(fd, p, remaining, 0);
                     if (r <= 0)
+                    {
+                        if (r == 0)
+                            spdlog::debug("Connection closed by peer");
+                        else
+                            spdlog::debug("recv error: {}", strerror(errno));
                         return false;
+                    }
                     p += static_cast<size_t>(r);
-                    n -= static_cast<size_t>(r);
+                    remaining -= static_cast<size_t>(r);
                 }
                 return true;
             };
@@ -457,11 +486,15 @@ int main(int argc, char* argv[])
 
             bool ok = recv_all(client, &type, 1) && recv_all(client, &len, sizeof(len));
 
-            std::vector<uint8_t> payload;
-            payload.resize(len);
+            if (ok)
+                spdlog::debug("IPC received type={}, len={}", type, len);
 
-            if (ok && len > 0)
+            std::vector<uint8_t> payload;
+            if (ok && len > 0 && len < 100 * 1024 * 1024)  // Sanity check: max 100MB
+            {
+                payload.resize(len);
                 ok = recv_all(client, payload.data(), payload.size());
+            }
 
             close(client);
 
@@ -476,18 +509,26 @@ int main(int argc, char* argv[])
             else if (type == 'I')
             {
                 if (payload.size() < 8)
+                {
+                    spdlog::debug("IPC image payload too small: {}", payload.size());
                     continue;
+                }
 
                 int w = 0, h = 0;
                 std::memcpy(&w, payload.data() + 0, 4);
                 std::memcpy(&h, payload.data() + 4, 4);
 
+                spdlog::debug("IPC received image: {}x{}", w, h);
+
                 if (w <= 0 || h <= 0)
                     continue;
 
                 const size_t expected = static_cast<size_t>(w) * h * 4;
                 if (payload.size() != expected + 8)
+                {
+                    spdlog::debug("IPC image size mismatch: got {}, expected {}", payload.size(), expected + 8);
                     continue;
+                }
 
                 // Strip the 8-byte header
                 payload.erase(payload.begin(), payload.begin() + 8);

src/screenshot_tool.cpp

@@ -1609,12 +1609,12 @@ static void draw_preference_edit_config(const std::function<void()>& refresh_mod
     if (ImGui::TreeNode("Format help"))
     {
         auto row = [](const char* spec, const char* desc) {
-                ImGui::TableNextRow();
-                ImGui::TableSetColumnIndex(0);
-                ImGui::TextDisabled("%s", spec);
-                ImGui::TableSetColumnIndex(1);
-                ImGui::Text("%s", desc);
-            };
+            ImGui::TableNextRow();
+            ImGui::TableSetColumnIndex(0);
+            ImGui::TextDisabled("%s", spec);
+            ImGui::TableSetColumnIndex(1);
+            ImGui::Text("%s", desc);
+        };
 
         ImGui::Spacing();
         ImGui::TextDisabled("Specifiers:");

src/util.cpp

@@ -391,15 +391,15 @@ bool parse_hex_rgba(const std::string_view hex, rgba_t& out)
     // from the substring
     const std::string s(hex.substr(1));
 
-    char*          end  = nullptr;
-    unsigned long  parsed = std::strtoul(s.c_str(), &end, 16);
+    char*         end    = nullptr;
+    unsigned long parsed = std::strtoul(s.c_str(), &end, 16);
 
     // Ensure the entire string was consumed and no overflow occurred.
     if (end != s.c_str() + s.size() || parsed > 0xFFFFFFFFul)
         return false;
 
     const auto value = static_cast<uint32_t>(parsed);
-    rgba_t v(hex.size() == 7 ? (value << 8) | 0xFF : value);
+    rgba_t     v(hex.size() == 7 ? (value << 8) | 0xFF : value);
 
     out = v;
     return true;