Rename some things, stub of async version, download rapidjson in cmake file

src/CMakeLists.txt

@@ -5,5 +5,6 @@ add_library(discord-rpc-simple STATIC ${PROJECT_SOURCE_DIR}/include/discord-rpc.
 set(BASE_RPC_SRC ${PROJECT_SOURCE_DIR}/include/discord-rpc.h discord-rpc.cpp yolojson.h connection.h)
 
 if(WIN32)
-    add_library(discord-rpc STATIC ${BASE_RPC_SRC} connection_win_sync.cpp)
+    add_library(discord-rpc-sync STATIC ${BASE_RPC_SRC} connection_win_sync.cpp)
+    add_library(discord-rpc STATIC ${BASE_RPC_SRC} connection_win.cpp)
 endif(WIN32)

src/connection.h

@@ -18,7 +18,7 @@ struct RpcMessageFrame {
 
 struct RpcConnection {
     void (*onConnect)() = nullptr;
-    void (*onDisconnect)() = nullptr;
+    void (*onDisconnect)(int errorcode, const char* message) = nullptr;
     char appId[64];
 
     static RpcConnection* Create(const char* applicationId);
@@ -26,6 +26,7 @@ struct RpcConnection {
     void Open();
     void Close();
     void Write(const void* data, size_t length);
+    RpcMessageFrame* Read();
     
     RpcMessageFrame* GetNextFrame();
     void WriteFrame(RpcMessageFrame* frame);

src/connection_win.cpp

@@ -0,0 +1,133 @@
+#include "connection.h"
+
+#include <stdio.h>
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMCX
+#define NOSERVICE
+#define NOIME
+#include <windows.h>
+
+#include "yolojson.h"
+
+const int RpcVersion = 1;
+const int NumFrames = 3;
+static int LastErrorCode = 0;
+static const char* LastErrorMessage = "";
+
+struct WinRpcConnection : public RpcConnection {
+    HANDLE pipe{INVALID_HANDLE_VALUE};
+    RpcMessageFrame frames[NumFrames];
+    int nextFrame{0};
+    int lastErrorCode{0};
+    char lastErrorMessage[1024];
+
+    void HandleError(RpcMessageFrame* frame) {
+        if (frame->opcode == OPCODE::CLOSE) {
+            lastErrorCode = 1; // todo
+            StringCopy(lastErrorMessage, frame->message, sizeof(lastErrorMessage));
+            printf("got a close message: %d: %s\n", lastErrorCode, lastErrorMessage);
+        }
+    }
+};
+
+static const wchar_t* PipeName = L"\\\\?\\pipe\\discord-ipc";
+
+/*static*/ RpcConnection* RpcConnection::Create(const char* applicationId)
+{
+    auto connection = new WinRpcConnection;
+    StringCopy(connection->appId, applicationId, sizeof(connection->appId));
+    return connection;
+}
+
+/*static*/ void RpcConnection::Destroy(RpcConnection*& c)
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(c);
+    delete self;
+    c = nullptr;
+}
+
+void RpcConnection::Open()
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    for (;;) {
+        self->pipe = ::CreateFileW(PipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
+        if (self->pipe != INVALID_HANDLE_VALUE) {
+            break;
+        }
+
+        if (GetLastError() != ERROR_PIPE_BUSY) {
+            printf("Could not open pipe. Error: %d\n", GetLastError());
+            return;
+        }
+
+        if (!WaitNamedPipeW(PipeName, 10000)) {
+            printf("Could not open pipe: 10 second wait timed out.\n");
+            return;
+        }
+    }
+
+    RpcMessageFrame* frame = GetNextFrame();
+    frame->opcode = OPCODE::HANDSHAKE;
+    char* msg = frame->message;
+    JsonWriteHandshakeObj(msg, RpcVersion, appId);
+    frame->length = msg - frame->message;
+    WriteFrame(frame);
+
+    if (self->onConnect) {
+        self->onConnect();
+    }
+}
+
+void RpcConnection::Close()
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    ::CloseHandle(self->pipe);
+    self->pipe = INVALID_HANDLE_VALUE;
+    if (self->onDisconnect) {
+        self->onDisconnect(LastErrorCode, LastErrorMessage);
+        LastErrorCode = 0;
+        LastErrorMessage = "";
+    }
+}
+
+void RpcConnection::Write(const void* data, size_t length)
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    const int retries = 3;
+    for (int i = 0; i < retries; ++i) {
+        if (self->pipe == INVALID_HANDLE_VALUE) {
+            self->Open();
+            if (self->pipe == INVALID_HANDLE_VALUE) {
+                break;
+            }
+        }
+        BOOL success = ::WriteFile(self->pipe, data, length, nullptr, nullptr);
+        if (success) {
+            break;
+        }
+        LastErrorCode = -1;
+        LastErrorMessage = "Pipe closed";
+        self->Close();
+    }
+}
+
+RpcMessageFrame* RpcConnection::Read()
+{
+    // todo
+    return nullptr;
+}
+
+RpcMessageFrame* RpcConnection::GetNextFrame()
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    auto result = &(self->frames[self->nextFrame]);
+    self->nextFrame = (self->nextFrame + 1) % NumFrames;
+    return result;
+}
+
+void RpcConnection::WriteFrame(RpcMessageFrame* frame)
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    self->Write(frame, 8 + frame->length);
+}

src/connection_win_sync.cpp

@@ -11,12 +11,23 @@
 #include "yolojson.h"
 
 const int RpcVersion = 1;
-const int NumFrames = 3;
+const int NumFrames = 4;
 
 struct WinRpcConnection : public RpcConnection {
     HANDLE pipe{INVALID_HANDLE_VALUE};
+    RpcMessageFrame readFrame;
     RpcMessageFrame frames[NumFrames];
     int nextFrame{0};
+    int lastErrorCode{0};
+    char lastErrorMessage[1024];
+
+    void HandleError(RpcMessageFrame* frame) {
+        if (frame->opcode == OPCODE::CLOSE) {
+            lastErrorCode = 1; // todo
+            StringCopy(lastErrorMessage, frame->message, sizeof(lastErrorMessage));
+            printf("got a close message: %d: %s\n", lastErrorCode, lastErrorMessage);
+        }
+    }
 };
 
 static const wchar_t* PipeName = L"\\\\?\\pipe\\discord-ipc";
@@ -73,7 +84,9 @@ void RpcConnection::Close()
     ::CloseHandle(self->pipe);
     self->pipe = INVALID_HANDLE_VALUE;
     if (self->onDisconnect) {
-        self->onDisconnect();
+        self->onDisconnect(self->lastErrorCode, self->lastErrorMessage);
+        self->lastErrorCode = 0;
+        self->lastErrorMessage[0] = 0;
     }
 }
 
@@ -92,10 +105,37 @@ void RpcConnection::Write(const void* data, size_t length)
         if (success) {
             break;
         }
+
+        RpcMessageFrame* frame = self->Read();
+        if (frame) {
+            self->HandleError(frame);
+        }
+
         self->Close();
     }
 }
 
+RpcMessageFrame* RpcConnection::Read()
+{
+    auto self = reinterpret_cast<WinRpcConnection*>(this);
+    DWORD bytesAvailable = 0;
+    if (::PeekNamedPipe(self->pipe, nullptr, 0, nullptr, &bytesAvailable, nullptr) && bytesAvailable > 8) {
+        if (::ReadFile(self->pipe, &self->readFrame, 8, nullptr, nullptr) != TRUE) {
+            return nullptr;
+        }
+
+        if (self->readFrame.length > 0) {
+            if (::ReadFile(self->pipe, &self->readFrame.message, self->readFrame.length, nullptr, nullptr) != TRUE) {
+                return nullptr;
+            }
+            self->readFrame.message[self->readFrame.length] = 0;
+        }
+
+        return &self->readFrame;
+    }
+    return nullptr;
+}
+
 RpcMessageFrame* RpcConnection::GetNextFrame()
 {
     auto self = reinterpret_cast<WinRpcConnection*>(this);

src/discord-rpc-simple.cpp

@@ -275,7 +275,7 @@ void ConnectionClose()
     CloseHandle(PipeHandle);
     PipeHandle = INVALID_HANDLE_VALUE;
     if (Handlers.disconnected) {
-        Handlers.disconnected();
+        Handlers.disconnected(0, "");
     }
 }
 

src/discord-rpc.cpp

@@ -3,11 +3,15 @@
 #include "connection.h"
 #include "yolojson.h"
 
+#include <stdio.h>
+
 static RpcConnection* MyConnection = nullptr;
 static char ApplicationId[64]{};
 static DiscordEventHandlers Handlers{};
-static bool wasJustConnected = false;
-static bool wasJustDisconnected = false;
+static bool WasJustConnected = false;
+static bool WasJustDisconnected = false;
+static int LastErrorCode = 0;
+static const char* LastErrorMessage = "";
 
 extern "C" void Discord_Initialize(const char* applicationId, DiscordEventHandlers* handlers)
 {
@@ -19,8 +23,12 @@ extern "C" void Discord_Initialize(const char* applicationId, DiscordEventHandle
     }
 
     MyConnection = RpcConnection::Create(applicationId);
-    MyConnection->onConnect = []() { wasJustConnected = true; };
-    MyConnection->onDisconnect = []() { wasJustDisconnected = true; };
+    MyConnection->onConnect = []() { WasJustConnected = true; };
+    MyConnection->onDisconnect = [](int errorCode, const char* message) {
+        LastErrorCode = errorCode;
+        LastErrorMessage = message;
+        WasJustDisconnected = true;
+    };
     MyConnection->Open();
 }
 
@@ -43,17 +51,18 @@ extern "C" void Discord_UpdatePresence(const DiscordRichPresence* presence)
 
 extern "C" void Discord_Update()
 {
-    // check for messages
-    // todo
-
-    // fire callbacks
-    if (wasJustDisconnected && Handlers.disconnected) {
-        wasJustDisconnected = false;
-        Handlers.disconnected();
+    while (auto frame = MyConnection->Read()) {
+        printf("got a message %d, %d, %s\n", frame->opcode, frame->length, frame->message);
     }
 
-    if (wasJustConnected && Handlers.ready) {
-        wasJustConnected = false;
+    // fire callbacks
+    if (WasJustDisconnected && Handlers.disconnected) {
+        WasJustDisconnected = false;
+        Handlers.disconnected(LastErrorCode, LastErrorMessage);
+    }
+
+    if (WasJustConnected && Handlers.ready) {
+        WasJustConnected = false;
         Handlers.ready();
     }
 }