commit 950fc2eabb1007b85b69c74ef23efc1eb0f681e9 Author: Green Sky Date: Sat Apr 8 22:19:09 2023 +0200 initial commit diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..addd857 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.9 FATAL_ERROR) + +add_library(solanaceae_ipc_client + ./solanaceae/ipc1/zpp_rpc_cldev.hpp + + ./solanaceae/ipc1/tox_ipc_client.hpp + ./solanaceae/ipc1/tox_ipc_client.cpp +) + +target_include_directories(solana_ipc_client PUBLIC .) +target_compile_features(solana_ipc_client PRIVATE cxx_std_20) +target_link_libraries(solana_ipc_client PUBLIC + solanaceae_core + ipc + zpp_bits +) + +################################################# + +add_library(solanaceae_ipc_server + ./solanaceae/ipc1/zpp_rpc_cldev.hpp + + ./solanaceae/ipc1/tox_ipc_server.hpp + ./solanaceae/ipc1/tox_ipc_server.cpp +) + +target_include_directories(solana_ipc_server PUBLIC .) +target_compile_features(solana_ipc_server PRIVATE cxx_std_20) +target_link_libraries(solana_ipc_server PUBLIC + solanaceae_core + ipc + zpp_bits +) + diff --git a/solanaceae/ipc1/tox_ipc_client.cpp b/solanaceae/ipc1/tox_ipc_client.cpp new file mode 100644 index 0000000..365d11d --- /dev/null +++ b/solanaceae/ipc1/tox_ipc_client.cpp @@ -0,0 +1,319 @@ +#include "./tox_ipc_client.hpp" + +#include "./zpp_rpc_cldev.hpp" + +#include +#include + +using namespace zpp::bits::literals; + +ToxIPCClient::ToxIPCClient(void) { +} + +ToxIPCClient::~ToxIPCClient(void) { + // TODO: add free (not close) to ipc api +#if 0 // they gone, so no + ipc_mem_close(&_mem_rpc); + ipc_sem_close(&_sem_rpc_c); + ipc_sem_close(&_sem_rpc_s); + + ipc_mem_close(&_mem_events); + ipc_sem_close(&_sem_events_lock); +#endif +} + +bool ToxIPCClient::connect(void) { + // TODO: more cleanup? + { // rpc + ipc_mem_init(&_mem_rpc, "solana_toxI_rpc.shm", RPC_MEM_SIZE); // 2k prob enough for now + + // client expects it to exist + if (ipc_mem_open_existing(&_mem_rpc) != 0) { + std::cerr << "rpc shared mem not open\n"; + ipc_mem_close(&_mem_rpc); + return false; + } + + // client write lock (server waits on this) + ipc_sem_init(&_sem_rpc_c, "solana_toxI_rpc_client.lock"); + + if (ipc_sem_create(&_sem_rpc_c, 0) != 0) { + std::cerr << "failed to create sem_rpc_c\n"; + ipc_mem_close(&_mem_rpc); + return false; + } + + // server write lock (client waits on this) + ipc_sem_init(&_sem_rpc_s, "solana_toxI_rpc_server.lock"); + + if (ipc_sem_create(&_sem_rpc_s, 0) != 0) { + std::cerr << "failed to create sem_rpc_s\n"; + ipc_mem_close(&_mem_rpc); + return false; + } + // if no call is in progress, both sems are 0 + } + + { // events + ipc_mem_init(&_mem_events, "solana_toxEventsI_events.shm", EVENTS_MEM_SIZE); + // server creates + if (ipc_mem_open_existing(&_mem_events) != 0) { + std::cerr << "events shared mem not open\n"; + return false; + } + + // mutex + ipc_sem_init(&_sem_events_lock, "solana_toxEventsI_events.lock"); + if (ipc_sem_create(&_sem_events_lock, 1) != 0) { + std::cerr << "failed to create sem_events_lock\n"; + return false; + } + } + + return true; +} + +void ToxIPCClient::iterate(void) { + Tox_Events* events = nullptr; + + // grap mutex + ipc_sem_decrement(&_sem_events_lock); + + // read first byte + const uint8_t zbyte = ipc_mem_access(&_mem_events)[0]; + if (zbyte == EVENTS_WRITTEN) { + // if WRITTEN, serl, release mutex + events = tox_events_load(ipc_mem_access(&_mem_events)+1, EVENTS_MEM_SIZE-1); + + ipc_mem_access(&_mem_events)[0] = EVENTS_READ; + ipc_sem_increment(&_sem_events_lock); + } else { + // if not, release mutex exit + ipc_sem_increment(&_sem_events_lock); + return; + } + + // handle events + if (events == nullptr) { + std::cerr << "error: read back empty events list?\n"; + return; + } + + dispatchEvents(events); + + tox_events_free(events); +} + +Tox_Connection ToxIPCClient::toxSelfGetConnectionStatus(void) { + // we assume we can write (warn) + + zpp::bits::in in{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; + zpp::bits::out out{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; + + // TODO: write magic on client and server to very + + // serl call + ToxI_rpc::client cl{in, out}; // ephimeral, should be cheap + + // TODO: no throw + + // write to mem + cl.request<"ToxI::toxSelfGetConnectionStatus"_sha1_int>().or_throw(); + + // inc sem + ipc_sem_increment(&_sem_rpc_c); + + // wait on sem (block) + ipc_sem_decrement(&_sem_rpc_s); + + // deserl res and return + return cl.response<"ToxI::toxSelfGetConnectionStatus"_sha1_int>().or_throw(); +} + +#define CL_SETUP_BUFS \ + zpp::bits::in in{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; \ + zpp::bits::out out{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; \ + ToxI_rpc::client cl{in, out}; + +#define CL_REQUEST(X, ...) cl.request<"ToxI::" #X##_sha1_int>(__VA_ARGS__).or_throw(); +#define CL_REQUEST_STR(X, ...) cl.request<"ToxI::" #X "_str"_sha1_int>(__VA_ARGS__).or_throw(); + +#define CL_SEMWAIT \ + ipc_sem_increment(&_sem_rpc_c); \ + ipc_sem_decrement(&_sem_rpc_s); + +#define CL_RESPONSE(X) return cl.response<"ToxI::" #X##_sha1_int>().or_throw(); +#define CL_RESPONSE_STR(X) return cl.response<"ToxI::" #X "_str"_sha1_int>().or_throw(); +// TODO: for real? +#define CL_RESPONSE_VOID(X) cl.response<"ToxI::" #X##_sha1_int>().or_throw(); + +#define CL_BODY(X, ...) \ + CL_SETUP_BUFS \ + CL_REQUEST(X, __VA_ARGS__) \ + CL_SEMWAIT \ + CL_RESPONSE(X) + +#define CL_BODY_STR(X, ...) \ + CL_SETUP_BUFS \ + CL_REQUEST_STR(X, __VA_ARGS__) \ + CL_SEMWAIT \ + CL_RESPONSE_STR(X) + +#define CL_BODY_VOID(X, ...) \ + CL_SETUP_BUFS \ + CL_REQUEST(X, __VA_ARGS__) \ + CL_SEMWAIT +// TODO: response with void? + +uint32_t ToxIPCClient::toxIterationInterval(void) { + CL_BODY(toxIterationInterval) +} + +std::vector ToxIPCClient::toxSelfGetAddress(void) { + CL_BODY(toxSelfGetAddress) +} + +void ToxIPCClient::toxSelfSetNospam(uint32_t nospam) { + CL_BODY_VOID(toxSelfSetNospam, nospam) +} + +uint32_t ToxIPCClient::toxSelfGetNospam(void) { + CL_BODY(toxSelfGetNospam) +} + +std::vector ToxIPCClient::toxSelfGetPublicKey(void) { + CL_BODY(toxSelfGetPublicKey) +} + +Tox_Err_Set_Info ToxIPCClient::toxSelfSetName(std::string_view name) { + CL_BODY(toxSelfSetName, std::string{name}) +} + +std::string ToxIPCClient::toxSelfGetName(void) { + CL_BODY(toxSelfGetName) +} + +Tox_Err_Set_Info ToxIPCClient::toxSelfSetStatusMessage(std::string_view status_message) { + CL_BODY(toxSelfSetStatusMessage, std::string{status_message}) +} + +std::string ToxIPCClient::toxSelfGetStatusMessage(void) { + CL_BODY(toxSelfGetStatusMessage) +} + +void ToxIPCClient::toxSelfSetStatus(Tox_User_Status status) { + CL_BODY_VOID(toxSelfSetStatus, status) +} + +Tox_User_Status ToxIPCClient::toxSelfGetStatus(void) { + CL_BODY(toxSelfGetStatus) +} + +std::tuple, Tox_Err_Friend_Add> ToxIPCClient::toxFriendAdd(const std::vector& address, std::string_view message) { + CL_BODY(toxFriendAdd, address, std::string{message}) +} + +std::tuple, Tox_Err_Friend_Add> ToxIPCClient::toxFriendAddNorequest(const std::vector& public_key) { + CL_BODY(toxFriendAddNorequest, public_key) +} + +Tox_Err_Friend_Delete ToxIPCClient::toxFriendDelete(uint32_t friend_number) { + CL_BODY(toxFriendDelete, friend_number) +} + +std::tuple>, Tox_Err_Friend_Get_Public_Key> ToxIPCClient::toxFriendGetPublicKey(uint32_t friend_number) { + CL_BODY(toxFriendGetPublicKey, friend_number) +} + +std::tuple, Tox_Err_Friend_Send_Message> ToxIPCClient::toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) { + CL_BODY(toxFriendSendMessage, friend_number, type, std::string{message}) +} + +std::vector ToxIPCClient::toxHash(const std::vector& data) { + CL_BODY(toxHash, data) +} + +Tox_Err_Conference_Send_Message ToxIPCClient::toxConferenceSendMessage(uint32_t conference_number, Tox_Message_Type type, std::string_view message) { + CL_BODY(toxConferenceSendMessage, conference_number, type, std::string{message}) +} + +Tox_Err_Friend_Custom_Packet ToxIPCClient::toxFriendSendLossyPacket(uint32_t friend_number, const std::vector& data) { + CL_BODY(toxFriendSendLossyPacket, friend_number, data) +} + +Tox_Err_Friend_Custom_Packet ToxIPCClient::toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector& data) { + CL_BODY(toxFriendSendLosslessPacket, friend_number, data) +} + +std::tuple, Tox_Err_Group_New> ToxIPCClient::toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) { + CL_BODY(toxGroupNew, privacy_state, std::string{group_name}, std::string{name}) +} + +std::tuple, Tox_Err_Group_Join> ToxIPCClient::toxGroupJoin(const std::vector& chat_id, std::string_view name, std::string_view password) { + CL_BODY(toxGroupJoin, chat_id, std::string{name}, std::string{password}) +} + +std::optional ToxIPCClient::toxGroupIsConnected(uint32_t group_number) { + CL_BODY(toxGroupIsConnected, group_number) +} + +Tox_Err_Group_Reconnect ToxIPCClient::toxGroupReconnect(uint32_t group_number) { + CL_BODY(toxGroupReconnect, group_number) +} + +Tox_Err_Group_Leave ToxIPCClient::toxGroupLeave(uint32_t group_number, std::string_view part_message) { + CL_BODY(toxGroupLeave, group_number, std::string{part_message}) +} + +std::optional ToxIPCClient::toxGroupSelfGetName(uint32_t group_number) { + CL_BODY(toxGroupSelfGetName, group_number) +} + +std::tuple, Tox_Err_Group_Peer_Query> ToxIPCClient::toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) { + CL_BODY(toxGroupPeerGetName, group_number, peer_id) +} + +std::tuple, Tox_Err_Group_Peer_Query> ToxIPCClient::toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) { + CL_BODY(toxGroupPeerGetConnectionStatus, group_number, peer_id) +} + +Tox_Err_Group_Topic_Set ToxIPCClient::toxGroupSetTopic(uint32_t group_number, std::string_view topic) { + CL_BODY(toxGroupSetTopic, group_number, std::string{topic}) +} + +std::optional ToxIPCClient::toxGroupGetTopic(uint32_t group_number) { + CL_BODY(toxGroupGetTopic, group_number) +} + +std::optional ToxIPCClient::toxGroupGetName(uint32_t group_number) { + CL_BODY(toxGroupGetName, group_number) +} + +std::optional> ToxIPCClient::toxGroupGetChatId(uint32_t group_number) { + CL_BODY(toxGroupGetChatId, group_number) +} + +std::tuple, Tox_Err_Group_Send_Message> ToxIPCClient::toxGroupSendMessage(uint32_t group_number, Tox_Message_Type type, std::string_view message) { + CL_BODY(toxGroupSendMessage, group_number, type, std::string{message}) +} + +Tox_Err_Group_Send_Private_Message ToxIPCClient::toxGroupSendPrivateMessage(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, std::string_view message) { + CL_BODY(toxGroupSendPrivateMessage, group_number, peer_id, type, std::string{message}) +} + +Tox_Err_Group_Send_Custom_Packet ToxIPCClient::toxGroupSendCustomPacket(uint32_t group_number, bool lossless, const std::vector& data) { + CL_BODY(toxGroupSendCustomPacket, group_number, lossless, data) +} + +Tox_Err_Group_Send_Custom_Private_Packet ToxIPCClient::toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector& data) { + CL_BODY(toxGroupSendCustomPrivatePacket, group_number, peer_id, lossless, data) +} + +Tox_Err_Group_Invite_Friend ToxIPCClient::toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) { + CL_BODY(toxGroupInviteFriend, group_number, friend_number) +} + +std::tuple, Tox_Err_Group_Invite_Accept> ToxIPCClient::toxGroupInviteAccept(uint32_t friend_number, const std::vector& invite_data, std::string_view name, std::string_view password) { + CL_BODY(toxGroupInviteAccept, friend_number, invite_data, std::string{name}, std::string{password}) +} + diff --git a/solanaceae/ipc1/tox_ipc_client.hpp b/solanaceae/ipc1/tox_ipc_client.hpp new file mode 100644 index 0000000..43b7968 --- /dev/null +++ b/solanaceae/ipc1/tox_ipc_client.hpp @@ -0,0 +1,96 @@ +#pragma once + +#include +#include + +#include + +class ToxIPCClient : public ToxI, public ToxEventProviderBase { + ipc_sharedmemory _mem_rpc; + ipc_sharedsemaphore _sem_rpc_c; + ipc_sharedsemaphore _sem_rpc_s; + + ipc_sharedmemory _mem_events; + ipc_sharedsemaphore _sem_events_lock; + + public: + ToxIPCClient(void); + ~ToxIPCClient(void); + + bool connect(void); + + // pulls events and handles them + void iterate(void); + + public: // ToxI + Tox_Connection toxSelfGetConnectionStatus(void) override; + uint32_t toxIterationInterval(void) override; + + std::vector toxSelfGetAddress(void) override; + + void toxSelfSetNospam(uint32_t nospam) override; + uint32_t toxSelfGetNospam(void) override; + + std::vector toxSelfGetPublicKey(void) override; + + Tox_Err_Set_Info toxSelfSetName(std::string_view name) override; + std::string toxSelfGetName(void) override; + + Tox_Err_Set_Info toxSelfSetStatusMessage(std::string_view status_message) override; + std::string toxSelfGetStatusMessage(void) override; + + void toxSelfSetStatus(Tox_User_Status status) override; + Tox_User_Status toxSelfGetStatus(void) override; + + std::tuple, Tox_Err_Friend_Add> toxFriendAdd(const std::vector& address, std::string_view message) override; + std::tuple, Tox_Err_Friend_Add> toxFriendAddNorequest(const std::vector& public_key) override; + Tox_Err_Friend_Delete toxFriendDelete(uint32_t friend_number) override; + std::tuple>, Tox_Err_Friend_Get_Public_Key> toxFriendGetPublicKey(uint32_t friend_number) override; + + std::tuple, Tox_Err_Friend_Send_Message> toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) override; + + // should this be virtual at all? + // TODO: array? make it type agnostic? + std::vector toxHash(const std::vector& data) override; + + // files + // conferece + Tox_Err_Conference_Send_Message toxConferenceSendMessage(uint32_t conference_number, Tox_Message_Type type, std::string_view message) override; + + Tox_Err_Friend_Custom_Packet toxFriendSendLossyPacket(uint32_t friend_number, const std::vector& data) override; + Tox_Err_Friend_Custom_Packet toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector& data) override; + + // dht + // udp + // tcp + + // group + + std::tuple, Tox_Err_Group_New> toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) override; + std::tuple, Tox_Err_Group_Join> toxGroupJoin(const std::vector& chat_id, std::string_view name, std::string_view password) override; + std::optional toxGroupIsConnected(uint32_t group_number) override; + Tox_Err_Group_Reconnect toxGroupReconnect(uint32_t group_number) override; + Tox_Err_Group_Leave toxGroupLeave(uint32_t group_number, std::string_view part_message) override; + + std::optional toxGroupSelfGetName(uint32_t group_number) override; + + std::tuple, Tox_Err_Group_Peer_Query> toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) override; + std::tuple, Tox_Err_Group_Peer_Query> toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) override; + + Tox_Err_Group_Topic_Set toxGroupSetTopic(uint32_t group_number, std::string_view topic) override; + std::optional toxGroupGetTopic(uint32_t group_number) override; + + std::optional toxGroupGetName(uint32_t group_number) override; + std::optional> toxGroupGetChatId(uint32_t group_number) override; + // TODO: str + + std::tuple, Tox_Err_Group_Send_Message> toxGroupSendMessage(uint32_t group_number, Tox_Message_Type type, std::string_view message) override; + Tox_Err_Group_Send_Private_Message toxGroupSendPrivateMessage(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, std::string_view message) override; + + Tox_Err_Group_Send_Custom_Packet toxGroupSendCustomPacket(uint32_t group_number, bool lossless, const std::vector& data) override; + Tox_Err_Group_Send_Custom_Private_Packet toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector& data) override; + + Tox_Err_Group_Invite_Friend toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) override; + std::tuple, Tox_Err_Group_Invite_Accept> toxGroupInviteAccept(uint32_t friend_number, const std::vector& invite_data, std::string_view name, std::string_view password) override; +}; + diff --git a/solanaceae/ipc1/tox_ipc_server.cpp b/solanaceae/ipc1/tox_ipc_server.cpp new file mode 100644 index 0000000..588916c --- /dev/null +++ b/solanaceae/ipc1/tox_ipc_server.cpp @@ -0,0 +1,147 @@ +#include "./tox_ipc_server.hpp" + +#include "./zpp_rpc_cldev.hpp" + +#include + +#include +#include +#include +#include + +ToxIPCServer::ToxIPCServer(ToxI& t, std::mutex& t_m) : _t(t), _t_m(t_m) { +} + +ToxIPCServer::~ToxIPCServer(void) { + ipc_mem_close(&_mem_rpc); + ipc_sem_close(&_sem_rpc_c); + ipc_sem_close(&_sem_rpc_s); + + ipc_mem_close(&_mem_events); + ipc_sem_close(&_sem_events_lock); +} + +bool ToxIPCServer::connect(void) { + { // rpc + ipc_mem_init(&_mem_rpc, "solana_toxI_rpc.shm", RPC_MEM_SIZE); // 2k prob enough for now + // server creates + if (ipc_mem_create(&_mem_rpc) != 0) { + std::cerr << "rpc shared mem already exists or failed\n"; + return false; + } + + // client write lock (server waits on this) + ipc_sem_init(&_sem_rpc_c, "solana_toxI_rpc_client.lock"); + if (ipc_sem_create(&_sem_rpc_c, 0) != 0) { + std::cerr << "failed to create sem_rpc_c\n"; + return false; + } + + // server write lock (client waits on this) + ipc_sem_init(&_sem_rpc_s, "solana_toxI_rpc_server.lock"); + if (ipc_sem_create(&_sem_rpc_s, 0) != 0) { + std::cerr << "failed to create sem_rpc_s\n"; + return false; + } + // if no call is in progress, both sems are 0 + } + + { // events + ipc_mem_init(&_mem_events, "solana_toxEventsI_events.shm", EVENTS_MEM_SIZE); + // server creates + if (ipc_mem_create(&_mem_events) != 0) { + std::cerr << "events shared mem already exists or failed\n"; + return false; + } + // TODO: do this with the lock? + ipc_mem_access(&_mem_events)[0] = EVENTS_READ; // reset + + // mutex + ipc_sem_init(&_sem_events_lock, "solana_toxEventsI_events.lock"); + if (ipc_sem_create(&_sem_events_lock, 1) != 0) { + std::cerr << "failed to create sem_events_lock\n"; + return false; + } + } + + return true; +} + +using namespace std::chrono_literals; + +void ToxIPCServer::run(void) { + while (!_quit) { + // wait for client call + ipc_sem_decrement(&_sem_rpc_c); + + if (_quit) { + break; + } + + zpp::bits::in in{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; + zpp::bits::out out{std::span{ipc_mem_access(&_mem_rpc), RPC_MEM_SIZE}}; + + ToxI_rpc::server se{in, out, _t}; // ephimeral, should be cheap + + { + std::lock_guard lg{_t_m}; + se.serve().or_throw(); + } + + // signal client + ipc_sem_increment(&_sem_rpc_s); + } +} + +void ToxIPCServer::start(void) { + _thread = std::thread([this](){ this->run(); }); +} + +void ToxIPCServer::stop(void) { + _quit = true; + ipc_sem_increment(&_sem_rpc_c); // hack, wake up server thread + _thread.join(); +} + +void ToxIPCServer::updateEvents(const Tox_Events* events) { + if (uint32_t size = tox_events_bytes_size(events); size <= EVENTS_MEM_SIZE-1) { + _tmp_events_buf.resize(size); + tox_events_get_bytes(events, _tmp_events_buf.data()); + } else { + std::cerr << "events data bigger than space (" << size << " > " << EVENTS_MEM_SIZE-1 << ")\n"; + } +} + +void ToxIPCServer::pub(void) { + if (_tmp_events_buf.empty()) { + return; // no events, no op + } + + // if noone is reading the events, this loop sleeps ~30ms + for (size_t i = 0; i < 10; i++) { + // grap mutex + ipc_sem_decrement(&_sem_events_lock); + + // look at first byte if it got read + const uint8_t zbyte = ipc_mem_access(&_mem_events)[0]; + if (zbyte == EVENTS_WRITTEN) { + // if not, release mutex and short sleep + ipc_sem_increment(&_sem_events_lock); + std::this_thread::sleep_for(3ms); + } else { + break; + } + } + + // after loop we write events (potentially overwriting) + + // memcpy new events, set first byte + std::memcpy(ipc_mem_access(&_mem_events)+1, _tmp_events_buf.data(), _tmp_events_buf.size()); + ipc_mem_access(&_mem_events)[0] = EVENTS_WRITTEN; + + _tmp_events_buf.clear(); // TODO: just mark read, and keep around + + // release mutex + ipc_sem_increment(&_sem_events_lock); +} + diff --git a/solanaceae/ipc1/tox_ipc_server.hpp b/solanaceae/ipc1/tox_ipc_server.hpp new file mode 100644 index 0000000..924a578 --- /dev/null +++ b/solanaceae/ipc1/tox_ipc_server.hpp @@ -0,0 +1,51 @@ +#pragma once + +//#include + +#include + +#include +#include +#include +#include + +// fwd +struct ToxI; +struct Tox_Events; + +class ToxIPCServer { + ipc_sharedmemory _mem_rpc; + ipc_sharedsemaphore _sem_rpc_c; + ipc_sharedsemaphore _sem_rpc_s; + + ipc_sharedmemory _mem_events; + ipc_sharedsemaphore _sem_events_lock; + + ToxI& _t; + std::mutex& _t_m; + + std::atomic_bool _quit = false; + + std::thread _thread; + + std::vector _tmp_events_buf; + + void run(void); + + public: + ToxIPCServer(ToxI& t, std::mutex& t_m); + ~ToxIPCServer(void); + + bool connect(void); + + // starts a thread and serves + void start(void); + void stop(void); + + // take events, serialize + void updateEvents(const Tox_Events* events); + + // this might sleep for longer, and events might get discarded + void pub(void); +}; + diff --git a/solanaceae/ipc1/zpp_rpc_cldev.hpp b/solanaceae/ipc1/zpp_rpc_cldev.hpp new file mode 100644 index 0000000..e8f0fcd --- /dev/null +++ b/solanaceae/ipc1/zpp_rpc_cldev.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include + +#include + +static constexpr size_t RPC_MEM_SIZE = 1024u * 4u; // 4kb +static constexpr size_t EVENTS_MEM_SIZE = 1024u * 1024u * 64u; // 64mb + +static constexpr uint8_t EVENTS_WRITTEN = 0x05; +static constexpr uint8_t EVENTS_READ = 0x00; + +using namespace zpp::bits::literals; + +using ToxI_rpc = zpp::bits::rpc< + zpp::bits::bind<&ToxI::toxSelfGetConnectionStatus, "ToxI::toxSelfGetConnectionStatus"_sha1_int>, + zpp::bits::bind<&ToxI::toxIterationInterval, "ToxI::toxIterationInterval"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetAddress, "ToxI::toxSelfGetAddress"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfSetNospam, "ToxI::toxSelfSetNospam"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetNospam, "ToxI::toxSelfGetNospam"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetPublicKey, "ToxI::toxSelfGetPublicKey"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfSetName_str, "ToxI::toxSelfSetName"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetName, "ToxI::toxSelfGetName"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfSetStatusMessage_str, "ToxI::toxSelfSetStatusMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetStatusMessage, "ToxI::toxSelfGetStatusMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfSetStatus, "ToxI::toxSelfSetStatus"_sha1_int>, + zpp::bits::bind<&ToxI::toxSelfGetStatus, "ToxI::toxSelfGetStatus"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendAdd_str, "ToxI::toxFriendAdd"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendAddNorequest, "ToxI::toxFriendAddNorequest"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendDelete, "ToxI::toxFriendDelete"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendGetPublicKey, "ToxI::toxFriendGetPublicKey"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendSendMessage_str, "ToxI::toxFriendSendMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxHash, "ToxI::toxHash"_sha1_int>, // TODO: remove lol + zpp::bits::bind<&ToxI::toxConferenceSendMessage_str, "ToxI::toxConferenceSendMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendSendLossyPacket, "ToxI::toxFriendSendLossyPacket"_sha1_int>, + zpp::bits::bind<&ToxI::toxFriendSendLosslessPacket, "ToxI::toxFriendSendLosslessPacket"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupNew_str, "ToxI::toxGroupNew"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupJoin_str, "ToxI::toxGroupJoin"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupIsConnected, "ToxI::toxGroupIsConnected"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupReconnect, "ToxI::toxGroupReconnect"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupLeave_str, "ToxI::toxGroupLeave"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSelfGetName, "ToxI::toxGroupSelfGetName"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupPeerGetName, "ToxI::toxGroupPeerGetName"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupPeerGetConnectionStatus, "ToxI::toxGroupPeerGetConnectionStatus"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSetTopic_str, "ToxI::toxGroupSetTopic"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupGetTopic, "ToxI::toxGroupGetTopic"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupGetName, "ToxI::toxGroupGetName"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupGetChatId, "ToxI::toxGroupGetChatId"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSendMessage_str, "ToxI::toxGroupSendMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSendPrivateMessage_str, "ToxI::toxGroupSendPrivateMessage"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSendCustomPacket, "ToxI::toxGroupSendCustomPacket"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupSendCustomPrivatePacket, "ToxI::toxGroupSendCustomPrivatePacket"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupInviteFriend, "ToxI::toxGroupInviteFriend"_sha1_int>, + zpp::bits::bind<&ToxI::toxGroupInviteAccept_str, "ToxI::toxGroupInviteAccept"_sha1_int> +>; +