Green-Sky/solanaceae_toxcore
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename core -> toxcore

Browse Source
This commit is contained in:
Green Sky
2023-07-21 15:17:05 +02:00
parent cac82821e8
commit 76fbeb9500
12 changed files with 15 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

589
solanaceae/toxcore/tox_default_impl.cpp Normal file
View File

@ -0,0 +1,589 @@
#include "./tox_default_impl.hpp"
Tox_Connection ToxDefaultImpl::toxSelfGetConnectionStatus(void) {
return tox_self_get_connection_status(_tox);
}
uint32_t ToxDefaultImpl::toxIterationInterval(void) {
return tox_iteration_interval(_tox);
}
std::vector<uint8_t> ToxDefaultImpl::toxSelfGetAddress(void) {
std::vector<uint8_t> self_addr{};
self_addr.resize(TOX_ADDRESS_SIZE);
tox_self_get_address(_tox, self_addr.data());
return self_addr;
}
void ToxDefaultImpl::toxSelfSetNospam(uint32_t nospam) {
tox_self_set_nospam(_tox, nospam);
}
uint32_t ToxDefaultImpl::toxSelfGetNospam(void) {
return tox_self_get_nospam(_tox);
}
std::vector<uint8_t> ToxDefaultImpl::toxSelfGetPublicKey(void) {
std::vector<uint8_t> self_pub{};
self_pub.resize(TOX_PUBLIC_KEY_SIZE);
tox_self_get_public_key(_tox, self_pub.data());
return self_pub;
}
Tox_Err_Set_Info ToxDefaultImpl::toxSelfSetName(std::string_view name) {
Tox_Err_Set_Info err = TOX_ERR_SET_INFO_OK;
tox_self_set_name(_tox, reinterpret_cast<const uint8_t*>(name.data()), name.size(), &err);
return err;
}
std::string ToxDefaultImpl::toxSelfGetName(void) {
std::string name;
name.resize(tox_self_get_name_size(_tox));
tox_self_get_name(_tox, reinterpret_cast<uint8_t*>(name.data()));
return name;
}
Tox_Err_Set_Info ToxDefaultImpl::toxSelfSetStatusMessage(std::string_view status_message) {
Tox_Err_Set_Info err = TOX_ERR_SET_INFO_OK;
tox_self_set_status_message(_tox, reinterpret_cast<const uint8_t*>(status_message.data()), status_message.size(), &err);
return err;
}
std::string ToxDefaultImpl::toxSelfGetStatusMessage(void) {
std::string status;
status.resize(tox_self_get_status_message_size(_tox));
tox_self_get_status_message(_tox, reinterpret_cast<uint8_t*>(status.data()));
return status;
}
void ToxDefaultImpl::toxSelfSetStatus(Tox_User_Status status) {
tox_self_set_status(_tox, status);
}
Tox_User_Status ToxDefaultImpl::toxSelfGetStatus(void) {
return tox_self_get_status(_tox);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> ToxDefaultImpl::toxFriendAdd(const std::vector<uint8_t>& address, std::string_view message) {
// TODO: check size
Tox_Err_Friend_Add err = TOX_ERR_FRIEND_ADD_OK;
auto res = tox_friend_add(_tox, address.data(), reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
if (err == TOX_ERR_FRIEND_ADD_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> ToxDefaultImpl::toxFriendAddNorequest(const std::vector<uint8_t>& public_key) {
// TODO: check size
Tox_Err_Friend_Add err = TOX_ERR_FRIEND_ADD_OK;
auto res = tox_friend_add_norequest(_tox, public_key.data(), &err);
if (err == TOX_ERR_FRIEND_ADD_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_Friend_Delete ToxDefaultImpl::toxFriendDelete(uint32_t friend_number) {
Tox_Err_Friend_Delete err = TOX_ERR_FRIEND_DELETE_OK;
tox_friend_delete(_tox, friend_number, &err);
return err;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_By_Public_Key> ToxDefaultImpl::toxFriendByPublicKey(const std::vector<uint8_t>& public_key) {
// TODO: check size
Tox_Err_Friend_By_Public_Key err = TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK;
auto res = tox_friend_by_public_key(_tox, public_key.data(), &err);
if (err == TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
bool ToxDefaultImpl::toxFriendExists(uint32_t friend_number) {
return tox_friend_exists(_tox, friend_number);
}
size_t ToxDefaultImpl::toxSelfGetFriendListSize(void) {
return tox_self_get_friend_list_size(_tox);
}
std::vector<uint32_t> ToxDefaultImpl::toxSelfGetFriendList(void) {
std::vector<uint32_t> friend_list;
friend_list.resize(tox_self_get_friend_list_size(_tox));
tox_self_get_friend_list(_tox, friend_list.data());
return friend_list;
}
std::optional<std::vector<uint8_t>> ToxDefaultImpl::toxFriendGetPublicKey(uint32_t friend_number) {
std::vector<uint8_t> pub(TOX_PUBLIC_KEY_SIZE);
Tox_Err_Friend_Get_Public_Key err = TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK;
tox_friend_get_public_key(_tox, friend_number, pub.data(), &err);
if (err == TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK) {
return pub;
} else {
return std::nullopt;
}
}
std::optional<uint64_t> ToxDefaultImpl::toxFriendGetLastOnline(uint32_t friend_number) {
Tox_Err_Friend_Get_Last_Online err = TOX_ERR_FRIEND_GET_LAST_ONLINE_OK;
auto res = tox_friend_get_last_online(_tox, friend_number, &err);
if (res == TOX_ERR_FRIEND_GET_LAST_ONLINE_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<std::string> ToxDefaultImpl::toxFriendGetName(uint32_t friend_number) {
std::string name;
Tox_Err_Friend_Query err = TOX_ERR_FRIEND_QUERY_OK;
const auto size = tox_friend_get_name_size(_tox, friend_number, &err);
if (err != TOX_ERR_FRIEND_QUERY_OK) {
return std::nullopt;
}
name.resize(size);
tox_friend_get_name(_tox, friend_number, reinterpret_cast<uint8_t*>(name.data()), &err);
if (err == TOX_ERR_FRIEND_QUERY_OK) {
return name;
} else {
return std::nullopt;
}
}
std::optional<std::string> ToxDefaultImpl::toxFriendGetStatusMessage(uint32_t friend_number) {
std::string status;
Tox_Err_Friend_Query err = TOX_ERR_FRIEND_QUERY_OK;
const auto size = tox_friend_get_status_message_size(_tox, friend_number, &err);
if (err != TOX_ERR_FRIEND_QUERY_OK) {
return std::nullopt;
}
status.resize(size);
tox_friend_get_status_message(_tox, friend_number, reinterpret_cast<uint8_t*>(status.data()), &err);
if (err == TOX_ERR_FRIEND_QUERY_OK) {
return status;
} else {
return std::nullopt;
}
}
std::optional<Tox_User_Status> ToxDefaultImpl::toxFriendGetStatus(uint32_t friend_number) {
Tox_Err_Friend_Query err = TOX_ERR_FRIEND_QUERY_OK;
auto res = tox_friend_get_status(_tox, friend_number, &err);
if (err == TOX_ERR_FRIEND_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<Tox_Connection> ToxDefaultImpl::toxFriendGetConnectionStatus(uint32_t friend_number) {
Tox_Err_Friend_Query err = TOX_ERR_FRIEND_QUERY_OK;
auto res = tox_friend_get_connection_status(_tox, friend_number, &err);
if (err == TOX_ERR_FRIEND_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<bool> ToxDefaultImpl::toxFriendGetTyping(uint32_t friend_number) {
Tox_Err_Friend_Query err = TOX_ERR_FRIEND_QUERY_OK;
auto res = tox_friend_get_typing(_tox, friend_number, &err);
if (err == TOX_ERR_FRIEND_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
Tox_Err_Set_Typing ToxDefaultImpl::toxSelfSetTyping(uint32_t friend_number, bool typing) {
Tox_Err_Set_Typing err = TOX_ERR_SET_TYPING_OK;
tox_self_set_typing(_tox, friend_number, typing, &err);
return err;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Send_Message> ToxDefaultImpl::toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) {
Tox_Err_Friend_Send_Message err = TOX_ERR_FRIEND_SEND_MESSAGE_OK;
auto res = tox_friend_send_message(_tox, friend_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
if (err == TOX_ERR_FRIEND_SEND_MESSAGE_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_File_Control ToxDefaultImpl::toxFileControl(uint32_t friend_number, uint32_t file_number, Tox_File_Control control) {
Tox_Err_File_Control err = TOX_ERR_FILE_CONTROL_OK;
tox_file_control(_tox, friend_number, file_number, control, &err);
return err;
}
Tox_Err_File_Seek ToxDefaultImpl::toxFileSeek(uint32_t friend_number, uint32_t file_number, uint64_t position) {
Tox_Err_File_Seek err = TOX_ERR_FILE_SEEK_OK;
tox_file_seek(_tox, friend_number, file_number, position, &err);
return err;
}
std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_File_Get> ToxDefaultImpl::toxFileGetFileID(uint32_t friend_number, uint32_t file_number) {
Tox_Err_File_Get err = TOX_ERR_FILE_GET_OK;
std::vector<uint8_t> id(TOX_FILE_ID_LENGTH);
tox_file_get_file_id(_tox, friend_number, file_number, id.data(), &err);
if (err == TOX_ERR_FILE_GET_OK) {
return {id, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<uint32_t>, Tox_Err_File_Send> ToxDefaultImpl::toxFileSend(uint32_t friend_number, uint32_t kind, uint64_t file_size, const std::vector<uint8_t>& file_id, std::string_view filename) {
// TODO: check file_id size
Tox_Err_File_Send err = TOX_ERR_FILE_SEND_OK;
auto res = tox_file_send(_tox, friend_number, kind, file_size, file_id.data(), reinterpret_cast<const uint8_t*>(filename.data()), filename.size(), &err);
if (err == TOX_ERR_FILE_SEND_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_File_Send_Chunk ToxDefaultImpl::toxFileSendChunk(uint32_t friend_number, uint32_t file_number, uint64_t position, const std::vector<uint8_t>& data) {
Tox_Err_File_Send_Chunk err = TOX_ERR_FILE_SEND_CHUNK_OK;
tox_file_send_chunk(_tox, friend_number, file_number, position, data.data(), data.size(), &err);
return err;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Conference_Join> ToxDefaultImpl::toxConferenceJoin(uint32_t friend_number, const std::vector<uint8_t>& cookie) {
Tox_Err_Conference_Join err = TOX_ERR_CONFERENCE_JOIN_OK;
auto res = tox_conference_join(_tox, friend_number, cookie.data(), cookie.size(), &err);
if (err == TOX_ERR_CONFERENCE_JOIN_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_Conference_Send_Message ToxDefaultImpl::toxConferenceSendMessage(uint32_t conference_number, Tox_Message_Type type, std::string_view message) {
Tox_Err_Conference_Send_Message err = TOX_ERR_CONFERENCE_SEND_MESSAGE_OK;
tox_conference_send_message(_tox, conference_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
return err;
}
Tox_Err_Friend_Custom_Packet ToxDefaultImpl::toxFriendSendLossyPacket(uint32_t friend_number, const std::vector<uint8_t>& data) {
Tox_Err_Friend_Custom_Packet err = TOX_ERR_FRIEND_CUSTOM_PACKET_OK;
tox_friend_send_lossy_packet(_tox, friend_number, data.data(), data.size(), &err);
return err;
}
Tox_Err_Friend_Custom_Packet ToxDefaultImpl::toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector<uint8_t>& data) {
Tox_Err_Friend_Custom_Packet err = TOX_ERR_FRIEND_CUSTOM_PACKET_OK;
tox_friend_send_lossless_packet(_tox, friend_number, data.data(), data.size(), &err);
return err;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_New> ToxDefaultImpl::toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) {
Tox_Err_Group_New err = TOX_ERR_GROUP_NEW_OK;
auto res = tox_group_new(_tox, privacy_state, reinterpret_cast<const uint8_t*>(group_name.data()), group_name.size(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), &err);
if (err == TOX_ERR_GROUP_NEW_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Join> ToxDefaultImpl::toxGroupJoin(const std::vector<uint8_t>& chat_id, std::string_view name, std::string_view password) {
Tox_Err_Group_Join err = TOX_ERR_GROUP_JOIN_OK;
// TODO: check size
auto res = tox_group_join(_tox, chat_id.data(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), reinterpret_cast<const uint8_t*>(password.data()), password.size(), &err);
if (err == TOX_ERR_GROUP_JOIN_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
std::optional<bool> ToxDefaultImpl::toxGroupIsConnected(uint32_t group_number) {
Tox_Err_Group_Is_Connected err = TOX_ERR_GROUP_IS_CONNECTED_OK;
auto res = tox_group_is_connected(_tox, group_number, &err);
if (err == TOX_ERR_GROUP_IS_CONNECTED_OK) {
return res;
} else {
return std::nullopt;
}
}
Tox_Err_Group_Disconnect ToxDefaultImpl::toxGroupDisconnect(uint32_t group_number) {
Tox_Err_Group_Disconnect err = TOX_ERR_GROUP_DISCONNECT_OK;
tox_group_disconnect(_tox, group_number, &err);
return err;
}
Tox_Err_Group_Reconnect ToxDefaultImpl::toxGroupReconnect(uint32_t group_number) {
Tox_Err_Group_Reconnect err = TOX_ERR_GROUP_RECONNECT_OK;
tox_group_reconnect(_tox, group_number, &err);
return err;
}
Tox_Err_Group_Leave ToxDefaultImpl::toxGroupLeave(uint32_t group_number, std::string_view part_message) {
Tox_Err_Group_Leave err = TOX_ERR_GROUP_LEAVE_OK;
tox_group_leave(_tox, group_number, reinterpret_cast<const uint8_t*>(part_message.data()), part_message.size(), &err);
return err;
}
Tox_Err_Group_Self_Name_Set ToxDefaultImpl::toxGroupSelfSetName(uint32_t group_number, std::string_view name) {
Tox_Err_Group_Self_Name_Set err = TOX_ERR_GROUP_SELF_NAME_SET_OK;
tox_group_self_set_name(_tox, group_number, reinterpret_cast<const uint8_t*>(name.data()), name.size(), &err);
return err;
}
std::optional<std::string> ToxDefaultImpl::toxGroupSelfGetName(uint32_t group_number) {
std::string name;
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
const auto size = tox_group_self_get_name_size(_tox, group_number, &err);
if (err != TOX_ERR_GROUP_SELF_QUERY_OK) {
return std::nullopt;
}
name.resize(size);
tox_group_self_get_name(_tox, group_number, reinterpret_cast<uint8_t*>(name.data()), &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
return name;
} else {
return std::nullopt;
}
}
Tox_Err_Group_Self_Status_Set ToxDefaultImpl::toxGroupSelfSetStatus(uint32_t group_number, Tox_User_Status status) {
Tox_Err_Group_Self_Status_Set err = TOX_ERR_GROUP_SELF_STATUS_SET_OK;
tox_group_self_set_status(_tox, group_number, status, &err);
return err;
}
std::optional<Tox_User_Status> ToxDefaultImpl::toxGroupSelfGetStatus(uint32_t group_number) {
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
auto res = tox_group_self_get_status(_tox, group_number, &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<Tox_Group_Role> ToxDefaultImpl::toxGroupSelfGetRole(uint32_t group_number) {
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
auto res = tox_group_self_get_role(_tox, group_number, &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<uint32_t> ToxDefaultImpl::toxGroupSelfGetPeerId(uint32_t group_number) {
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
auto res = tox_group_self_get_peer_id(_tox, group_number, &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
return res;
} else {
return std::nullopt;
}
}
std::optional<std::vector<uint8_t>> ToxDefaultImpl::toxGroupSelfGetPublicKey(uint32_t group_number) {
std::vector<uint8_t> public_key(TOX_GROUP_PEER_PUBLIC_KEY_SIZE);
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
tox_group_self_get_public_key(_tox, group_number, public_key.data(), &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
return public_key;
} else {
return std::nullopt;
}
}
std::tuple<std::optional<std::string>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) {
std::string name;
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
const auto size = tox_group_peer_get_name_size(_tox, group_number, peer_id, &err);
if (err != TOX_ERR_GROUP_PEER_QUERY_OK) {
return {std::nullopt, err};
}
name.resize(size);
tox_group_peer_get_name(_tox, group_number, peer_id, reinterpret_cast<uint8_t*>(name.data()), &err);
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
return {name, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<Tox_User_Status>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetStatus(uint32_t group_number, uint32_t peer_id) {
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
auto res = tox_group_peer_get_status(_tox, group_number, peer_id, &err);
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<Tox_Group_Role>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetRole(uint32_t group_number, uint32_t peer_id) {
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
auto res = tox_group_peer_get_role(_tox, group_number, peer_id, &err);
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
return {res, err};
} else{
return {std::nullopt, err};
}
}
std::tuple<std::optional<Tox_Connection>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) {
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
auto res = tox_group_peer_get_connection_status(_tox, group_number, peer_id, &err);
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}
std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetPublicKey(uint32_t group_number, uint32_t peer_id) {
std::vector<uint8_t> public_key(TOX_GROUP_PEER_PUBLIC_KEY_SIZE);
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
tox_group_peer_get_public_key(_tox, group_number, peer_id, public_key.data(), &err);
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
return {public_key, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_Group_Topic_Set ToxDefaultImpl::toxGroupSetTopic(uint32_t group_number, std::string_view topic) {
Tox_Err_Group_Topic_Set err = TOX_ERR_GROUP_TOPIC_SET_OK;
tox_group_set_topic(_tox, group_number, reinterpret_cast<const uint8_t*>(topic.data()), topic.size(), &err);
return err;
}
std::optional<std::string> ToxDefaultImpl::toxGroupGetTopic(uint32_t group_number) {
std::string topic;
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
const auto size = tox_group_get_topic_size(_tox, group_number, &err);
if (err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
return std::nullopt;
}
topic.resize(size);
tox_group_get_topic(_tox, group_number, reinterpret_cast<uint8_t*>(topic.data()), &err);
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
return topic;
} else {
return std::nullopt;
}
}
std::optional<std::string> ToxDefaultImpl::toxGroupGetName(uint32_t group_number) {
std::string name;
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
const auto size = tox_group_get_name_size(_tox, group_number, &err);
if (err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
return std::nullopt;
}
name.resize(size);
tox_group_get_name(_tox, group_number, reinterpret_cast<uint8_t*>(name.data()), &err);
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
return name;
} else {
return std::nullopt;
}
}
std::optional<std::vector<uint8_t>> ToxDefaultImpl::toxGroupGetChatId(uint32_t group_number) {
std::vector<uint8_t> chat_id{};
chat_id.resize(TOX_GROUP_CHAT_ID_SIZE);
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
tox_group_get_chat_id(_tox, group_number, chat_id.data(), &err);
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
return chat_id;
} else {
return std::nullopt;
}
}
size_t ToxDefaultImpl::toxGroupGetNumberGroups(void) {
return tox_group_get_number_groups(_tox);
}
std::vector<uint32_t> ToxDefaultImpl::toxGroupGetList(void) {
std::vector<uint32_t> group_list;
size_t group_count = tox_group_get_number_groups(_tox);
// HACK: we guess number until we have count
for (uint32_t i = 0; i < group_count + 10'000u && group_list.size() < group_count; i++) {
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
tox_group_self_get_peer_id(_tox, i, &err);
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
group_list.push_back(i);
}
}
return group_list;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Send_Message> ToxDefaultImpl::toxGroupSendMessage(uint32_t group_number, Tox_Message_Type type, std::string_view message) {
Tox_Err_Group_Send_Message err = TOX_ERR_GROUP_SEND_MESSAGE_OK;
uint32_t message_id = 0;
const bool res = tox_group_send_message(_tox, group_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &message_id, &err);
if (res) {
return {message_id, err};
} else {
return {std::nullopt, err};
}
}
Tox_Err_Group_Send_Private_Message ToxDefaultImpl::toxGroupSendPrivateMessage(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, std::string_view message) {
Tox_Err_Group_Send_Private_Message err = TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK;
tox_group_send_private_message(_tox, group_number, peer_id, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
return err;
}
Tox_Err_Group_Send_Custom_Packet ToxDefaultImpl::toxGroupSendCustomPacket(uint32_t group_number, bool lossless, const std::vector<uint8_t>& data) {
Tox_Err_Group_Send_Custom_Packet err = TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK;
tox_group_send_custom_packet(_tox, group_number, lossless, data.data(), data.size(), &err);
return err;
}
Tox_Err_Group_Send_Custom_Private_Packet ToxDefaultImpl::toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector<uint8_t>& data) {
Tox_Err_Group_Send_Custom_Private_Packet err = TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK;
tox_group_send_custom_private_packet(_tox, group_number, peer_id, lossless, data.data(), data.size(), &err);
return err;
}
Tox_Err_Group_Invite_Friend ToxDefaultImpl::toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) {
Tox_Err_Group_Invite_Friend err = TOX_ERR_GROUP_INVITE_FRIEND_OK;
tox_group_invite_friend(_tox, group_number, friend_number, &err);
return err;
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Invite_Accept> ToxDefaultImpl::toxGroupInviteAccept(uint32_t friend_number, const std::vector<uint8_t>& invite_data, std::string_view name, std::string_view password) {
Tox_Err_Group_Invite_Accept err = TOX_ERR_GROUP_INVITE_ACCEPT_OK;
auto res = tox_group_invite_accept(_tox, friend_number, invite_data.data(), invite_data.size(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), reinterpret_cast<const uint8_t*>(password.data()), password.size(), &err);
if (err == TOX_ERR_GROUP_INVITE_ACCEPT_OK) {
return {res, err};
} else {
return {std::nullopt, err};
}
}

122
solanaceae/toxcore/tox_default_impl.hpp Normal file
View File

@ -0,0 +1,122 @@
#pragma once
#include "./tox_interface.hpp"
struct ToxDefaultImpl : public ToxI {
Tox* _tox = nullptr;
virtual ~ToxDefaultImpl(void) {}
Tox_Connection toxSelfGetConnectionStatus(void) override;
uint32_t toxIterationInterval(void) override;
std::vector<uint8_t> toxSelfGetAddress(void) override;
void toxSelfSetNospam(uint32_t nospam) override;
uint32_t toxSelfGetNospam(void) override;
std::vector<uint8_t> toxSelfGetPublicKey(void) override;
//virtual void toxSelfGetSecretKey(const Tox *tox, uint8_t *secret_key);
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<std::optional<uint32_t>, Tox_Err_Friend_Add> toxFriendAdd(const std::vector<uint8_t>& address, std::string_view message) override;
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> toxFriendAddNorequest(const std::vector<uint8_t>& public_key) override;
Tox_Err_Friend_Delete toxFriendDelete(uint32_t friend_number) override;
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_By_Public_Key> toxFriendByPublicKey(const std::vector<uint8_t>& public_key) override;
bool toxFriendExists(uint32_t friend_number) override;
size_t toxSelfGetFriendListSize(void) override;
std::vector<uint32_t> toxSelfGetFriendList(void) override;
std::optional<std::vector<uint8_t>> toxFriendGetPublicKey(uint32_t friend_number) override;
std::optional<uint64_t> toxFriendGetLastOnline(uint32_t friend_number) override;
std::optional<std::string> toxFriendGetName(uint32_t friend_number) override;
std::optional<std::string> toxFriendGetStatusMessage(uint32_t friend_number) override;
std::optional<Tox_User_Status> toxFriendGetStatus(uint32_t friend_number) override;
std::optional<Tox_Connection> toxFriendGetConnectionStatus(uint32_t friend_number) override;
std::optional<bool> toxFriendGetTyping(uint32_t friend_number) override;
Tox_Err_Set_Typing toxSelfSetTyping(uint32_t friend_number, bool typing) override;
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Send_Message> toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) override;
// files
Tox_Err_File_Control toxFileControl(uint32_t friend_number, uint32_t file_number, Tox_File_Control control) override;
Tox_Err_File_Seek toxFileSeek(uint32_t friend_number, uint32_t file_number, uint64_t position) override;
std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_File_Get> toxFileGetFileID(uint32_t friend_number, uint32_t file_number) override;
std::tuple<std::optional<uint32_t>, Tox_Err_File_Send> toxFileSend(uint32_t friend_number, uint32_t kind, uint64_t file_size, const std::vector<uint8_t>& file_id, std::string_view filename) override;
Tox_Err_File_Send_Chunk toxFileSendChunk(uint32_t friend_number, uint32_t file_number, uint64_t position, const std::vector<uint8_t>& data) override;
// conferece
std::tuple<std::optional<uint32_t>, Tox_Err_Conference_Join> toxConferenceJoin(uint32_t friend_number, const std::vector<uint8_t>& cookie) override;
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<uint8_t>& data) override;
Tox_Err_Friend_Custom_Packet toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector<uint8_t>& data) override;
// dht
// udp
// tcp
// group
std::tuple<std::optional<uint32_t>, Tox_Err_Group_New> toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) override;
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Join> toxGroupJoin(const std::vector<uint8_t>& chat_id, std::string_view name, std::string_view password) override;
std::optional<bool> toxGroupIsConnected(uint32_t group_number) override;
Tox_Err_Group_Disconnect toxGroupDisconnect(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;
Tox_Err_Group_Self_Name_Set toxGroupSelfSetName(uint32_t group_number, std::string_view name) override;
std::optional<std::string> toxGroupSelfGetName(uint32_t group_number) override;
Tox_Err_Group_Self_Status_Set toxGroupSelfSetStatus(uint32_t group_number, Tox_User_Status status) override;
std::optional<Tox_User_Status> toxGroupSelfGetStatus(uint32_t group_number) override;
std::optional<Tox_Group_Role> toxGroupSelfGetRole(uint32_t group_number) override;
std::optional<uint32_t> toxGroupSelfGetPeerId(uint32_t group_number) override;
std::optional<std::vector<uint8_t>> toxGroupSelfGetPublicKey(uint32_t group_number) override;
std::tuple<std::optional<std::string>, Tox_Err_Group_Peer_Query> toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) override;
std::tuple<std::optional<Tox_User_Status>, Tox_Err_Group_Peer_Query> toxGroupPeerGetStatus(uint32_t group_number, uint32_t peer_id) override;
std::tuple<std::optional<Tox_Group_Role>, Tox_Err_Group_Peer_Query> toxGroupPeerGetRole(uint32_t group_number, uint32_t peer_id) override;
std::tuple<std::optional<Tox_Connection>, Tox_Err_Group_Peer_Query> toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) override;
std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_Group_Peer_Query> toxGroupPeerGetPublicKey(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<std::string> toxGroupGetTopic(uint32_t group_number) override;
std::optional<std::string> toxGroupGetName(uint32_t group_number) override;
std::optional<std::vector<uint8_t>> toxGroupGetChatId(uint32_t group_number) override;
// TODO: str
size_t toxGroupGetNumberGroups(void) override;
std::vector<uint32_t> toxGroupGetList(void) override;
//virtual Tox_Group_Privacy_State toxGroupGetPrivacyState(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual Tox_Group_Voice_State toxGroupGetVoiceState(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual Tox_Group_Topic_Lock toxGroupGetTopicLock(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual uint16_t toxGroupGetPeerLimit(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual std::string toxGroupGetPassword(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
std::tuple<std::optional<uint32_t>, 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<uint8_t>& data) override;
Tox_Err_Group_Send_Custom_Private_Packet toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector<uint8_t>& data) override;
Tox_Err_Group_Invite_Friend toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) override;
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Invite_Accept> toxGroupInviteAccept(uint32_t friend_number, const std::vector<uint8_t>& invite_data, std::string_view name, std::string_view password) override;
//virtual Tox_Err_Group_Founder_Set_Password toxGroupFounderSetPassword(uint32_t group_number, std::string_view password) = 0;
//virtual Tox_Err_Group_Founder_Set_Topic_Lock toxGroupFounderSetTopicLock(uint32_t group_number, Tox_Group_Topic_Lock topic_lock) = 0;
//virtual Tox_Err_Group_Founder_Set_Voice_State toxGroupFounderSetVoiceState(uint32_t group_number, Tox_Group_Voice_State voice_state) = 0;
//virtual Tox_Err_Group_Founder_Set_Privacy_State toxGroupFounderSetPrivacyState(uint32_t group_number, Tox_Group_Privacy_State privacy_state) = 0;
//virtual Tox_Err_Group_Founder_Set_Peer_Limit toxGroupFounderSetPeerLimit(uint32_t group_number, uint16_t max_peers) = 0;
//virtual Tox_Err_Group_Set_Ignore toxGroupSetIgnore(uint32_t group_number, uint32_t peer_id, bool ignore) = 0;
//virtual Tox_Err_Group_Mod_Set_Role toxGroupModSetRole(uint32_t group_number, uint32_t peer_id, Tox_Group_Role role) = 0;
//virtual Tox_Err_Group_Mod_Kick_Peer toxGroupModKickPeer(uint32_t group_number, uint32_t peer_id) = 0;
};

179
solanaceae/toxcore/tox_event_interface.hpp Normal file
View File

@ -0,0 +1,179 @@
#pragma once
#include <tox/tox_events.h>
#include <string_view>
// defines the full event interface for tox event subscription
struct ToxEventI {
virtual ~ToxEventI(void) {}
// TODO: rename to onEvent()
#define VIRT_EVENT(x) virtual bool onToxEvent(const x*) { return false; }
// return true if the event is handled and should not be given down the chain
VIRT_EVENT(Tox_Event_Conference_Connected)
VIRT_EVENT(Tox_Event_Conference_Invite)
VIRT_EVENT(Tox_Event_Conference_Message)
VIRT_EVENT(Tox_Event_Conference_Peer_List_Changed)
VIRT_EVENT(Tox_Event_Conference_Peer_Name)
VIRT_EVENT(Tox_Event_Conference_Title)
VIRT_EVENT(Tox_Event_File_Chunk_Request)
VIRT_EVENT(Tox_Event_File_Recv)
VIRT_EVENT(Tox_Event_File_Recv_Chunk)
VIRT_EVENT(Tox_Event_File_Recv_Control)
VIRT_EVENT(Tox_Event_Friend_Connection_Status)
VIRT_EVENT(Tox_Event_Friend_Lossless_Packet)
VIRT_EVENT(Tox_Event_Friend_Lossy_Packet)
VIRT_EVENT(Tox_Event_Friend_Message)
VIRT_EVENT(Tox_Event_Friend_Name)
VIRT_EVENT(Tox_Event_Friend_Read_Receipt)
VIRT_EVENT(Tox_Event_Friend_Request)
VIRT_EVENT(Tox_Event_Friend_Status)
VIRT_EVENT(Tox_Event_Friend_Status_Message)
VIRT_EVENT(Tox_Event_Friend_Typing)
VIRT_EVENT(Tox_Event_Self_Connection_Status)
VIRT_EVENT(Tox_Event_Group_Peer_Name)
VIRT_EVENT(Tox_Event_Group_Peer_Status)
VIRT_EVENT(Tox_Event_Group_Topic)
VIRT_EVENT(Tox_Event_Group_Privacy_State)
VIRT_EVENT(Tox_Event_Group_Voice_State)
VIRT_EVENT(Tox_Event_Group_Topic_Lock)
VIRT_EVENT(Tox_Event_Group_Peer_Limit)
VIRT_EVENT(Tox_Event_Group_Password)
VIRT_EVENT(Tox_Event_Group_Message)
VIRT_EVENT(Tox_Event_Group_Private_Message)
VIRT_EVENT(Tox_Event_Group_Custom_Packet)
VIRT_EVENT(Tox_Event_Group_Custom_Private_Packet)
VIRT_EVENT(Tox_Event_Group_Invite)
VIRT_EVENT(Tox_Event_Group_Peer_Join)
VIRT_EVENT(Tox_Event_Group_Peer_Exit)
VIRT_EVENT(Tox_Event_Group_Self_Join)
VIRT_EVENT(Tox_Event_Group_Join_Fail)
VIRT_EVENT(Tox_Event_Group_Moderation)
#undef VIRT_EVENT
};
// defines the interface where to subscribe
struct ToxEventProviderI {
virtual ~ToxEventProviderI(void) {}
// TODO: unsub
virtual void subscribe(ToxEventI* object, const Tox_Event event_type) = 0;
};
constexpr Tox_Event tox_event_from_string(const std::string_view str) {
#define CASE_E_TYPE(x) if (str == #x) return Tox_Event::x;
CASE_E_TYPE(TOX_EVENT_SELF_CONNECTION_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_REQUEST)
CASE_E_TYPE(TOX_EVENT_FRIEND_CONNECTION_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_LOSSY_PACKET)
CASE_E_TYPE(TOX_EVENT_FRIEND_LOSSLESS_PACKET)
CASE_E_TYPE(TOX_EVENT_FRIEND_NAME)
CASE_E_TYPE(TOX_EVENT_FRIEND_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_STATUS_MESSAGE)
CASE_E_TYPE(TOX_EVENT_FRIEND_MESSAGE)
CASE_E_TYPE(TOX_EVENT_FRIEND_READ_RECEIPT)
CASE_E_TYPE(TOX_EVENT_FRIEND_TYPING)
CASE_E_TYPE(TOX_EVENT_FILE_CHUNK_REQUEST)
CASE_E_TYPE(TOX_EVENT_FILE_RECV)
CASE_E_TYPE(TOX_EVENT_FILE_RECV_CHUNK)
CASE_E_TYPE(TOX_EVENT_FILE_RECV_CONTROL)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_INVITE)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_CONNECTED)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_PEER_NAME)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_TITLE)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_NAME)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_STATUS)
CASE_E_TYPE(TOX_EVENT_GROUP_TOPIC)
CASE_E_TYPE(TOX_EVENT_GROUP_PRIVACY_STATE)
CASE_E_TYPE(TOX_EVENT_GROUP_VOICE_STATE)
CASE_E_TYPE(TOX_EVENT_GROUP_TOPIC_LOCK)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_LIMIT)
CASE_E_TYPE(TOX_EVENT_GROUP_PASSWORD)
CASE_E_TYPE(TOX_EVENT_GROUP_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_PRIVATE_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_CUSTOM_PACKET)
CASE_E_TYPE(TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET)
CASE_E_TYPE(TOX_EVENT_GROUP_INVITE)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_JOIN)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_EXIT)
CASE_E_TYPE(TOX_EVENT_GROUP_SELF_JOIN)
CASE_E_TYPE(TOX_EVENT_GROUP_JOIN_FAIL)
CASE_E_TYPE(TOX_EVENT_GROUP_MODERATION)
return (Tox_Event)-1; // TODO: add invalid event enum?
#undef CASE_E_TYPE
}
constexpr std::string_view tox_event_to_string(const Tox_Event e) {
#define CASE_E_TYPE(x) if (e == x) return #x;
CASE_E_TYPE(TOX_EVENT_SELF_CONNECTION_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_REQUEST)
CASE_E_TYPE(TOX_EVENT_FRIEND_CONNECTION_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_LOSSY_PACKET)
CASE_E_TYPE(TOX_EVENT_FRIEND_LOSSLESS_PACKET)
CASE_E_TYPE(TOX_EVENT_FRIEND_NAME)
CASE_E_TYPE(TOX_EVENT_FRIEND_STATUS)
CASE_E_TYPE(TOX_EVENT_FRIEND_STATUS_MESSAGE)
CASE_E_TYPE(TOX_EVENT_FRIEND_MESSAGE)
CASE_E_TYPE(TOX_EVENT_FRIEND_READ_RECEIPT)
CASE_E_TYPE(TOX_EVENT_FRIEND_TYPING)
CASE_E_TYPE(TOX_EVENT_FILE_CHUNK_REQUEST)
CASE_E_TYPE(TOX_EVENT_FILE_RECV)
CASE_E_TYPE(TOX_EVENT_FILE_RECV_CHUNK)
CASE_E_TYPE(TOX_EVENT_FILE_RECV_CONTROL)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_INVITE)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_CONNECTED)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_PEER_NAME)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_TITLE)
CASE_E_TYPE(TOX_EVENT_CONFERENCE_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_NAME)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_STATUS)
CASE_E_TYPE(TOX_EVENT_GROUP_TOPIC)
CASE_E_TYPE(TOX_EVENT_GROUP_PRIVACY_STATE)
CASE_E_TYPE(TOX_EVENT_GROUP_VOICE_STATE)
CASE_E_TYPE(TOX_EVENT_GROUP_TOPIC_LOCK)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_LIMIT)
CASE_E_TYPE(TOX_EVENT_GROUP_PASSWORD)
CASE_E_TYPE(TOX_EVENT_GROUP_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_PRIVATE_MESSAGE)
CASE_E_TYPE(TOX_EVENT_GROUP_CUSTOM_PACKET)
CASE_E_TYPE(TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET)
CASE_E_TYPE(TOX_EVENT_GROUP_INVITE)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_JOIN)
CASE_E_TYPE(TOX_EVENT_GROUP_PEER_EXIT)
CASE_E_TYPE(TOX_EVENT_GROUP_SELF_JOIN)
CASE_E_TYPE(TOX_EVENT_GROUP_JOIN_FAIL)
CASE_E_TYPE(TOX_EVENT_GROUP_MODERATION)
return "<unk>"; // TODO: add invalid event enum?
#undef CASE_E_TYPE
}

273
solanaceae/toxcore/tox_event_logger.cpp Normal file
View File

@ -0,0 +1,273 @@
#include "./tox_event_logger.hpp"
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Connected*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_CONNECTED) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Invite*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_INVITE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Message*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_MESSAGE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Peer_List_Changed*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Peer_Name*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_PEER_NAME) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Conference_Title*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_CONFERENCE_TITLE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_File_Chunk_Request* e) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FILE_CHUNK_REQUEST)
<< " frd:" << tox_event_file_chunk_request_get_friend_number(e)
<< " fnb:" << tox_event_file_chunk_request_get_file_number(e)
<< " pos:" << tox_event_file_chunk_request_get_position(e)
<< " len:" << tox_event_file_chunk_request_get_length(e)
<< "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_File_Recv* e) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FILE_RECV)
<< " frd:" << tox_event_file_recv_get_friend_number(e)
<< " fnb:" << tox_event_file_recv_get_file_number(e)
<< " fnm:" << std::string_view{reinterpret_cast<const char*>(tox_event_file_recv_get_filename(e)), tox_event_file_recv_get_filename_length(e)}
<< " sze:" << tox_event_file_recv_get_file_size(e)
<< " knd:" << tox_event_file_recv_get_kind(e)
<< "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_File_Recv_Chunk*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FILE_RECV_CHUNK) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_File_Recv_Control* e) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FILE_RECV_CONTROL)
<< " frd:" << tox_event_file_recv_control_get_friend_number(e)
<< " fnb:" << tox_event_file_recv_control_get_file_number(e)
<< " ctl:" << tox_event_file_recv_control_get_control(e)
<< "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Connection_Status*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_CONNECTION_STATUS) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Lossless_Packet*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_LOSSLESS_PACKET) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Lossy_Packet*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_LOSSY_PACKET) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Message*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_MESSAGE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Name*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_NAME) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Read_Receipt*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_READ_RECEIPT) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Request*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_REQUEST) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Status*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_STATUS) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Status_Message*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_STATUS_MESSAGE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Friend_Typing*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_FRIEND_TYPING) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Self_Connection_Status*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_SELF_CONNECTION_STATUS) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Peer_Name*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PEER_NAME) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Peer_Status*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PEER_STATUS) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Topic*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_TOPIC) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Privacy_State*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PRIVACY_STATE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Voice_State*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_VOICE_STATE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Topic_Lock*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_TOPIC_LOCK) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Peer_Limit*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PEER_LIMIT) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Password*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PASSWORD) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Message*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_MESSAGE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Private_Message*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PRIVATE_MESSAGE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Custom_Packet*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_CUSTOM_PACKET) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Custom_Private_Packet*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Invite*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_INVITE) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Peer_Join*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PEER_JOIN) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Peer_Exit* e) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_PEER_EXIT)
<< " grp:" << tox_event_group_peer_exit_get_group_number(e)
<< " per:" << tox_event_group_peer_exit_get_peer_id(e)
<< " xtp:" << tox_event_group_peer_exit_get_exit_type(e)
<< " nam:" << std::string_view{reinterpret_cast<const char*>(tox_event_group_peer_exit_get_name(e)), tox_event_group_peer_exit_get_name_length(e)}
<< " prt:" << std::string_view{reinterpret_cast<const char*>(tox_event_group_peer_exit_get_part_message(e)), tox_event_group_peer_exit_get_part_message_length(e)}
<< "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Self_Join*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_SELF_JOIN) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Join_Fail*) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_JOIN_FAIL) << "\n";
return false;
}
bool ToxEventLogger::onToxEvent(const Tox_Event_Group_Moderation* e) {
_out << "TOX_EVENT: " << tox_event_to_string(TOX_EVENT_GROUP_MODERATION)
<< " grp:" << tox_event_group_moderation_get_group_number(e)
<< " typ:" << tox_event_group_moderation_get_mod_type(e)
<< " src:" << tox_event_group_moderation_get_source_peer_id(e)
<< " trg:" << tox_event_group_moderation_get_target_peer_id(e)
<< "\n";
return false;
}
void ToxEventLogger::subscribeAll(ToxEventProviderI& tep) {
// TODO: loop + max event
tep.subscribe(this, TOX_EVENT_SELF_CONNECTION_STATUS);
tep.subscribe(this, TOX_EVENT_FRIEND_REQUEST);
tep.subscribe(this, TOX_EVENT_FRIEND_CONNECTION_STATUS);
tep.subscribe(this, TOX_EVENT_FRIEND_LOSSY_PACKET);
tep.subscribe(this, TOX_EVENT_FRIEND_LOSSLESS_PACKET);
tep.subscribe(this, TOX_EVENT_FRIEND_NAME);
tep.subscribe(this, TOX_EVENT_FRIEND_STATUS);
tep.subscribe(this, TOX_EVENT_FRIEND_STATUS_MESSAGE);
tep.subscribe(this, TOX_EVENT_FRIEND_MESSAGE);
tep.subscribe(this, TOX_EVENT_FRIEND_READ_RECEIPT);
tep.subscribe(this, TOX_EVENT_FRIEND_TYPING);
tep.subscribe(this, TOX_EVENT_FILE_CHUNK_REQUEST);
tep.subscribe(this, TOX_EVENT_FILE_RECV);
tep.subscribe(this, TOX_EVENT_FILE_RECV_CHUNK);
tep.subscribe(this, TOX_EVENT_FILE_RECV_CONTROL);
tep.subscribe(this, TOX_EVENT_CONFERENCE_INVITE);
tep.subscribe(this, TOX_EVENT_CONFERENCE_CONNECTED);
tep.subscribe(this, TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED);
tep.subscribe(this, TOX_EVENT_CONFERENCE_PEER_NAME);
tep.subscribe(this, TOX_EVENT_CONFERENCE_TITLE);
tep.subscribe(this, TOX_EVENT_CONFERENCE_MESSAGE);
tep.subscribe(this, TOX_EVENT_GROUP_PEER_NAME);
tep.subscribe(this, TOX_EVENT_GROUP_PEER_STATUS);
tep.subscribe(this, TOX_EVENT_GROUP_TOPIC);
tep.subscribe(this, TOX_EVENT_GROUP_PRIVACY_STATE);
tep.subscribe(this, TOX_EVENT_GROUP_VOICE_STATE);
tep.subscribe(this, TOX_EVENT_GROUP_TOPIC_LOCK);
tep.subscribe(this, TOX_EVENT_GROUP_PEER_LIMIT);
tep.subscribe(this, TOX_EVENT_GROUP_PASSWORD);
tep.subscribe(this, TOX_EVENT_GROUP_MESSAGE);
tep.subscribe(this, TOX_EVENT_GROUP_PRIVATE_MESSAGE);
tep.subscribe(this, TOX_EVENT_GROUP_CUSTOM_PACKET);
tep.subscribe(this, TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET);
tep.subscribe(this, TOX_EVENT_GROUP_INVITE);
tep.subscribe(this, TOX_EVENT_GROUP_PEER_JOIN);
tep.subscribe(this, TOX_EVENT_GROUP_PEER_EXIT);
tep.subscribe(this, TOX_EVENT_GROUP_SELF_JOIN);
tep.subscribe(this, TOX_EVENT_GROUP_JOIN_FAIL);
tep.subscribe(this, TOX_EVENT_GROUP_MODERATION);
}

63
solanaceae/toxcore/tox_event_logger.hpp Normal file
View File

@ -0,0 +1,63 @@
#pragma once
#include "./tox_event_interface.hpp"
#include <ostream>
struct ToxEventLogger : public ToxEventI {
std::ostream& _out;
ToxEventLogger(std::ostream& out) : _out(out) {}
~ToxEventLogger(void) {}
#define OVER_EVENT(x) bool onToxEvent(const x*) override;
OVER_EVENT(Tox_Event_Conference_Connected)
OVER_EVENT(Tox_Event_Conference_Invite)
OVER_EVENT(Tox_Event_Conference_Message)
OVER_EVENT(Tox_Event_Conference_Peer_List_Changed)
OVER_EVENT(Tox_Event_Conference_Peer_Name)
OVER_EVENT(Tox_Event_Conference_Title)
OVER_EVENT(Tox_Event_File_Chunk_Request)
OVER_EVENT(Tox_Event_File_Recv)
OVER_EVENT(Tox_Event_File_Recv_Chunk)
OVER_EVENT(Tox_Event_File_Recv_Control)
OVER_EVENT(Tox_Event_Friend_Connection_Status)
OVER_EVENT(Tox_Event_Friend_Lossless_Packet)
OVER_EVENT(Tox_Event_Friend_Lossy_Packet)
OVER_EVENT(Tox_Event_Friend_Message)
OVER_EVENT(Tox_Event_Friend_Name)
OVER_EVENT(Tox_Event_Friend_Read_Receipt)
OVER_EVENT(Tox_Event_Friend_Request)
OVER_EVENT(Tox_Event_Friend_Status)
OVER_EVENT(Tox_Event_Friend_Status_Message)
OVER_EVENT(Tox_Event_Friend_Typing)
OVER_EVENT(Tox_Event_Self_Connection_Status)
OVER_EVENT(Tox_Event_Group_Peer_Name)
OVER_EVENT(Tox_Event_Group_Peer_Status)
OVER_EVENT(Tox_Event_Group_Topic)
OVER_EVENT(Tox_Event_Group_Privacy_State)
OVER_EVENT(Tox_Event_Group_Voice_State)
OVER_EVENT(Tox_Event_Group_Topic_Lock)
OVER_EVENT(Tox_Event_Group_Peer_Limit)
OVER_EVENT(Tox_Event_Group_Password)
OVER_EVENT(Tox_Event_Group_Message)
OVER_EVENT(Tox_Event_Group_Private_Message)
OVER_EVENT(Tox_Event_Group_Custom_Packet)
OVER_EVENT(Tox_Event_Group_Custom_Private_Packet)
OVER_EVENT(Tox_Event_Group_Invite)
OVER_EVENT(Tox_Event_Group_Peer_Join)
OVER_EVENT(Tox_Event_Group_Peer_Exit)
OVER_EVENT(Tox_Event_Group_Self_Join)
OVER_EVENT(Tox_Event_Group_Join_Fail)
OVER_EVENT(Tox_Event_Group_Moderation)
#undef OVER_EVENT
void subscribeAll(ToxEventProviderI& tep);
};

76
solanaceae/toxcore/tox_event_provider_base.cpp Normal file
View File

@ -0,0 +1,76 @@
#include "./tox_event_provider_base.hpp"
void ToxEventProviderBase::dispatchEvents(const Tox_Events* events) {
if (events == nullptr) {
return;
}
// forward events to event handlers
// TODO: make order independent (construct string and lookup event id)
#define HANDLE_EVENT(x) \
for (size_t i = 0; i < tox_events_get_##x##_size(events); i++) { \
for (auto* tei : _subscribers.at(event_type_index)) { \
if (tei->onToxEvent(tox_events_get_##x(events, i))) { \
break; \
} \
} \
} \
event_type_index++;
size_t event_type_index = 0;
// IMPORTANT: the order defines the type
HANDLE_EVENT(self_connection_status);
HANDLE_EVENT(friend_request);
HANDLE_EVENT(friend_connection_status);
HANDLE_EVENT(friend_lossy_packet);
HANDLE_EVENT(friend_lossless_packet);
HANDLE_EVENT(friend_name);
HANDLE_EVENT(friend_status);
HANDLE_EVENT(friend_status_message);
HANDLE_EVENT(friend_message);
HANDLE_EVENT(friend_read_receipt);
HANDLE_EVENT(friend_typing);
HANDLE_EVENT(file_chunk_request);
HANDLE_EVENT(file_recv);
HANDLE_EVENT(file_recv_chunk);
HANDLE_EVENT(file_recv_control);
HANDLE_EVENT(conference_invite);
HANDLE_EVENT(conference_connected);
HANDLE_EVENT(conference_peer_list_changed);
HANDLE_EVENT(conference_peer_name);
HANDLE_EVENT(conference_title);
HANDLE_EVENT(conference_message);
HANDLE_EVENT(group_peer_name);
HANDLE_EVENT(group_peer_status);
HANDLE_EVENT(group_topic);
HANDLE_EVENT(group_privacy_state);
HANDLE_EVENT(group_voice_state);
HANDLE_EVENT(group_topic_lock);
HANDLE_EVENT(group_peer_limit);
HANDLE_EVENT(group_password);
HANDLE_EVENT(group_message);
HANDLE_EVENT(group_private_message);
HANDLE_EVENT(group_custom_packet);
HANDLE_EVENT(group_custom_private_packet);
HANDLE_EVENT(group_invite);
HANDLE_EVENT(group_peer_join);
HANDLE_EVENT(group_peer_exit);
HANDLE_EVENT(group_self_join);
HANDLE_EVENT(group_join_fail);
HANDLE_EVENT(group_moderation);
#undef HANDLE_EVENT
}
void ToxEventProviderBase::subscribe(ToxEventI* object, const Tox_Event event_type) {
_subscribers.at(event_type).push_back(object);
}

19
solanaceae/toxcore/tox_event_provider_base.hpp Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include "./tox_event_interface.hpp"
#include <vector>
#include <array>
// implements common code for tox event dispatching
struct ToxEventProviderBase : public ToxEventProviderI {
protected:
void dispatchEvents(const Tox_Events* events);
public: // event provider
virtual void subscribe(ToxEventI* object, const Tox_Event event_type) override;
protected:
std::array<std::vector<ToxEventI*>, 39> _subscribers; // rn 39 event types
};

15
solanaceae/toxcore/tox_interface.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "./tox_interface.hpp"
#include "./utils.hpp"
std::string ToxI_raw::toxSelfGetAddressStr(void) {
// TODO: cache
return bin2hex(toxSelfGetAddress());
}
std::vector<uint8_t> ToxI_raw::toxHash(const std::vector<uint8_t>& data) {
std::vector<uint8_t> hash(TOX_HASH_LENGTH);
tox_hash(hash.data(), data.data(), data.size()); // TODO: return value?
return hash;
}

225
solanaceae/toxcore/tox_interface.hpp Normal file
View File

@ -0,0 +1,225 @@
#pragma once
#include <tox/tox.h>
#include <string_view>
#include <vector>
#include <string>
#include <tuple>
#include <optional>
// TODO: c++20 span
// defines the full interface for tox
// HACK: raw
struct ToxI_raw {
virtual ~ToxI_raw(void) {}
// TODO: tox version
// size stuff
// options? (no)
// get save data?
// bootstrap
// add tcp relay
virtual Tox_Connection toxSelfGetConnectionStatus(void) = 0;
virtual uint32_t toxIterationInterval(void) = 0;
virtual std::vector<uint8_t> toxSelfGetAddress(void) = 0;
virtual std::string toxSelfGetAddressStr(void); // has default impl
virtual void toxSelfSetNospam(uint32_t nospam) = 0;
virtual uint32_t toxSelfGetNospam(void) = 0;
virtual std::vector<uint8_t> toxSelfGetPublicKey(void) = 0;
//virtual void toxSelfGetSecretKey(const Tox *tox, uint8_t *secret_key);
virtual Tox_Err_Set_Info toxSelfSetName(std::string_view name) = 0;
virtual std::string toxSelfGetName(void) = 0;
virtual Tox_Err_Set_Info toxSelfSetStatusMessage(std::string_view status_message) = 0;
virtual std::string toxSelfGetStatusMessage(void) = 0;
virtual void toxSelfSetStatus(Tox_User_Status status) = 0;
virtual Tox_User_Status toxSelfGetStatus(void) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> toxFriendAdd(const std::vector<uint8_t>& address, std::string_view message) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> toxFriendAddNorequest(const std::vector<uint8_t>& public_key) = 0;
virtual Tox_Err_Friend_Delete toxFriendDelete(uint32_t friend_number) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Friend_By_Public_Key> toxFriendByPublicKey(const std::vector<uint8_t>& public_key) = 0;
virtual bool toxFriendExists(uint32_t friend_number) = 0;
virtual size_t toxSelfGetFriendListSize(void) = 0;
virtual std::vector<uint32_t> toxSelfGetFriendList(void) = 0;
virtual std::optional<std::vector<uint8_t>> toxFriendGetPublicKey(uint32_t friend_number) = 0;
virtual std::optional<uint64_t> toxFriendGetLastOnline(uint32_t friend_number) = 0;
virtual std::optional<std::string> toxFriendGetName(uint32_t friend_number) = 0;
virtual std::optional<std::string> toxFriendGetStatusMessage(uint32_t friend_number) = 0;
virtual std::optional<Tox_User_Status> toxFriendGetStatus(uint32_t friend_number) = 0;
virtual std::optional<Tox_Connection> toxFriendGetConnectionStatus(uint32_t friend_number) = 0;
virtual std::optional<bool> toxFriendGetTyping(uint32_t friend_number) = 0;
virtual Tox_Err_Set_Typing toxSelfSetTyping(uint32_t friend_number, bool typing) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Send_Message> toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) = 0;
// files
// TODO: array? make it type agnostic?
virtual std::vector<uint8_t> toxHash(const std::vector<uint8_t>& data);
virtual Tox_Err_File_Control toxFileControl(uint32_t friend_number, uint32_t file_number, Tox_File_Control control) = 0;
virtual Tox_Err_File_Seek toxFileSeek(uint32_t friend_number, uint32_t file_number, uint64_t position) = 0;
virtual std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_File_Get> toxFileGetFileID(uint32_t friend_number, uint32_t file_number) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_File_Send> toxFileSend(uint32_t friend_number, uint32_t kind, uint64_t file_size, const std::vector<uint8_t>& file_id, std::string_view filename) = 0;
virtual Tox_Err_File_Send_Chunk toxFileSendChunk(uint32_t friend_number, uint32_t file_number, uint64_t position, const std::vector<uint8_t>& data) = 0;
// conferece
//bool tox_conference_delete(Tox *tox, uint32_t conference_number, Tox_Err_Conference_Delete *error);
//uint32_t tox_conference_peer_count(const Tox *tox, uint32_t conference_number, Tox_Err_Conference_Peer_Query *error);
//size_t tox_conference_peer_get_name_size(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
//bool tox_conference_peer_get_name(const Tox *tox, uint32_t conference_number, uint32_t peer_number, uint8_t *name,
//bool tox_conference_peer_get_public_key(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
//bool tox_conference_peer_number_is_ours(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
//uint32_t tox_conference_offline_peer_count(const Tox *tox, uint32_t conference_number,
//size_t tox_conference_offline_peer_get_name_size(const Tox *tox, uint32_t conference_number,
//bool tox_conference_offline_peer_get_name(const Tox *tox, uint32_t conference_number, uint32_t offline_peer_number,
//bool tox_conference_offline_peer_get_public_key(const Tox *tox, uint32_t conference_number,
//uint64_t tox_conference_offline_peer_get_last_active(const Tox *tox, uint32_t conference_number,
//bool tox_conference_set_max_offline(Tox *tox, uint32_t conference_number, uint32_t max_offline_peers, Tox_Err_Conference_Set_Max_Offline *error);
//bool tox_conference_invite(Tox *tox, uint32_t friend_number, uint32_t conference_number, Tox_Err_Conference_Invite *error);
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Conference_Join> toxConferenceJoin(uint32_t friend_number, const std::vector<uint8_t>& cookie) = 0;
virtual Tox_Err_Conference_Send_Message toxConferenceSendMessage(uint32_t conference_number, Tox_Message_Type type, std::string_view message) = 0;
//size_t tox_conference_get_title_size(const Tox *tox, uint32_t conference_number, Tox_Err_Conference_Title *error);
//bool tox_conference_get_title(const Tox *tox, uint32_t conference_number, uint8_t *title, Tox_Err_Conference_Title *error);
//bool tox_conference_set_title(Tox *tox, uint32_t conference_number, const uint8_t *title, size_t length, Tox_Err_Conference_Title *error);
//size_t tox_conference_get_chatlist_size(const Tox *tox);
//void tox_conference_get_chatlist(const Tox *tox, uint32_t *chatlist);
//Tox_Conference_Type tox_conference_get_type(const Tox *tox, uint32_t conference_number, Tox_Err_Conference_Get_Type *error);
//bool tox_conference_get_id(const Tox *tox, uint32_t conference_number, uint8_t *id);
//uint32_t tox_conference_by_id(const Tox *tox, const uint8_t *id, Tox_Err_Conference_By_Id *error);
//bool tox_conference_get_uid(const Tox *tox, uint32_t conference_number, uint8_t *uid);
//uint32_t tox_conference_by_uid(const Tox *tox, const uint8_t *uid, Tox_Err_Conference_By_Uid *error);
virtual Tox_Err_Friend_Custom_Packet toxFriendSendLossyPacket(uint32_t friend_number, const std::vector<uint8_t>& data) = 0;
virtual Tox_Err_Friend_Custom_Packet toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector<uint8_t>& data) = 0;
// dht
// udp
// tcp
// group
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Group_New> toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Group_Join> toxGroupJoin(const std::vector<uint8_t>& chat_id, std::string_view name, std::string_view password) = 0;
virtual std::optional<bool> toxGroupIsConnected(uint32_t group_number) = 0; // only 1 error type, skip
virtual Tox_Err_Group_Disconnect toxGroupDisconnect(uint32_t group_number) = 0;
virtual Tox_Err_Group_Reconnect toxGroupReconnect(uint32_t group_number) = 0;
virtual Tox_Err_Group_Leave toxGroupLeave(uint32_t group_number, std::string_view part_message) = 0;
virtual Tox_Err_Group_Self_Name_Set toxGroupSelfSetName(uint32_t group_number, std::string_view name) = 0;
virtual std::optional<std::string> toxGroupSelfGetName(uint32_t group_number) = 0; // only 1 error type, skip
virtual Tox_Err_Group_Self_Status_Set toxGroupSelfSetStatus(uint32_t group_number, Tox_User_Status status) = 0;
virtual std::optional<Tox_User_Status> toxGroupSelfGetStatus(uint32_t group_number) = 0;
virtual std::optional<Tox_Group_Role> toxGroupSelfGetRole(uint32_t group_number) = 0;
virtual std::optional<uint32_t> toxGroupSelfGetPeerId(uint32_t group_number) = 0;
virtual std::optional<std::vector<uint8_t>> toxGroupSelfGetPublicKey(uint32_t group_number) = 0;
virtual std::tuple<std::optional<std::string>, Tox_Err_Group_Peer_Query> toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) = 0;
virtual std::tuple<std::optional<Tox_User_Status>, Tox_Err_Group_Peer_Query> toxGroupPeerGetStatus(uint32_t group_number, uint32_t peer_id) = 0;
virtual std::tuple<std::optional<Tox_Group_Role>, Tox_Err_Group_Peer_Query> toxGroupPeerGetRole(uint32_t group_number, uint32_t peer_id) = 0;
virtual std::tuple<std::optional<Tox_Connection>, Tox_Err_Group_Peer_Query> toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) = 0;
virtual std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_Group_Peer_Query> toxGroupPeerGetPublicKey(uint32_t group_number, uint32_t peer_id) = 0;
virtual Tox_Err_Group_Topic_Set toxGroupSetTopic(uint32_t group_number, std::string_view topic) = 0;
virtual std::optional<std::string> toxGroupGetTopic(uint32_t group_number) = 0; // only 1 error type, skip
virtual std::optional<std::string> toxGroupGetName(uint32_t group_number) = 0; // only 1 error type, skip
virtual std::optional<std::vector<uint8_t>> toxGroupGetChatId(uint32_t group_number) = 0; // only 1 error type, skip
// TODO: str
//virtual uint32_t toxGroupGetNumberGroups(void) = 0;
virtual size_t toxGroupGetNumberGroups(void) = 0;
virtual std::vector<uint32_t> toxGroupGetList(void) = 0;
//virtual Tox_Group_Privacy_State toxGroupGetPrivacyState(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual Tox_Group_Voice_State toxGroupGetVoiceState(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual Tox_Group_Topic_Lock toxGroupGetTopicLock(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual uint16_t toxGroupGetPeerLimit(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
//virtual std::string toxGroupGetPassword(uint32_t group_number, Tox_Err_Group_State_Queries *error) = 0;
// returns message_id
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Group_Send_Message> toxGroupSendMessage(uint32_t group_number, Tox_Message_Type type, std::string_view message) = 0;
virtual Tox_Err_Group_Send_Private_Message toxGroupSendPrivateMessage(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, std::string_view message) = 0;
virtual Tox_Err_Group_Send_Custom_Packet toxGroupSendCustomPacket(uint32_t group_number, bool lossless, const std::vector<uint8_t>& data) = 0;
virtual Tox_Err_Group_Send_Custom_Private_Packet toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector<uint8_t>& data) = 0;
virtual Tox_Err_Group_Invite_Friend toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) = 0;
virtual std::tuple<std::optional<uint32_t>, Tox_Err_Group_Invite_Accept> toxGroupInviteAccept(uint32_t friend_number, const std::vector<uint8_t>& invite_data, std::string_view name, std::string_view password) = 0;
//virtual Tox_Err_Group_Founder_Set_Password toxGroupFounderSetPassword(uint32_t group_number, std::string_view password) = 0;
//virtual Tox_Err_Group_Founder_Set_Topic_Lock toxGroupFounderSetTopicLock(uint32_t group_number, Tox_Group_Topic_Lock topic_lock) = 0;
//virtual Tox_Err_Group_Founder_Set_Voice_State toxGroupFounderSetVoiceState(uint32_t group_number, Tox_Group_Voice_State voice_state) = 0;
//virtual Tox_Err_Group_Founder_Set_Privacy_State toxGroupFounderSetPrivacyState(uint32_t group_number, Tox_Group_Privacy_State privacy_state) = 0;
//virtual Tox_Err_Group_Founder_Set_Peer_Limit toxGroupFounderSetPeerLimit(uint32_t group_number, uint16_t max_peers) = 0;
//virtual Tox_Err_Group_Set_Ignore toxGroupSetIgnore(uint32_t group_number, uint32_t peer_id, bool ignore) = 0;
//virtual Tox_Err_Group_Mod_Set_Role toxGroupModSetRole(uint32_t group_number, uint32_t peer_id, Tox_Group_Role role) = 0;
//virtual Tox_Err_Group_Mod_Kick_Peer toxGroupModKickPeer(uint32_t group_number, uint32_t peer_id) = 0;
};
// HACK: work around zppbits inability to pass string_view as parameter ( https://github.com/eyalz800/zpp_bits/issues/107 )
struct ToxI : public ToxI_raw {
Tox_Err_Set_Info toxSelfSetName_str(const std::string& name) {
return toxSelfSetName(name);
}
Tox_Err_Set_Info toxSelfSetStatusMessage_str(const std::string& status_message) {
return toxSelfSetStatusMessage(status_message);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> toxFriendAdd_str(const std::vector<uint8_t>& address, const std::string& message) {
return toxFriendAdd(address, message);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Send_Message> toxFriendSendMessage_str(uint32_t friend_number, Tox_Message_Type type, const std::string& message) {
return toxFriendSendMessage(friend_number, type, message);
}
std::tuple<std::optional<uint32_t>, Tox_Err_File_Send> toxFileSend_str(uint32_t friend_number, uint32_t kind, uint64_t file_size, const std::vector<uint8_t>& file_id, const std::string& filename) {
return toxFileSend(friend_number, kind, file_size, file_id, filename);
}
Tox_Err_Conference_Send_Message toxConferenceSendMessage_str(uint32_t conference_number, Tox_Message_Type type, const std::string& message) {
return toxConferenceSendMessage(conference_number, type, message);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_New> toxGroupNew_str(Tox_Group_Privacy_State privacy_state, const std::string& group_name, const std::string& name) {
return toxGroupNew(privacy_state, group_name, name);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Join> toxGroupJoin_str(const std::vector<uint8_t>& chat_id, const std::string& name, const std::string& password) {
return toxGroupJoin(chat_id, name, password);
}
Tox_Err_Group_Leave toxGroupLeave_str(uint32_t group_number, const std::string& part_message) {
return toxGroupLeave(group_number, part_message);
}
Tox_Err_Group_Self_Name_Set toxGroupSelfSetName_str(uint32_t group_number, const std::string& name) {
return toxGroupSelfSetName(group_number, name);
}
Tox_Err_Group_Topic_Set toxGroupSetTopic_str(uint32_t group_number, const std::string& topic) {
return toxGroupSetTopic(group_number, topic);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Send_Message> toxGroupSendMessage_str(uint32_t group_number, Tox_Message_Type type, const std::string& message) {
return toxGroupSendMessage(group_number, type, message);
}
Tox_Err_Group_Send_Private_Message toxGroupSendPrivateMessage_str(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, const std::string& message) {
return toxGroupSendPrivateMessage(group_number, peer_id, type, message);
}
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Invite_Accept> toxGroupInviteAccept_str(uint32_t friend_number, const std::vector<uint8_t>& invite_data, const std::string& name, const std::string& password) {
return toxGroupInviteAccept(friend_number, invite_data, name, password);
}
};

23
solanaceae/toxcore/utils.cpp Normal file
View File

@ -0,0 +1,23 @@
#include "./utils.hpp"
#include <sodium.h>
std::vector<uint8_t> hex2bin(const std::string& str) {
std::vector<uint8_t> bin{};
bin.resize(str.size()/2, 0);
sodium_hex2bin(bin.data(), bin.size(), str.c_str(), str.length(), nullptr, nullptr, nullptr);
return bin;
}
std::string bin2hex(const std::vector<uint8_t>& bin) {
std::string str{};
str.resize(bin.size()*2, '?');
// HECK, std is 1 larger than size returns ('\0')
sodium_bin2hex(str.data(), str.size()+1, bin.data(), bin.size());
return str;
}

8
solanaceae/toxcore/utils.hpp Normal file
View File

@ -0,0 +1,8 @@
#pragma once
#include <string>
#include <vector>
std::vector<uint8_t> hex2bin(const std::string& str);
std::string bin2hex(const std::vector<uint8_t>& bin);