diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7a09f17 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +# Compiled module +Release + +# Visual Studio folder +.vs \ No newline at end of file diff --git a/GDAModule.cpp b/GDAModule.cpp new file mode 100644 index 0000000..2f0e1a0 --- /dev/null +++ b/GDAModule.cpp @@ -0,0 +1,121 @@ +#include "GDAModule.h" +#include "ws.hpp" +#include "Settings.h" +#include "imgui.h" +#include "imguiex.h" +#include "Util.h" + +using easywsclient::WebSocket; +using namespace std; + +static char message[2048]; +static int online = 0; +static vector messages; +static bool _connection = false; +static WebSocket* ws = nullptr; + +void pingServer() { + if (ws && ws->getReadyState() == WebSocket::OPEN) { + ws->sendPing(); + } +} + +CALLBACK_F(void, handle_message, const string& msg) { + string str = msg.c_str(); + if (str.find("online::") == 0) { + str.erase(0, 8); + online = std::stoi(str); + return; + } + else if (str == "clearClient") { + messages.clear(); + return; + } + messages.push_back(msg); +} + +void connectToChat() { + if (_connection) { + if (!ws || ws->getReadyState() != WebSocket::OPEN) { + messages.push_back("[GDChat] Connecting.."); + ws = WebSocket::from_url(moduleSettings._chatUrl); + } + else if (ws->getReadyState() != WebSocket::CLOSED) { + ws->poll(); + ws->dispatch(handle_message); + } + } +} + +CALLBACK_F(void, update_ws) { + Util::timer_start(pingServer, 20000); + _connection = true; + connectToChat(); + Util::timer_start(connectToChat, 5000); +} + +CALLBACK_F(void, OnModuleDraw, GDA_MODULE* pModule) { + if (moduleSettings._show) { + if (!moduleSettings._settingsLoaded) { + moduleSettings._settingsLoaded = true; + ImGui::SetNextWindowCollapsed(moduleSettings._collapsed, ImGuiCond_Once); + ImGui::SetNextWindowPos(ImVec2(moduleSettings._pos.x, moduleSettings._pos.y), ImGuiCond_Once); + ImGui::SetNextWindowSize(ImVec2(moduleSettings._size.x, moduleSettings._size.y), ImGuiCond_Once); + } + ImGui::SetNextWindowSizeConstraints(ImVec2(400, 300), ImVec2(400, 600)); + + if (ImGuiEx::BeginWithAStyle(moduleSettings._collapsed, pModule->getName(), &moduleSettings._show)) { + ImGui::SetNextWindowContentWidth(moduleSettings._size.x / 0.9); + ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 5.0f); + if (ImGui::BeginChild("chat", ImVec2(0, moduleSettings._size.y - 60), true, ImGuiWindowFlags_None)) { + if (messages.size() == 0) + ImGui::TextDisabled("Chat is empty"); + else for (int i = 0; i < messages.size(); ++i) { + ImGuiEx::TextMulticolor(messages[i].c_str()); + if (i != messages.size()) ImGui::Separator(); + } + } + ImGui::EndChild(); + ImGui::InputText("##inputchat", message, 2048); + ImGui::SameLine(); + if (ImGui::Button(" > ") || ImGuiEx::IsKeysReleased(VK_RETURN)) { + if (ws != nullptr && ws->getReadyState() == WebSocket::OPEN) { + if (strlen(message) > 0) { + ws->send(message); + memset(message, 0, 2048); + } + } + } + ImGui::SameLine(); + if (ws != nullptr && ws->getReadyState() == WebSocket::OPEN) + ImGuiEx::TextMulticolor("{32a852}Online: %d{}", online); + else + ImGuiEx::TextMulticolor("{cc0000}Offline{}"); + } + + moduleSettings._collapsed = ImGui::IsWindowCollapsed(); + auto& pos = ImGui::GetWindowPos(); + moduleSettings._pos.x = pos.x; + moduleSettings._pos.y = pos.y; + auto& size = ImGui::GetWindowSize(); + moduleSettings._size.x = size.x; + moduleSettings._size.y = size.y; + + ImGui::End(); + } +} + +GDA_MODULE_CALLBACK(GDA_MODULE* pModule) { + memset(message, 0, 2048); + thread(&update_ws).detach(); + + pModule->setName("GDChat"); + pModule->setAuthor("bit0r1n"); + pModule->registerClickCallback(CALLBACK_L(void, GDA_MODULE * pModule) { + if (moduleSettings._show ^= true) + ImGui::SetNextWindowFocus(); + }); + pModule->registerDrawCallback(OnModuleDraw); + pModule->setClickName(" open "); + return true; +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..55768ae --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +# GD Chat +Module for [GD Addon](https://github.com/Keenlos/GDAddonSDK) that creates real-time chat + +Used: + * [GD Addon SDK](https://github.com/Keenlos/GDAddonSDK) + * [easywsclient](https://github.com/dhbaird/easywsclient) \ No newline at end of file diff --git a/Settings.cpp b/Settings.cpp new file mode 100644 index 0000000..af2e6b6 --- /dev/null +++ b/Settings.cpp @@ -0,0 +1,49 @@ +#include "Settings.h" + +#include "cocos2d_x/DS_Dictionary.h" + +ModuleSettings moduleSettings; + +ModuleSettings::ModuleSettings() { + _settingsLoaded = false; + + _show = _collapsed = false; + + _pos = cocos2d::CCPoint(0, 0); + + _size = cocos2d::CCPoint(0, 0); + + _chatUrl = "WebSocket link"; + + this->load(); +} + +ModuleSettings::~ModuleSettings() { + this->save(); +} + +void ModuleSettings::fixSettings() { } + +void ModuleSettings::save() { + DS_Dictionary _dict; + this->fixSettings(); + _dict.setBoolForKey("show", _show); + _dict.setBoolForKey("collapsed", _collapsed); + _dict.setVec2ForKey("pos", _pos); + _dict.setVec2ForKey("size", _size); + _dict.setStringForKey("chatUrl", _chatUrl); + + _dict.saveRootSubDictToCompressedFile("GDChat.dat"); +} + +void ModuleSettings::load() { + DS_Dictionary _dict; + _dict.loadRootSubDictFromCompressedFile("GDChat.dat"); + + _show = _dict.getBoolForKey("show"); + _collapsed = _dict.getBoolForKey("collapsed"); + _pos = _dict.getVec2ForKey("pos"); + _size = _dict.getVec2ForKey("size"); + _chatUrl = _dict.getStringForKey("chatUrl"); + this->fixSettings(); +} \ No newline at end of file diff --git a/Settings.h b/Settings.h new file mode 100644 index 0000000..19a89a1 --- /dev/null +++ b/Settings.h @@ -0,0 +1,23 @@ +#pragma once + +#include "cocos2d_x/CCGeometry.h" +#include + +using namespace std; + +struct ModuleSettings +{ + bool _settingsLoaded; + string _chatUrl; + bool _show, _collapsed; + cocos2d::CCPoint _pos, _size; + ModuleSettings(); + ~ModuleSettings(); + +private: + void fixSettings(); + void save(); + void load(); +}; + +extern ModuleSettings moduleSettings; \ No newline at end of file diff --git a/Util.h b/Util.h new file mode 100644 index 0000000..5326048 --- /dev/null +++ b/Util.h @@ -0,0 +1,18 @@ +#pragma once +#include +#include +class Util +{ +public: + static void timer_start(std::function func, unsigned int interval) + { + std::thread([func, interval]() { + while (true) + { + func(); + std::this_thread::sleep_for(std::chrono::milliseconds(interval)); + } + }).detach(); + } +}; + diff --git a/chat.sln b/chat.sln new file mode 100644 index 0000000..f496a50 --- /dev/null +++ b/chat.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.27703.2042 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chat", "chat.vcxproj", "{D8BFE6C7-D233-4E9A-8DB3-459116F0CB3F}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D8BFE6C7-D233-4E9A-8DB3-459116F0CB3F}.Release|x86.ActiveCfg = Release|Win32 + {D8BFE6C7-D233-4E9A-8DB3-459116F0CB3F}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {C3852A03-D542-4A49-A572-5F950A048DBD} + EndGlobalSection +EndGlobal diff --git a/chat.vcxproj b/chat.vcxproj new file mode 100644 index 0000000..038ee9b --- /dev/null +++ b/chat.vcxproj @@ -0,0 +1,73 @@ + + + + + Release + Win32 + + + + + + + + + + + + + + 15.0 + {D8BFE6C7-D233-4E9A-8DB3-459116F0CB3F} + Win32Proj + chat + 10.0.17763.0 + + + + DynamicLibrary + false + v142 + false + MultiByte + + + + + + + + + + + + + + NotUsing + Level1 + WIN32;_WINDOWS;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN=1;NDEBUG;VC_EXTRALEAN;%(PreprocessorDefinitions) + false + $(ProjectDir)..\..\SDK_CPP\;$(ProjectDir)..\..\SDK_CPP\GDAPI;%(AdditionalIncludeDirectories) + true + true + Speed + true + false + false + false + stdcpp17 + + + Windows + true + true + true + GDAddon.lib;opengl32.lib;libcocos2d.lib;libExtensions.lib;%(AdditionalDependencies) + $(ProjectDir)..\..\SDK_CPP\lib\win32;$(ProjectDir)..\..\SDK_CPP\GDAPI\lib\win32;%(AdditionalLibraryDirectories) + $(ProjectDir)..\..\..\..\Addon\Modules\$(TargetName)$(TargetExt) + + + + + + \ No newline at end of file diff --git a/chat.vcxproj.filters b/chat.vcxproj.filters new file mode 100644 index 0000000..e1cdc09 --- /dev/null +++ b/chat.vcxproj.filters @@ -0,0 +1,39 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/chat.vcxproj.user b/chat.vcxproj.user new file mode 100644 index 0000000..c3a946f --- /dev/null +++ b/chat.vcxproj.user @@ -0,0 +1,9 @@ + + + + $(ProjectDir)..\..\..\..\GeometryDash.exe + $(ProjectDir)..\..\..\..\ + WindowsLocalDebugger + + + \ No newline at end of file diff --git a/ws.cpp b/ws.cpp new file mode 100644 index 0000000..c8b4fb8 --- /dev/null +++ b/ws.cpp @@ -0,0 +1,554 @@ + +#ifdef _WIN32 +#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS // _CRT_SECURE_NO_WARNINGS for sscanf errors in MSVC2013 Express +#endif +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#include +#include +#include +#pragma comment( lib, "ws2_32" ) +#include +#include +#include +#include +#include +#ifndef _SSIZE_T_DEFINED +typedef int ssize_t; +#define _SSIZE_T_DEFINED +#endif +#ifndef _SOCKET_T_DEFINED +typedef SOCKET socket_t; +#define _SOCKET_T_DEFINED +#endif +#ifndef snprintf +#define snprintf _snprintf_s +#endif +#if _MSC_VER >=1600 +// vs2010 or later +#include +#else +typedef __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +#endif +#define socketerrno WSAGetLastError() +#define SOCKET_EAGAIN_EINPROGRESS WSAEINPROGRESS +#define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK +#else +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef _SOCKET_T_DEFINED +typedef int socket_t; +#define _SOCKET_T_DEFINED +#endif +#ifndef INVALID_SOCKET +#define INVALID_SOCKET (-1) +#endif +#ifndef SOCKET_ERROR +#define SOCKET_ERROR (-1) +#endif +#define closesocket(s) ::close(s) +#include +#define socketerrno errno +#define SOCKET_EAGAIN_EINPROGRESS EAGAIN +#define SOCKET_EWOULDBLOCK EWOULDBLOCK +#endif + +#include +#include + +#include "ws.hpp" + +using easywsclient::Callback_Imp; +using easywsclient::BytesCallback_Imp; + +namespace { // private module-only namespace + + socket_t hostname_connect(const std::string& hostname, int port) { + struct addrinfo hints; + struct addrinfo* result; + struct addrinfo* p; + int ret; + socket_t sockfd = INVALID_SOCKET; + char sport[16]; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + snprintf(sport, 16, "%d", port); + if ((ret = getaddrinfo(hostname.c_str(), sport, &hints, &result)) != 0) + { + fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret)); + return 1; + } + for (p = result; p != NULL; p = p->ai_next) + { + sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol); + if (sockfd == INVALID_SOCKET) { continue; } + if (connect(sockfd, p->ai_addr, p->ai_addrlen) != SOCKET_ERROR) { + break; + } + closesocket(sockfd); + sockfd = INVALID_SOCKET; + } + freeaddrinfo(result); + return sockfd; + } + + + class _DummyWebSocket : public easywsclient::WebSocket + { + public: + void poll(int timeout) { } + void send(const std::string& message) { } + void sendBinary(const std::string& message) { } + void sendBinary(const std::vector& message) { } + void sendPing() { } + void close() { } + readyStateValues getReadyState() const { return CLOSED; } + void _dispatch(Callback_Imp& callable) { } + void _dispatchBinary(BytesCallback_Imp& callable) { } + }; + + + class _RealWebSocket : public easywsclient::WebSocket + { + public: + // http://tools.ietf.org/html/rfc6455#section-5.2 Base Framing Protocol + // + // 0 1 2 3 + // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + // +-+-+-+-+-------+-+-------------+-------------------------------+ + // |F|R|R|R| opcode|M| Payload len | Extended payload length | + // |I|S|S|S| (4) |A| (7) | (16/64) | + // |N|V|V|V| |S| | (if payload len==126/127) | + // | |1|2|3| |K| | | + // +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - + + // | Extended payload length continued, if payload len == 127 | + // + - - - - - - - - - - - - - - - +-------------------------------+ + // | |Masking-key, if MASK set to 1 | + // +-------------------------------+-------------------------------+ + // | Masking-key (continued) | Payload Data | + // +-------------------------------- - - - - - - - - - - - - - - - + + // : Payload Data continued ... : + // + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + // | Payload Data continued ... | + // +---------------------------------------------------------------+ + struct wsheader_type { + unsigned header_size; + bool fin; + bool mask; + enum opcode_type { + CONTINUATION = 0x0, + TEXT_FRAME = 0x1, + BINARY_FRAME = 0x2, + CLOSE = 8, + PING = 9, + PONG = 0xa, + } opcode; + int N0; + uint64_t N; + uint8_t masking_key[4]; + }; + + std::vector rxbuf; + std::vector txbuf; + std::vector receivedData; + + socket_t sockfd; + readyStateValues readyState; + bool useMask; + bool isRxBad; + + _RealWebSocket(socket_t sockfd, bool useMask) + : sockfd(sockfd) + , readyState(OPEN) + , useMask(useMask) + , isRxBad(false) { + } + + readyStateValues getReadyState() const { + return readyState; + } + + void poll(int timeout) { // timeout in milliseconds + if (readyState == CLOSED) { + if (timeout > 0) { + timeval tv = { timeout / 1000, (timeout % 1000) * 1000 }; + select(0, NULL, NULL, NULL, &tv); + } + return; + } + if (timeout != 0) { + fd_set rfds; + fd_set wfds; + timeval tv = { timeout / 1000, (timeout % 1000) * 1000 }; + FD_ZERO(&rfds); + FD_ZERO(&wfds); + FD_SET(sockfd, &rfds); + if (txbuf.size()) { FD_SET(sockfd, &wfds); } + select(sockfd + 1, &rfds, &wfds, 0, timeout > 0 ? &tv : 0); + } + while (true) { + // FD_ISSET(0, &rfds) will be true + int N = rxbuf.size(); + ssize_t ret; + rxbuf.resize(N + 1500); + ret = recv(sockfd, (char*)&rxbuf[0] + N, 1500, 0); + if (false) {} + else if (ret < 0 && (socketerrno == SOCKET_EWOULDBLOCK || socketerrno == SOCKET_EAGAIN_EINPROGRESS)) { + rxbuf.resize(N); + break; + } + else if (ret <= 0) { + rxbuf.resize(N); + closesocket(sockfd); + readyState = CLOSED; + fputs(ret < 0 ? "Connection error!\n" : "Connection closed!\n", stderr); + break; + } + else { + rxbuf.resize(N + ret); + } + } + while (txbuf.size()) { + int ret = ::send(sockfd, (char*)&txbuf[0], txbuf.size(), 0); + if (false) {} // ?? + else if (ret < 0 && (socketerrno == SOCKET_EWOULDBLOCK || socketerrno == SOCKET_EAGAIN_EINPROGRESS)) { + break; + } + else if (ret <= 0) { + closesocket(sockfd); + readyState = CLOSED; + fputs(ret < 0 ? "Connection error!\n" : "Connection closed!\n", stderr); + break; + } + else { + txbuf.erase(txbuf.begin(), txbuf.begin() + ret); + } + } + if (!txbuf.size() && readyState == CLOSING) { + closesocket(sockfd); + readyState = CLOSED; + } + } + + // Callable must have signature: void(const std::string & message). + // Should work with C functions, C++ functors, and C++11 std::function and + // lambda: + //template + //void dispatch(Callable callable) + virtual void _dispatch(Callback_Imp& callable) { + struct CallbackAdapter : public BytesCallback_Imp + // Adapt void(const std::string&) to void(const std::string&) + { + Callback_Imp& callable; + CallbackAdapter(Callback_Imp& callable) : callable(callable) { } + void operator()(const std::vector& message) { + std::string stringMessage(message.begin(), message.end()); + callable(stringMessage); + } + }; + CallbackAdapter bytesCallback(callable); + _dispatchBinary(bytesCallback); + } + + virtual void _dispatchBinary(BytesCallback_Imp& callable) { + // TODO: consider acquiring a lock on rxbuf... + if (isRxBad) { + return; + } + while (true) { + wsheader_type ws; + if (rxbuf.size() < 2) { return; /* Need at least 2 */ } + const uint8_t* data = (uint8_t*)&rxbuf[0]; // peek, but don't consume + ws.fin = (data[0] & 0x80) == 0x80; + ws.opcode = (wsheader_type::opcode_type) (data[0] & 0x0f); + ws.mask = (data[1] & 0x80) == 0x80; + ws.N0 = (data[1] & 0x7f); + ws.header_size = 2 + (ws.N0 == 126 ? 2 : 0) + (ws.N0 == 127 ? 8 : 0) + (ws.mask ? 4 : 0); + if (rxbuf.size() < ws.header_size) { return; /* Need: ws.header_size - rxbuf.size() */ } + int i = 0; + if (ws.N0 < 126) { + ws.N = ws.N0; + i = 2; + } + else if (ws.N0 == 126) { + ws.N = 0; + ws.N |= ((uint64_t)data[2]) << 8; + ws.N |= ((uint64_t)data[3]) << 0; + i = 4; + } + else if (ws.N0 == 127) { + ws.N = 0; + ws.N |= ((uint64_t)data[2]) << 56; + ws.N |= ((uint64_t)data[3]) << 48; + ws.N |= ((uint64_t)data[4]) << 40; + ws.N |= ((uint64_t)data[5]) << 32; + ws.N |= ((uint64_t)data[6]) << 24; + ws.N |= ((uint64_t)data[7]) << 16; + ws.N |= ((uint64_t)data[8]) << 8; + ws.N |= ((uint64_t)data[9]) << 0; + i = 10; + if (ws.N & 0x8000000000000000ull) { + // https://tools.ietf.org/html/rfc6455 writes the "the most + // significant bit MUST be 0." + // + // We can't drop the frame, because (1) we don't we don't + // know how much data to skip over to find the next header, + // and (2) this would be an impractically long length, even + // if it were valid. So just close() and return immediately + // for now. + isRxBad = true; + fprintf(stderr, "ERROR: Frame has invalid frame length. Closing.\n"); + close(); + return; + } + } + if (ws.mask) { + ws.masking_key[0] = ((uint8_t)data[i + 0]) << 0; + ws.masking_key[1] = ((uint8_t)data[i + 1]) << 0; + ws.masking_key[2] = ((uint8_t)data[i + 2]) << 0; + ws.masking_key[3] = ((uint8_t)data[i + 3]) << 0; + } + else { + ws.masking_key[0] = 0; + ws.masking_key[1] = 0; + ws.masking_key[2] = 0; + ws.masking_key[3] = 0; + } + + // Note: The checks above should hopefully ensure this addition + // cannot overflow: + if (rxbuf.size() < ws.header_size + ws.N) { return; /* Need: ws.header_size+ws.N - rxbuf.size() */ } + + // We got a whole message, now do something with it: + if (false) {} + else if ( + ws.opcode == wsheader_type::TEXT_FRAME + || ws.opcode == wsheader_type::BINARY_FRAME + || ws.opcode == wsheader_type::CONTINUATION + ) { + if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i + ws.header_size] ^= ws.masking_key[i & 0x3]; } } + receivedData.insert(receivedData.end(), rxbuf.begin() + ws.header_size, rxbuf.begin() + ws.header_size + (size_t)ws.N);// just feed + if (ws.fin) { + callable((const std::vector) receivedData); + receivedData.erase(receivedData.begin(), receivedData.end()); + std::vector().swap(receivedData);// free memory + } + } + else if (ws.opcode == wsheader_type::PING) { + if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i + ws.header_size] ^= ws.masking_key[i & 0x3]; } } + std::string data(rxbuf.begin() + ws.header_size, rxbuf.begin() + ws.header_size + (size_t)ws.N); + sendData(wsheader_type::PONG, data.size(), data.begin(), data.end()); + } + else if (ws.opcode == wsheader_type::PONG) {} + else if (ws.opcode == wsheader_type::CLOSE) { close(); } + else { fprintf(stderr, "ERROR: Got unexpected WebSocket message.\n"); close(); } + + rxbuf.erase(rxbuf.begin(), rxbuf.begin() + ws.header_size + (size_t)ws.N); + } + } + + void sendPing() { + std::string empty; + sendData(wsheader_type::PING, empty.size(), empty.begin(), empty.end()); + } + + void send(const std::string& message) { + sendData(wsheader_type::TEXT_FRAME, message.size(), message.begin(), message.end()); + } + + void sendBinary(const std::string& message) { + sendData(wsheader_type::BINARY_FRAME, message.size(), message.begin(), message.end()); + } + + void sendBinary(const std::vector& message) { + sendData(wsheader_type::BINARY_FRAME, message.size(), message.begin(), message.end()); + } + + template + void sendData(wsheader_type::opcode_type type, uint64_t message_size, Iterator message_begin, Iterator message_end) { + // TODO: + // Masking key should (must) be derived from a high quality random + // number generator, to mitigate attacks on non-WebSocket friendly + // middleware: + const uint8_t masking_key[4] = { 0x12, 0x34, 0x56, 0x78 }; + // TODO: consider acquiring a lock on txbuf... + if (readyState == CLOSING || readyState == CLOSED) { return; } + std::vector header; + header.assign(2 + (message_size >= 126 ? 2 : 0) + (message_size >= 65536 ? 6 : 0) + (useMask ? 4 : 0), 0); + header[0] = 0x80 | type; + if (false) {} + else if (message_size < 126) { + header[1] = (message_size & 0xff) | (useMask ? 0x80 : 0); + if (useMask) { + header[2] = masking_key[0]; + header[3] = masking_key[1]; + header[4] = masking_key[2]; + header[5] = masking_key[3]; + } + } + else if (message_size < 65536) { + header[1] = 126 | (useMask ? 0x80 : 0); + header[2] = (message_size >> 8) & 0xff; + header[3] = (message_size >> 0) & 0xff; + if (useMask) { + header[4] = masking_key[0]; + header[5] = masking_key[1]; + header[6] = masking_key[2]; + header[7] = masking_key[3]; + } + } + else { // TODO: run coverage testing here + header[1] = 127 | (useMask ? 0x80 : 0); + header[2] = (message_size >> 56) & 0xff; + header[3] = (message_size >> 48) & 0xff; + header[4] = (message_size >> 40) & 0xff; + header[5] = (message_size >> 32) & 0xff; + header[6] = (message_size >> 24) & 0xff; + header[7] = (message_size >> 16) & 0xff; + header[8] = (message_size >> 8) & 0xff; + header[9] = (message_size >> 0) & 0xff; + if (useMask) { + header[10] = masking_key[0]; + header[11] = masking_key[1]; + header[12] = masking_key[2]; + header[13] = masking_key[3]; + } + } + // N.B. - txbuf will keep growing until it can be transmitted over the socket: + txbuf.insert(txbuf.end(), header.begin(), header.end()); + txbuf.insert(txbuf.end(), message_begin, message_end); + if (useMask) { + size_t message_offset = txbuf.size() - message_size; + for (size_t i = 0; i != message_size; ++i) { + txbuf[message_offset + i] ^= masking_key[i & 0x3]; + } + } + } + + void close() { + if (readyState == CLOSING || readyState == CLOSED) { return; } + readyState = CLOSING; + uint8_t closeFrame[6] = { 0x88, 0x80, 0x00, 0x00, 0x00, 0x00 }; // last 4 bytes are a masking key + std::vector header(closeFrame, closeFrame + 6); + txbuf.insert(txbuf.end(), header.begin(), header.end()); + } + + }; + + + easywsclient::WebSocket::pointer from_url(const std::string& url, bool useMask, const std::string& origin) { + char host[512]; + int port; + char path[512]; + if (url.size() >= 512) { + fprintf(stderr, "ERROR: url size limit exceeded: %s\n", url.c_str()); + return NULL; + } + if (origin.size() >= 200) { + fprintf(stderr, "ERROR: origin size limit exceeded: %s\n", origin.c_str()); + return NULL; + } + if (false) {} + else if (sscanf(url.c_str(), "ws://%[^:/]:%d/%s", host, &port, path) == 3) { + } + else if (sscanf(url.c_str(), "ws://%[^:/]/%s", host, path) == 2) { + port = 80; + } + else if (sscanf(url.c_str(), "ws://%[^:/]:%d", host, &port) == 2) { + path[0] = '\0'; + } + else if (sscanf(url.c_str(), "ws://%[^:/]", host) == 1) { + port = 80; + path[0] = '\0'; + } + else { + fprintf(stderr, "ERROR: Could not parse WebSocket url: %s\n", url.c_str()); + return NULL; + } + //fprintf(stderr, "easywsclient: connecting: host=%s port=%d path=/%s\n", host, port, path); + socket_t sockfd = hostname_connect(host, port); + if (sockfd == INVALID_SOCKET) { + fprintf(stderr, "Unable to connect to %s:%d\n", host, port); + return NULL; + } + { + // XXX: this should be done non-blocking, + char line[1024]; + int status; + int i; + snprintf(line, 1024, "GET /%s HTTP/1.1\r\n", path); ::send(sockfd, line, strlen(line), 0); + if (port == 80) { + snprintf(line, 1024, "Host: %s\r\n", host); ::send(sockfd, line, strlen(line), 0); + } + else { + snprintf(line, 1024, "Host: %s:%d\r\n", host, port); ::send(sockfd, line, strlen(line), 0); + } + snprintf(line, 1024, "Upgrade: websocket\r\n"); ::send(sockfd, line, strlen(line), 0); + snprintf(line, 1024, "Connection: Upgrade\r\n"); ::send(sockfd, line, strlen(line), 0); + if (!origin.empty()) { + snprintf(line, 1024, "Origin: %s\r\n", origin.c_str()); ::send(sockfd, line, strlen(line), 0); + } + snprintf(line, 1024, "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"); ::send(sockfd, line, strlen(line), 0); + snprintf(line, 1024, "Sec-WebSocket-Version: 13\r\n"); ::send(sockfd, line, strlen(line), 0); + snprintf(line, 1024, "\r\n"); ::send(sockfd, line, strlen(line), 0); + for (i = 0; i < 2 || (i < 1023 && line[i - 2] != '\r' && line[i - 1] != '\n'); ++i) { if (recv(sockfd, line + i, 1, 0) == 0) { return NULL; } } + line[i] = 0; + if (i == 1023) { fprintf(stderr, "ERROR: Got invalid status line connecting to: %s\n", url.c_str()); return NULL; } + if (sscanf(line, "HTTP/1.1 %d", &status) != 1 || status != 101) { fprintf(stderr, "ERROR: Got bad status connecting to %s: %s", url.c_str(), line); return NULL; } + // TODO: verify response headers, + while (true) { + for (i = 0; i < 2 || (i < 1023 && line[i - 2] != '\r' && line[i - 1] != '\n'); ++i) { if (recv(sockfd, line + i, 1, 0) == 0) { return NULL; } } + if (line[0] == '\r' && line[1] == '\n') { break; } + } + } + int flag = 1; + setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag)); // Disable Nagle's algorithm +#ifdef _WIN32 + u_long on = 1; + ioctlsocket(sockfd, FIONBIO, &on); +#else + fcntl(sockfd, F_SETFL, O_NONBLOCK); +#endif + //fprintf(stderr, "Connected to: %s\n", url.c_str()); + return easywsclient::WebSocket::pointer(new _RealWebSocket(sockfd, useMask)); + } + +} // end of module-only namespace + + + +namespace easywsclient { + + WebSocket::pointer WebSocket::create_dummy() { + static pointer dummy = pointer(new _DummyWebSocket); + return dummy; + } + + + WebSocket::pointer WebSocket::from_url(const std::string& url, const std::string& origin) { + return ::from_url(url, true, origin); + } + + WebSocket::pointer WebSocket::from_url_no_mask(const std::string& url, const std::string& origin) { + return ::from_url(url, false, origin); + } + + +} // namespace easywsclient diff --git a/ws.hpp b/ws.hpp new file mode 100644 index 0000000..16ba791 --- /dev/null +++ b/ws.hpp @@ -0,0 +1,72 @@ +#ifndef EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD +#define EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD + +// This code comes from: +// https://github.com/dhbaird/easywsclient +// +// To get the latest version: +// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.hpp +// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.cpp + +#include +#include + +namespace easywsclient { + + struct Callback_Imp { virtual void operator()(const std::string& message) = 0; }; + struct BytesCallback_Imp { virtual void operator()(const std::vector& message) = 0; }; + + class WebSocket { + public: + typedef WebSocket* pointer; + typedef enum readyStateValues { CLOSING, CLOSED, CONNECTING, OPEN } readyStateValues; + + // Factories: + static pointer create_dummy(); + static pointer from_url(const std::string& url, const std::string& origin = std::string()); + static pointer from_url_no_mask(const std::string& url, const std::string& origin = std::string()); + + // Interfaces: + virtual ~WebSocket() { } + virtual void poll(int timeout = 0) = 0; // timeout in milliseconds + virtual void send(const std::string& message) = 0; + virtual void sendBinary(const std::string& message) = 0; + virtual void sendBinary(const std::vector& message) = 0; + virtual void sendPing() = 0; + virtual void close() = 0; + virtual readyStateValues getReadyState() const = 0; + + template + void dispatch(Callable callable) + // For callbacks that accept a string argument. + { // N.B. this is compatible with both C++11 lambdas, functors and C function pointers + struct _Callback : public Callback_Imp { + Callable& callable; + _Callback(Callable& callable) : callable(callable) { } + void operator()(const std::string& message) { callable(message); } + }; + _Callback callback(callable); + _dispatch(callback); + } + + template + void dispatchBinary(Callable callable) + // For callbacks that accept a std::vector argument. + { // N.B. this is compatible with both C++11 lambdas, functors and C function pointers + struct _Callback : public BytesCallback_Imp { + Callable& callable; + _Callback(Callable& callable) : callable(callable) { } + void operator()(const std::vector& message) { callable(message); } + }; + _Callback callback(callable); + _dispatchBinary(callback); + } + + protected: + virtual void _dispatch(Callback_Imp& callable) = 0; + virtual void _dispatchBinary(BytesCallback_Imp& callable) = 0; + }; + +} // namespace easywsclient + +#endif /* EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD */