timoreo/matrix-3ds-sdk
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
matrix-3ds-sdk/source/matrixclient.cpp
timoreo 308b77f2c4
Start of thread-safty
2023-12-11 16:06:09 +01:00

1087 lines
33 KiB
C++
Raw Blame History

#include <3ds.h>
#include <curl/curl.h>
#include <jansson.h>
#include <malloc.h>
#include <matrixclient.h>
#include <olm/olm.h>
#include <stdio.h>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <map>
#include <olm/account.hh>
#include <string>
#include <vector>
#include "memorystore.h"
#include "olm/base64.hh"
#include "util.h"
#include <sys/socket.h>
#define SOC_ALIGN 0x1000
#define SOC_BUFFERSIZE 0x100000
#define SYNC_TIMEOUT 10000
#if DEBUG
#define D
#else
#define D for(;0;)
#endif
#if DEBUG
PrintConsole* topScreenDebugConsole = NULL;
#endif
#if DEBUG
#define printf_top(f_, ...) do {consoleSelect(topScreenDebugConsole);printf((f_), ##__VA_ARGS__);} while(0)
#else
#define printf_top(f_, ...) do {} while(0)
#endif
namespace Matrix {
#define POST_BUFFERSIZE 0x100000
static u32 *SOC_buffer = NULL;
bool HTTPC_inited = false;
bool haveHttpcSupport = false;
Client::Client(std::string homeserverUrl, std::string matrixToken, Store* clientStore) {
hsUrl = homeserverUrl;
token = matrixToken;
if (!clientStore) {
clientStore = new MemoryStore;
}
store = clientStore;
#if DEBUG
if (!topScreenDebugConsole) {
topScreenDebugConsole = new PrintConsole;
consoleInit(GFX_TOP, topScreenDebugConsole);
}
#endif
}
std::string Client::getToken() const {
return token;
}
bool Client::login(std::string username, std::string password, std::string device_id) {
json_t* request = json_object();
json_object_set_new(request, "type", json_string("m.login.password"));
json_t* identifier = json_object();
json_object_set_new(identifier, "type", json_string("m.id.user"));
json_object_set_new(identifier, "user", json_string(username.c_str()));
json_object_set_new(request, "identifier", identifier);
json_object_set_new(request, "password", json_string(password.c_str()));
json_object_set_new(request, "initial_device_display_name", json_string("Nintendo 3DS"));
if(!device_id.empty()) {
json_object_set_new(request, "device_id", json_string(device_id.c_str()));
}
json_t* ret = doRequest("POST", "/_matrix/client/v3/login", request);
json_decref(request);
printf_top("Result : %s\n" ,json_dumps(ret, JSON_ENSURE_ASCII | JSON_ESCAPE_SLASH));
const char* tokenCStr = json_object_get_string_value(ret, "access_token");
if (!tokenCStr) {
if (ret) json_decref(ret);
return false;
}
token = tokenCStr;
json_decref(ret);
return true;
}
void Client::logout() {
json_t* ret = doRequest("POST", "/_matrix/client/v3/logout");
if (ret) {
json_decref(ret);
}
}
std::string Client::getUserId() {
if (!userIdCache.empty()) {
return userIdCache;
}
json_t* ret = doRequest("GET", "/_matrix/client/v3/account/whoami");
const char* userIdCStr = json_object_get_string_value(ret, "user_id");
if (!userIdCStr) {
if (ret) json_decref(ret);
return "";
}
const char* deviceIdCStr = json_object_get_string_value(ret, "device_id");
std::string deviceIdStr = deviceIdCStr;
std::string userIdStr = userIdCStr;
json_decref(ret);
userIdCache = std::string(userIdStr);
deviceIdCache = std::string(deviceIdStr);
return userIdCache;
}
std::string Client::getDeviceId() {
if(!deviceIdCache.empty()){
return deviceIdCache;
}
json_t* ret = doRequest("GET", "/_matrix/client/v3/account/whoami");
const char* userIdCStr = json_object_get_string_value(ret, "user_id");
if (!userIdCStr) {
if (ret) json_decref(ret);
return "";
}
const char* deviceIdCStr = json_object_get_string_value(ret, "device_id");
std::string deviceIdStr = deviceIdCStr;
std::string userIdStr = userIdCStr;
json_decref(ret);
userIdCache = std::string(userIdStr);
deviceIdCache = std::string(deviceIdStr);
return deviceIdCache;
}
std::string Client::resolveRoom(std::string alias) {
if (alias[0] == '!') {
return alias; // this is already a room ID, nothing to do
}
json_t* ret = doRequest("GET", "/_matrix/client/v3/directory/room/" + urlencode(alias));
const char* roomIdCStr = json_object_get_string_value(ret, "room_id");
if (!roomIdCStr) {
if (ret) json_decref(ret);
return "";
}
std::string roomIdStr = roomIdCStr;
printf_top("Room ID: %s\n", roomIdStr.c_str());
json_decref(ret);
return roomIdStr;
}
std::vector<std::string> Client::getJoinedRooms() {
std::vector<std::string> rooms;
json_t* ret = doRequest("GET", "/_matrix/client/v3/joined_rooms");
json_t* roomsArr = json_object_get(ret, "joined_rooms");
if (!roomsArr) {
json_decref(ret);
return rooms;
}
size_t index;
json_t* value;
json_array_foreach(roomsArr, index, value) {
const char* val = json_string_value(value);
if (val) {
rooms.push_back(val);
}
}
json_decref(ret);
return rooms;
}
RoomInfo Client::getRoomInfo(std::string roomId) {
// if we resolve the roomId here it only resolves once
roomId = resolveRoom(roomId);
RoomInfo info = {
getRoomName(roomId),
getRoomTopic(roomId),
getRoomAvatar(roomId),
};
return info;
}
ExtraRoomInfo Client::getExtraRoomInfo(std::string roomId) {
roomId = resolveRoom(roomId);
ExtraRoomInfo info;
info.canonicalAlias = getCanonicalAlias(roomId);
// next fetch the members
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/joined_members";
json_t* ret = doRequest("GET", path);
if (!ret) {
return info;
}
json_t* joined = json_object_get(ret, "joined");
if (!joined || json_typeof(joined) != JSON_OBJECT) {
json_decref(ret);
return info;
}
const char* mxid;
json_t* member;
json_object_foreach(joined, mxid, member) {
const char* displayname = json_object_get_string_value(member, "display_name");
const char* avatarUrl = json_object_get_string_value(member, "avatar_url");
MemberInfo memInfo;
if (displayname) {
memInfo.displayname = displayname;
}
if (avatarUrl) {
memInfo.avatarUrl = avatarUrl;
}
info.members[mxid] = memInfo;
}
json_decref(ret);
return info;
}
MemberInfo Client::getMemberInfo(std::string userId, std::string roomId) {
std::string displayname = "";
std::string avatarUrl = "";
if (roomId != "") {
// first try fetching fro the room
json_t* ret = getStateEvent(roomId, "m.room.member", userId);
if (ret) {
char* valCStr;
valCStr = json_object_get_string_value(ret, "displayname");
if (valCStr) {
displayname = valCStr;
}
valCStr = json_object_get_string_value(ret, "avatar_url");
if (valCStr) {
avatarUrl = valCStr;
}
json_decref(ret);
}
}
if (displayname == "") {
// then attempt the account
std::string path = "/_matrix/client/v3/profile/" + urlencode(userId);
json_t* ret = doRequest("GET", path);
if (ret) {
char* valCStr;
valCStr = json_object_get_string_value(ret, "displayname");
if (valCStr) {
displayname = valCStr;
}
valCStr = json_object_get_string_value(ret, "avatar_url");
if (valCStr) {
avatarUrl = valCStr;
}
json_decref(ret);
}
}
MemberInfo info = {
displayname,
avatarUrl,
};
return info;
}
std::string Client::getRoomName(std::string roomId) {
json_t* ret = getStateEvent(roomId, "m.room.name", "");
const char* nameCStr = json_object_get_string_value(ret, "name");
if (!nameCStr) {
if (ret) json_decref(ret);
return "";
}
std::string nameStr = nameCStr;
json_decref(ret);
return nameStr;
}
std::string Client::getRoomTopic(std::string roomId) {
json_t* ret = getStateEvent(roomId, "m.room.topic", "");
const char* topicCStr = json_object_get_string_value(ret, "topic");
if (!topicCStr) {
if (ret) json_decref(ret);
return "";
}
std::string topicStr = topicCStr;
json_decref(ret);
return topicStr;
}
std::string Client::getRoomAvatar(std::string roomId) {
json_t* ret = getStateEvent(roomId, "m.room.avatar", "");
const char* urlCStr = json_object_get_string_value(ret, "url");
if (!urlCStr) {
if (ret) json_decref(ret);
return "";
}
std::string urlStr = urlCStr;
json_decref(ret);
return urlStr;
}
std::string Client::getCanonicalAlias(std::string roomId) {
json_t* ret = getStateEvent(roomId, "m.room.canonical_alias", "");
const char* aliasCStr = json_object_get_string_value(ret, "alias");
if (!aliasCStr) {
if (ret) json_decref(ret);
return "";
}
std::string aliasStr = aliasCStr;
json_decref(ret);
return aliasStr;
}
void Client::sendReadReceipt(std::string roomId, std::string eventId) {
roomId = resolveRoom(roomId);
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/receipt/m.read/" + urlencode(eventId);
json_t* ret = doRequest("POST", path);
if (ret) {
json_decref(ret);
}
}
void Client::uploadKeys(json_t* body) {
std::string path = "/_matrix/client/v3/keys/upload";
/*char* jj = json_dumps(body, 0);
printf_top("%s\n", jj);
free(jj);*/
json_t* ret = doRequest("POST", path, body);
if (ret) {
/*char* j = json_dumps(ret, 0);
printf_top("%s\n",j);
free(j);*/
json_decref(ret);
}
}
void Client::setTyping(std::string roomId, bool typing, u32 timeout) {
roomId = resolveRoom(roomId);
std::string userId = getUserId();
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/typing/" + urlencode(userId);
json_t* request = json_object();
json_object_set_new(request, "typing", json_boolean(typing));
json_object_set_new(request, "timeout", json_integer(timeout));
json_t* ret = doRequest("PUT", path, request);
json_decref(request);
json_decref(ret);
}
std::string Client::sendEmote(std::string roomId, std::string text) {
json_t* request = json_object();
json_object_set_new(request, "msgtype", json_string("m.emote"));
json_object_set_new(request, "body", json_string(text.c_str()));
std::string eventId = sendMessage(roomId, request);
json_decref(request);
return eventId;
}
std::string Client::sendNotice(std::string roomId, std::string text) {
json_t* request = json_object();
json_object_set_new(request, "msgtype", json_string("m.notice"));
json_object_set_new(request, "body", json_string(text.c_str()));
std::string eventId = sendMessage(roomId, request);
json_decref(request);
return eventId;
}
std::string Client::sendText(std::string roomId, std::string text) {
json_t* request = json_object();
json_object_set_new(request, "msgtype", json_string("m.text"));
json_object_set_new(request, "body", json_string(text.c_str()));
std::string eventId = sendMessage(roomId, request);
json_decref(request);
return eventId;
}
std::string Client::sendMessage(std::string roomId, json_t* content) {
return sendEvent(roomId, "m.room.message", content);
}
void Client::sendEventToDevice(const std::string& eventType, json_t* content){
std::string txid = std::to_string(time(nullptr)) + "_REQ_" + std::to_string(requestId++);
std::string path = "/_matrix/client/v3/sendToDevice/" + urlencode(eventType) + "/" + urlencode(txid);
json_t* messages = json_object();
json_object_set(messages, "messages", content);
json_t* ret = doRequest("PUT", path, messages, 5, nullptr, false);
json_decref(messages);
if (ret) json_decref(ret);
}
std::string Client::sendEvent(std::string roomId, std::string eventType, json_t* content) {
roomId = resolveRoom(roomId);
std::string txid = std::to_string(time(NULL)) + "_REQ_" + std::to_string(requestId++);
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/send/" + urlencode(eventType) + "/" + urlencode(txid);
json_t* ret = doRequest("PUT", path, content, 5, nullptr, false);
const char* eventIdCStr = json_object_get_string_value(ret, "event_id");
if (!eventIdCStr) {
if (ret) json_decref(ret);
return "";
}
std::string eventIdStr = eventIdCStr;
json_decref(ret);
return eventIdStr;
}
json_t* Client::getStateEvent(std::string roomId, std::string type, std::string stateKey) {
roomId = resolveRoom(roomId);
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/state/" + urlencode(type) + "/" + urlencode(stateKey);
return doRequest("GET", path);
}
std::string Client::sendStateEvent(std::string roomId, std::string type, std::string stateKey, json_t* content) {
roomId = resolveRoom(roomId);
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/state/" + urlencode(type) + "/" + urlencode(stateKey);
json_t* ret = doRequest("PUT", path, content);
const char* eventIdCStr = json_object_get_string_value(ret, "event_id");
if (!eventIdCStr) {
if (ret) json_decref(ret);
return "";
}
std::string eventIdStr = eventIdCStr;
json_decref(ret);
return eventIdStr;
}
std::string Client::redactEvent(std::string roomId, std::string eventId, std::string reason) {
roomId = resolveRoom(roomId);
std::string txid = std::to_string(time(NULL)) + "_REQ_" + std::to_string(requestId++);
json_t* content = json_object();
if (!reason.empty()) {
json_object_set_new(content, "reason", json_string(reason.c_str()));
}
std::string path = "/_matrix/client/v3/rooms/" + urlencode(roomId) + "/redact/" + urlencode(eventId) + "/" + txid;
json_t* ret = doRequest("PUT", path, content, 5, nullptr, false);
json_decref(content);
const char* eventIdCStr = json_object_get_string_value(ret, "event_id");
if (!eventIdCStr) {
if (ret) json_decref(ret);
return "";
}
std::string eventIdStr = eventIdCStr;
json_decref(ret);
return eventIdStr;
}
void startSyncLoopWithoutClass(void* arg) {
((Client*)arg)->syncLoop();
}
void Client::startSyncLoop() {
stopSyncLoop(); // first we stop an already running sync loop
isSyncing = true;
stopSyncing = false;
s32 prio = 0;
svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
syncThread = threadCreate(startSyncLoopWithoutClass, this, 8*1024, prio-1, -2, true);
}
void Client::stopSyncLoop() {
stopSyncing = true;
if (isSyncing) {
threadJoin(syncThread, U64_MAX);
threadFree(syncThread);
}
isSyncing = false;
}
void Client::setEventCallback(eventCallback cb) {
callbacks.event = cb;
}
void Client::setLeaveRoomCallback(eventCallback cb) {
callbacks.leaveRoom = cb;
}
void Client::setInviteRoomCallback(eventCallback cb) {
callbacks.inviteRoom = cb;
}
void Client::setRoomInfoCallback(roomInfoCallback cb) {
callbacks.roomInfo = cb;
}
void Client::setRoomLimitedCallback(roomLimitedCallback cb) {
callbacks.roomLimited = cb;
}
void Client::processSync(json_t* sync) {
json_t* rooms = json_object_get(sync, "rooms");
if (!rooms) {
return; // nothing to do
}
json_t* leftRooms = json_object_get(rooms, "leave");
json_t* invitedRooms = json_object_get(rooms, "invite");
json_t* joinedRooms = json_object_get(rooms, "join");
const char* roomId;
json_t* room;
size_t index;
json_t* event;
if (leftRooms && callbacks.leaveRoom) {
json_object_foreach(leftRooms, roomId, room) {
// rooms that we left
json_t* timeline = json_object_get(room, "timeline");
if (!timeline) {
continue;
}
json_t* events = json_object_get(timeline, "events");
if (!events) {
continue;
}
json_t* leaveEvent = NULL;
json_array_foreach(events, index, event) {
// check if the event type is m.room.member
char* val;
val = json_object_get_string_value(event, "type");
if (!val) {
continue;
}
if (strcmp(val, "m.room.member") != 0) {
continue;
}
// check if it is actually us
val = json_object_get_string_value(event, "state_key");
if (!val) {
continue;
}
if (strcmp(val, getUserId().c_str()) != 0) {
continue;
}
// we do *not* check for event age as we don't have unsigned stuffs in our timeline due to our filter
// so we just assume that the events arrive in the correct order (probably true)
leaveEvent = event;
}
if (!leaveEvent) {
printf_top("Left room %s without an event\n", roomId);
continue;
}
callbacks.leaveRoom(roomId, leaveEvent);
}
}
if (invitedRooms && callbacks.inviteRoom) {
json_object_foreach(invitedRooms, roomId, room) {
// rooms that we were invited to
json_t* invite_state = json_object_get(room, "invite_state");
if (!invite_state) {
continue;
}
json_t* events = json_object_get(invite_state, "events");
if (!events) {
continue;
}
json_t* inviteEvent = NULL;
json_array_foreach(events, index, event) {
// check if the event type is m.room.member
char* val;
val = json_object_get_string_value(event, "type");
if (!val) {
continue;
}
if (strcmp(val, "m.room.member") != 0) {
continue;
}
// check if it is actually us
val = json_object_get_string_value(event, "state_key");
if (!val) {
continue;
}
if (strcmp(val, getUserId().c_str()) != 0) {
continue;
}
// check for if it was an invite event
json_t* content = json_object_get(event, "content");
if (!content) {
continue;
}
val = json_object_get_string_value(content, "membership");
if (!val) {
continue;
}
if (strcmp(val, "invite") != 0) {
continue;
}
// we do *not* check for event age as we don't have unsigned stuffs in our timeline due to our filter
// so we just assume that the events arrive in the correct order (probably true)
inviteEvent = event;
}
if (!inviteEvent) {
printf_top("Invite to room %s without an event\n", roomId);
continue;
}
callbacks.inviteRoom(roomId, inviteEvent);
}
}
if (joinedRooms) {
json_object_foreach(joinedRooms, roomId, room) {
// rooms that we are joined
json_t* state = json_object_get(room, "state");
if (callbacks.roomInfo && state) {
json_t* events = json_object_get(state, "events");
if (events) {
RoomInfo info;
bool addedInfo = false;
json_array_foreach(events, index, event) {
const char* typeCStr = json_object_get_string_value(event, "type");
if (!typeCStr) {
continue;
}
json_t* content = json_object_get(event, "content");
if (!content) {
continue;
}
if (strcmp(typeCStr, "m.room.name") == 0) {
const char* nameCStr = json_object_get_string_value(content, "name");
if (nameCStr) {
info.name = nameCStr;
addedInfo = true;
}
} else if (strcmp(typeCStr, "m.room.topic") == 0) {
const char* topicCStr = json_object_get_string_value(content, "topic");
if (topicCStr) {
info.topic = topicCStr;
addedInfo = true;
}
} else if (strcmp(typeCStr, "m.room.avatar") == 0) {
const char* urlCStr = json_object_get_string_value(content, "url");
if (urlCStr) {
info.avatarUrl = urlCStr;
addedInfo = true;
}
}
}
if (addedInfo) {
callbacks.roomInfo(roomId, info);
}
}
}
json_t* timeline = json_object_get(room, "timeline");
if (callbacks.roomLimited && timeline) {
json_t* limited = json_object_get(timeline, "limited");
const char* prevBatch = json_object_get_string_value(timeline, "prev_batch");
if (limited && prevBatch && json_typeof(limited) == JSON_TRUE) {
callbacks.roomLimited(roomId, prevBatch);
}
}
if (callbacks.event && timeline) {
json_t* events = json_object_get(timeline, "events");
if (events) {
json_array_foreach(events, index, event) {
callbacks.event(roomId, event);
}
}
}
}
}
}
void Client::registerFilter() {
static const char *json =
"{"
" \"account_data\": {"
" \"types\": ["
" \"m.direct\""
" ]"
" },"
" \"presence\": {"
" \"limit\": 0,"
" \"types\": [\"none\"]"
" },"
" \"room\": {"
" \"account_data\": {"
" \"limit\": 0,"
" \"types\": [\"none\"]"
" },"
" \"ephemeral\": {"
" \"limit\": 0,"
" \"types\": []"
" },"
" \"state\": {"
" \"limit\": 3,"
" \"types\": ["
" \"m.room.name\","
" \"m.room.topic\","
" \"m.room.avatar\""
" ]"
" },"
" \"timeline\": {"
" \"limit\": 10,"
" \"lazy_load_members\": true"
" }"
" },"
" \"event_format\": \"client\","
" \"event_fields\": ["
" \"type\","
" \"content\","
" \"sender\","
" \"state_key\","
" \"event_id\","
" \"origin_server_ts\","
" \"redacts\""
" ]"
"}";
json_error_t error;
json_t* filter = json_loads(json, 0, &error);
if (!filter) {
printf_top("PANIC!!!!! INVALID FILTER JSON!!!!\n");
printf_top("%s\n", error.text);
printf_top("At %d:%d (%d)\n", error.line, error.column, error.position);
return;
}
std::string userId = getUserId();
json_t* ret = doRequest("POST", "/_matrix/client/v3/user/" + urlencode(userId) + "/filter", filter);
json_decref(filter);
const char* filterIdCStr = json_object_get_string_value(ret, "filter_id");
if (!filterIdCStr) {
if (ret) json_decref(ret);
return;
}
std::string filterIdStr = filterIdCStr;
json_decref(ret);
store->setFilterId(filterIdStr);
}
void Client::syncLoop() {
u32 timeout = 60;
while (true) {
if (stopSyncing) {
return;
}
std::string token = store->getSyncToken();
std::string filterId = store->getFilterId();
if (filterId == "") {
registerFilter();
filterId = store->getFilterId();
}
CURLcode res;
json_t* ret = doSync(token, filterId, timeout, &res);
if (ret) {
timeout = 60;
// set the token for the next batch
const char* tokenCStr = json_object_get_string_value(ret, "next_batch");
if (tokenCStr) {
store->setSyncToken(tokenCStr);
} else {
store->setSyncToken("");
}
processSync(ret);
json_decref(ret);
} else {
if (res == CURLE_OPERATION_TIMEDOUT) {
timeout += 10*60;
printf_top("Timeout reached, increasing it to %lu\n", timeout);
}
}
svcSleepThread((u64)1000000ULL * (u64)200);
}
}
json_t* Client::doSync(std::string token, std::string filter, u32 timeout, CURLcode* res) {
// printf_top("Doing sync with token %s\n", token.c_str());
std::string query = "?full_state=false&timeout=" + std::to_string(SYNC_TIMEOUT) + "&filter=" + urlencode(filter);
if (token != "") {
query += "&since=" + token;
}
return doRequest("GET", "/_matrix/client/v3/sync" + query, NULL, timeout, res);
}
size_t DoRequestWriteCallback(char *contents, size_t size, size_t nmemb, void *userp) {
// printf_top("----\n%s\n", ((std::string*)userp)->c_str());
((std::string*)userp)->append((char*)contents, size * nmemb);
return size * nmemb;
}
bool doingCurlRequest = false;
bool doingHttpcRequest = false;
json_t* Client::doRequest(const char* method, std::string path, json_t* body, u32 timeout, CURLcode* retRes, bool needsRequest) {
std::string url = hsUrl + path;
if(needsRequest) {
requestId++;
}
return doRequestCurl(method, url, body, timeout, retRes);
}
CURLM* curl_multi_handle;
std::map<CURLM*, CURLcode> curl_handles_done;
Thread curl_multi_loop_thread;
void curl_multi_loop(void* p) {
int openHandles = 0;
while(true) {
CURLMcode mc = curl_multi_perform(curl_multi_handle, &openHandles);
if (mc != CURLM_OK) {
printf_top("curl multi fail: %u\n", mc);
}
// curl_multi_wait(curl_multi_handle, NULL, 0, 1000, &openHandles);
CURLMsg* msg;
int msgsLeft;
while ((msg = curl_multi_info_read(curl_multi_handle, &msgsLeft))) {
if (msg->msg == CURLMSG_DONE) {
curl_handles_done[msg->easy_handle] = msg->data.result;
}
}
if (!openHandles) {
svcSleepThread((u64)1000000ULL * 100);
}
}
}
json_t* Client::doRequestCurl(const char* method, std::string url, json_t* body, u32 timeout, CURLcode* retRes) {
// printf_top("Opening Request %d with CURL\n%s\n", requestId, url.c_str());
if (!SOC_buffer) {
SOC_buffer = (u32*)memalign(0x1000, POST_BUFFERSIZE);
if (!SOC_buffer) {
return NULL;
}
if (socInit(SOC_buffer, POST_BUFFERSIZE) != 0) {
return NULL;
}
curl_multi_handle = curl_multi_init();
s32 prio = 0;
svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
curl_multi_loop_thread = threadCreate(curl_multi_loop, NULL, 8*1024, prio-1, -2, true);
}
CURL* curl = curl_easy_init();
if (!curl) {
printf_top("curl init failed\n");
return NULL;
}
std::string readBuffer;
struct curl_slist* headers = NULL;
if (token != "") {
headers = curl_slist_append(headers, ("Authorization: Bearer " + token).c_str());
}
char* bodyStr = NULL;
if (body) {
headers = curl_slist_append(headers, "Content-Type: application/json");
bodyStr = json_dumps(body, JSON_ENSURE_ASCII | JSON_ESCAPE_SLASH);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, bodyStr);
}
curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 102400L);
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
curl_easy_setopt(curl, CURLOPT_USERAGENT, "3ds");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, (long)CURL_HTTP_VERSION_2TLS);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, DoRequestWriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
curl_multi_add_handle(curl_multi_handle, curl);
while (curl_handles_done.count(curl) == 0) {
svcSleepThread((u64)1000000ULL * 1);
}
CURLcode res = curl_handles_done[curl];
curl_handles_done.erase(curl);
curl_multi_remove_handle(curl_multi_handle, curl);
// curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
// curl_easy_setopt(curl, CURLOPT_STDERR, stdout);
curl_easy_cleanup(curl);
if (bodyStr) free(bodyStr);
if (retRes) *retRes = res;
if (res != CURLE_OK) {
printf_top("curl res not ok %d\n", res);
return NULL;
}
// printf_top("++++\n%s\n", readBuffer.c_str());
// printf_top("Body size: %d\n", readBuffer.length());
json_error_t error;
json_t* content = json_loads(readBuffer.c_str(), 0, &error);
if (!content) {
printf_top("Failed to parse json\n");
return NULL;
}
return content;
}
void Client::print_json(json_t *json){
char* data = json_dumps(json, 0);
puts(data);
free(data);
}
void Client::generate_otk(size_t otkcount) {
size_t len = acc.generate_one_time_keys_random_length(otkcount);
std::unique_ptr<uint8_t[]> otkrandom = std::make_unique<uint8_t[]>(len);
PS_GenerateRandomBytes(otkrandom.get(), len);
acc.generate_one_time_keys(otkcount, otkrandom.get(), len);
}
void Client::generate_otk() {
size_t otkcount = acc.max_number_of_one_time_keys() / 2;
generate_otk(otkcount);
}
void Client::generate_device_key() {
size_t len = acc.new_account_random_length();
std::unique_ptr<uint8_t[]> random = std::make_unique<uint8_t[]>(len);
PS_GenerateRandomBytes(random.get(), len);
acc.new_account(random.get(), len);
}
void Client::generate_fallback_key() {
size_t len = acc.generate_fallback_key_random_length();
std::unique_ptr<uint8_t[]> random = std::make_unique<uint8_t[]>(len);
PS_GenerateRandomBytes(random.get(), len);
acc.generate_fallback_key(random.get(), len);
}
// Make sure to remove any unsigned and signatures block before doing this !
void Client::sign_json(json_t* json) {
puts("Signing json");
char* jsonStr = json_dumps(json, JSON_COMPACT | JSON_SORT_KEYS);
size_t signlen = acc.signature_length();
size_t ptrlen = olm::encode_base64_length(signlen);
std::unique_ptr<uint8_t[]> signature = std::make_unique<uint8_t[]>(ptrlen);
acc.sign(reinterpret_cast<const uint8_t*>(jsonStr), strlen(jsonStr), signature.get() + ptrlen - signlen, signlen);
free(jsonStr);
olm::encode_base64(signature.get() + ptrlen - signlen, signlen, signature.get());
json_t* signitem = json_object();
std::cout << std::string(reinterpret_cast<const char*>(signature.get()), ptrlen) << std::endl;
json_object_set_new(signitem, ("ed25519:" + getDeviceId()).c_str(), json_stringn(reinterpret_cast<const char*>(signature.get()), ptrlen));
json_t* signobj = json_object();
json_object_set_new(signobj, getUserId().c_str(), signitem);
json_object_set_new(json, "signatures", signobj);
}
json_t* Client::get_device_keys() {
json_t* device_keys = json_object();
json_t* algorithms = json_array();
json_array_append_new(algorithms, json_string("m.olm.v1.curve25519-aes-sha2"));
json_array_append_new(algorithms, json_string("m.megolm.v1.aes-sha2"));
json_object_set_new(device_keys, "algorithms", algorithms);
json_object_set_new(device_keys, "device_id", json_string(getDeviceId().c_str()));
json_object_set_new(device_keys, "user_id", json_string(getUserId().c_str()));
// Extract keys
size_t acclen = acc.get_identity_json_length();
std::unique_ptr<uint8_t[]> acckeys = std::make_unique<uint8_t[]>(acclen);
size_t bytes = acc.get_identity_json(acckeys.get(), acclen);
std::cout << "Parsing bytes" << std::endl;
json_error_t error;
sleep(5);
std::cout << "Heading into it..." << std::endl;
json_t* keys = json_loadb(reinterpret_cast<const char*>(acckeys.get()), bytes, 0, &error);
if (keys == nullptr) {
printf("error: on line %d at char %d: %s\n", error.line, error.column, error.text);
sleep(10);
}
std::cout << "Reloaded data" << std::endl;
std::cout << "Adding bits" << std::endl;
// Merge keys
json_object_set(device_keys, ("ed25519:" + getDeviceId()).c_str(), json_object_get(keys, "ed25519"));
json_object_set(device_keys, ("curve25519:" + getDeviceId()).c_str(), json_object_get(keys, "curve25519"));
json_decref(keys);
std::cout << "Finalizing" << std::endl;
return device_keys;
}
json_t* Client::get_fallback_keys() {
json_t* fallback_keys = json_object();
// Extract keys
size_t acclen = acc.get_unpublished_fallback_key_json_length();
auto acckeys = std::make_unique<uint8_t[]>(acclen);
size_t bytes = acc.get_unpublished_fallback_key_json(acckeys.get(), acclen);
json_t* keys = json_loadb(reinterpret_cast<const char*>(acckeys.get()), bytes, 0, nullptr);
json_t* keyobj = json_object_get(keys, "curve25519");
void* iter = json_object_iter(keyobj);
while (iter != nullptr) {
const char* keyid = json_object_iter_key(iter);
json_t* keyval = json_object_iter_value(iter);
json_t* tosign = json_object();
json_object_set(tosign, "key", keyval);
// object is fallback key
json_object_set_new(tosign, "fallback", json_true());
sign_json(tosign);
json_object_set(fallback_keys, (std::string("signed_curve25519:") + keyid).c_str(), tosign);
iter = json_object_iter_next(keyobj, iter);
}
json_decref(keys);
return fallback_keys;
}
json_t* Client::get_unpublished_otk() {
json_t* otk_keys = json_object();
// Extract keys
size_t acclen = acc.get_one_time_keys_json_length();
auto acckeys = std::make_unique<uint8_t[]>(acclen);
size_t bytes = acc.get_one_time_keys_json(acckeys.get(), acclen);
json_t* keys = json_loadb(reinterpret_cast<const char*>(acckeys.get()), bytes, 0, nullptr);
json_t* keyobj = json_object_get(keys, "curve25519");
void* iter = json_object_iter(keyobj);
while (iter != nullptr) {
const char* keyid = json_object_iter_key(iter);
json_t* keyval = json_object_iter_value(iter);
json_t* tosign = json_object();
json_object_set(tosign, "key", keyval);
sign_json(tosign);
json_object_set(otk_keys, (std::string("signed_curve25519:") + keyid).c_str(), tosign);
iter = json_object_iter_next(keyobj, iter);
}
json_decref(keys);
return otk_keys;
}
void Client::save_keys() {
size_t pacclen = olm::pickle_length(acc);
auto m = std::make_unique<uint8_t[]>(pacclen);
olm::pickle(m.get(), acc);
FILE* file = fopen("secret-keys", "w");
fwrite(m.get(), pacclen, 1, file);
fclose(file);
}
void Client::upload_keys() { // Upload the keys ---
// Build device key json
json_t* upload_keys = json_object();
json_t* device_keys = get_device_keys();
std::cout << "Gathered device keys" << std::endl;
// Sign keys block
sign_json(device_keys);
std::cout << "Signed device keys" << std::endl;
json_object_set_new(upload_keys, "device_keys", device_keys);
json_t* fallback_keys = get_fallback_keys();
std::cout << "Signed fallback keys" << std::endl;
// fallback keys are already signed
json_object_set_new(upload_keys, "fallback_keys", fallback_keys);
// OTK keys
json_t* otk = get_unpublished_otk();
std::cout << "Signed OTK keys" << std::endl;
// OTK keys are already signed
json_object_set_new(upload_keys, "one_time_keys", otk);
uploadKeys(upload_keys);
std::cout << "Keys uploaded !" << std::endl;
print_json(upload_keys);
json_decref(upload_keys);
acc.mark_keys_as_published();
// Whether a key or not is published is saved, let's save again
save_keys();
}
void Client::start_encryption() {
// std::FILE* file = std::fopen("secret-keys", "r");
std::ifstream ifs("secret-keys", std::ios::binary | std::ios::ate);
if (!ifs.is_open()) {
std::cout << "No secret keys found, generating " << std::endl;
// Generate and save to file
// Device keys
generate_device_key();
std::cout << "Generated device key" << std::endl;
// One time keys
generate_otk();
std::cout << "Generated OTK key" << std::endl;
// Fallback keys
generate_fallback_key();
std::cout << "Generated fallback key" << std::endl;
upload_keys();
} else {
// Load from file
std::ifstream::pos_type fsize = ifs.tellg();
if (fsize == -1) {
std::cout << "What." << std::endl;
return;
}
auto data = std::make_unique<uint8_t[]>(fsize);
ifs.seekg(0, std::ios::beg);
ifs.read(reinterpret_cast<char*>(data.get()), static_cast<std::streamsize>(fsize));
olm::unpickle(data.get(), data.get() + fsize, acc);
}
}
}; // namespace Matrix
Reference in a new issue View git blame Copy permalink