IPC is now a socket

README.md

@@ -32,7 +32,6 @@ Nevertheless, REPORT any you find! Make an issue!
  - Fix electron rendering issues
  - Fix sloppy dragging of windows
  - Optimization
- - IPC done correctly with a socket
  - Fix weird scroll on XWayland
  - Become sane
  - STABILITY

hyprctl/main.cpp

@@ -1,11 +1,17 @@
 #include <ctype.h>
+#include <netdb.h>
+#include <netinet/in.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
 
-#include <fstream>
 #include <iostream>
-#include <string.h>
+#include <string>
+#include <fstream>
 #include <string>
 
 const std::string USAGE = R"#(
@@ -16,64 +22,76 @@ usage: hyprctl [command] [(opt)args]
     clients
 )#";
 
-void readReply() {
-    std::ifstream ifs;
+void request(std::string arg) {
+    const auto SERVERSOCKET = socket(AF_INET, SOCK_STREAM, 0);
 
-    while (1) {
-        usleep(1000 * 25);
-
-        ifs.open("/tmp/hypr/.hyprlandrq");
-
-        if (ifs.good()) {
-            std::string reply = "";
-            std::getline(ifs, reply);
-
-            if (reply.find("RPLY:") != std::string::npos) {
-                reply = "";
-                std::string temp = "";
-                while (std::getline(ifs, temp))
-                    reply += temp + '\n';
-
-                std::cout << reply;
-
-                unlink("/tmp/hypr/.hyprlandrq"); // cleanup
-                break;
+    if (SERVERSOCKET < 0) {
+        std::cout << "Couldn't open a socket (1)";
+        return;
     }
+
+    const auto SERVER = gethostbyname("localhost");
+
+    if (!SERVER) {
+        std::cout << "Couldn't get host (2)";
+        return;
     }
+
+    sockaddr_in serverAddress = {0};
+    serverAddress.sin_family = AF_INET;
+    bcopy((char*)SERVER->h_addr, (char*)&serverAddress.sin_addr.s_addr, SERVER->h_length);
+
+    std::ifstream socketPortStream;
+    socketPortStream.open("/tmp/hypr/.socket");
+    
+    if (!socketPortStream.good()) {
+        std::cout << "No socket port file (2a)";
+        return;
     }
-}
 
-void requestMonitors() {
-    std::ofstream ofs;
-    ofs.open("/tmp/hypr/.hyprlandrq", std::ios::trunc);
+    std::string port = "";
+    std::getline(socketPortStream, port);
+    socketPortStream.close();
 
-    ofs << "R>monitors";
+    int portInt = 0;
+    try {
+        portInt = std::stoi(port.c_str());
+    } catch (...) {
+        std::cout << "Port not an int?! (2b)";
+        return;
+    }
 
-    ofs.close();
+    if (portInt == 0) {
+        std::cout << "Port not an int?! (2c)";
+        return;
+    }
     
-    readReply();
-}
+    serverAddress.sin_port = portInt;
 
-void requestClients() {
-    std::ofstream ofs;
-    ofs.open("/tmp/hypr/.hyprlandrq", std::ios::trunc);
+    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, sizeof(serverAddress)) < 0) {
+        std::cout << "Couldn't connect to port " << port << " (3) Is Hyprland running?";
+        return;
+    }
 
-    ofs << "R>clients";
+    auto sizeWritten = write(SERVERSOCKET, arg.c_str(), arg.length());
 
-    ofs.close();
+    if (sizeWritten < 0) {
+        std::cout << "Couldn't write (4)";
+        return;
+    }
 
-    readReply();
-}
+    char buffer[8192] = {0};
 
-void requestWorkspaces() {
-    std::ofstream ofs;
-    ofs.open("/tmp/hypr/.hyprlandrq", std::ios::trunc);
+    sizeWritten = read(SERVERSOCKET,buffer, 8192);
 
-    ofs << "R>workspaces";
+    if (sizeWritten < 0) {
+        std::cout << "Couldn't read (5)";
+        return;
+    }
 
-    ofs.close();
+    close(SERVERSOCKET);
 
-    readReply();
+    std::cout << std::string(buffer);
 }
 
 int main(int argc, char** argv) {
@@ -84,9 +102,9 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    if (!strcmp(argv[1], "monitors")) requestMonitors();
-    else if (!strcmp(argv[1], "clients")) requestClients();
-    else if (!strcmp(argv[1], "workspaces")) requestWorkspaces();
+    if (!strcmp(argv[1], "monitors")) request("R>monitors");
+    else if (!strcmp(argv[1], "clients")) request("R>clients");
+    else if (!strcmp(argv[1], "workspaces")) request("R>workspaces");
     else {
         printf(USAGE.c_str());
         return 1;

src/debug/HyprCtl.cpp

@@ -1,6 +1,12 @@
 #include "HyprCtl.hpp"
 
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
@@ -46,31 +52,58 @@ std::string workspacesRequest() {
     return result;
 }
 
-void HyprCtl::tickHyprCtl() {
-    struct stat buf;
+void HyprCtl::startHyprCtlSocket() {
+    int port = 9187;
 
-    if (stat("/tmp/hypr/.hyprlandrq", &buf) == 0) {
-        // file exists, let's open it
+    std::thread([&]() {
+        const auto SOCKET = socket(AF_INET, SOCK_STREAM, 0);
 
-        requestStream.open("/tmp/hypr/.hyprlandrq");
+        if (SOCKET < 0) {
+            Debug::log(ERR, "Couldn't start the Hyprland Socket. (1) IPC will not work.");
+            return;
+        }
 
-        std::string request = "";
-        std::getline(requestStream, request);
+        const sockaddr_in SERVERADDRESS = {.sin_family = AF_INET, .sin_port = port, .sin_addr = (in_addr)INADDR_ANY};
 
-        requestStream.close();
+        if (bind(SOCKET, (sockaddr*)&SERVERADDRESS, sizeof(SERVERADDRESS)) < 0) {
+            Debug::log(ERR, "Couldn't start the Hyprland Socket. (2) IPC will not work.");
+            return;
+        }
+
+        // 10 max queued.
+        listen(SOCKET, 10);
+
+        sockaddr_in clientAddress;
+        socklen_t clientSize = sizeof(clientAddress);
+
+        char readBuffer[1024] = {0};
+
+        Debug::log(LOG, "Hypr socket started on port %i", SERVERADDRESS.sin_port);
+
+        std::string cmd = "rm -f /tmp/hypr/.socket && echo \"" + std::to_string(SERVERADDRESS.sin_port) + "\" > /tmp/hypr/.socket";
+        system(cmd.c_str()); // forgive me for using system() but it works and it doesnt matter here that much
+
+        while(1) {
+            const auto ACCEPTEDCONNECTION = accept(SOCKET, (sockaddr*)&clientAddress, &clientSize);
+
+            if (ACCEPTEDCONNECTION < 0) {
+                Debug::log(ERR, "Couldn't listen on the Hyprland Socket. (3) IPC will not work.");
+                break;
+            }
+
+            auto messageSize = read(ACCEPTEDCONNECTION, readBuffer, 1024);
+            readBuffer[messageSize == 1024 ? 1024 : messageSize] = '\0';
+
+            std::string request(readBuffer);
 
             std::string reply = "";
             if (request == "R>monitors") reply = monitorsRequest();
             if (request == "R>workspaces") reply = workspacesRequest();
             if (request == "R>clients") reply = clientsRequest();
 
-        if (reply != "") {
-            std::ofstream ofs;
-            ofs.open("/tmp/hypr/.hyprlandrq", std::ios::trunc);
-            ofs << "RPLY:\n" << reply;
-            ofs.close();
-        }
+            write(ACCEPTEDCONNECTION, reply.c_str(), reply.length());
 
-        // the hyprctl app deletes the file when done.
+            close(ACCEPTEDCONNECTION);
         }
+    }).detach();
 }

src/debug/HyprCtl.hpp

@@ -4,6 +4,7 @@
 #include <fstream>
 
 namespace HyprCtl {
+    void            startHyprCtlSocket();
     void            tickHyprCtl();
 
     inline std::ifstream requestStream;

src/managers/ThreadManager.cpp

@@ -20,6 +20,8 @@ void CThreadManager::handle() {
 
     g_pConfigManager->init();
 
+    HyprCtl::startHyprCtlSocket();
+
     while (3.1415f) {
         slowUpdate++;
         if (slowUpdate >= g_pConfigManager->getInt("general:max_fps")){
@@ -27,8 +29,6 @@ void CThreadManager::handle() {
             slowUpdate = 0;
         }
 
-        HyprCtl::tickHyprCtl();
-
         std::this_thread::sleep_for(std::chrono::microseconds(1000000 / g_pConfigManager->getInt("general:max_fps")));
     }
 }