rexy712/matrix_thing
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Simplify url generation internally. Remove matrix::syncer; moved functionality to matrix::client

Browse Source
This commit is contained in:
rexy712 2020-01-03 15:43:05 -08:00
parent 232b669d44
commit 9cf6905ea3
16 changed files with 160 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/matrix/client.hpp
View File

@ -28,6 +28,7 @@
#include "matrix/roomcxn.hpp"
#include "matrix/netreturn.hpp"
#include "matrix/rest/client_url_list.hpp"
#include "matrix/sync_response.hpp"
#include <vector> //vector
#include <memory> //shared_ptr
#include <cstdlib> //size_t
@ -140,7 +141,7 @@ namespace matrix{
raii::binary download_file(const raii::string_base& url);
template<class DLHandler>
bool download_file(const raii::string_base& url, DLHandler&& dl){
_get_curl_setup(m_urls->file_download(m_ses->homeserver, url));
_get_curl_setup(m_urls->file_download(*m_ses, url));
m_curl.setwritefun(_download_dispatch<DLHandler>);
m_curl.setwritedata(&dl);
if(!_perform_curl())
@ -152,6 +153,10 @@ namespace matrix{
raii::string url = "mxc://"_ss + server + "/"_ss + media_id;
return download_file(url, std::forward<DLHandler>(dl));
}
netreturn<sync::client_response> sync(size_t timeout);
netreturn<sync::client_response> sync(size_t timeout, const sync::client_response&);
private:
template<class DLHandler>
static size_t _download_dispatch(char* ptr, size_t size, size_t nmemb, void* userdata){

1
include/matrix/matrix.hpp
View File

@ -20,7 +20,6 @@
#define MATRIX_HPP
#include "matrix/client.hpp"
#include "matrix/syncer.hpp"
#include "matrix/session.hpp"
#include "matrix/roomcxn.hpp"

7
include/matrix/netreturn.hpp
View File

@ -62,12 +62,15 @@ namespace matrix{
netreturn_base(std::move(n)){}
netreturn(const netreturn_base& n):
netreturn_base(n){}
Retval& value(void){
Retval& value(void)&{
return m_ret;
}
const Retval& value(void)const{
const Retval& value(void)const&{
return m_ret;
}
Retval&& value(void)&&{
return std::move(m_ret);
}
};
template<>
class netreturn<void> : public netreturn_base

9
include/matrix/rest/client_url_list.hpp
View File

@ -48,11 +48,10 @@ namespace matrix::rest{
const raii::string& alias_lookup(void)const;
const raii::string& displayname(void)const;
const raii::string& profile_picture(void)const;
raii::string file_download(const raii::string_base& homeserver, const raii::string_base& mediaid);
raii::string file_thumbnail(const raii::string_base& homeserver, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const;
raii::string power_level(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const;
raii::string presence(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid)const;
raii::string file_download(const session_info& session, const raii::string_base& mediaid);
raii::string file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const;
raii::string presence(const session_info& session, const raii::string_base& userid)const;
raii::string sync(const session_info& session, const raii::rjp_string& batch, const raii::string& timeout);
void repopulate(const session_info&);
void invalidate(void);

27
include/matrix/rest/room_url_list.hpp
View File

@ -20,6 +20,7 @@
#define MATRIX_ROOM_URL_LIST_HPP
#include "raii/string.hpp"
#include "matrix/session_info.hpp"
namespace matrix{
@ -33,25 +34,27 @@ namespace matrix{
raii::string m_invite;
raii::string m_members;
public:
room_url_list(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& userid);
raii::string join(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const;
raii::string leave(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const;
raii::string forget(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const;
raii::string upgrade(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const;
raii::string read_receipt(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const;
raii::string send(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventtype)const;
raii::string redact(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const;
room_url_list(const session_info& session, const raii::string_base& roomid);
raii::string join(const session_info& session, const raii::string_base& roomid)const;
raii::string leave(const session_info& session, const raii::string_base& roomid)const;
raii::string forget(const session_info& session, const raii::string_base& roomid)const;
raii::string upgrade(const session_info& session, const raii::string_base& roomid)const;
raii::string read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const;
raii::string send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const;
raii::string redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const;
const raii::string& typing(void)const;
const raii::string& kick(void)const;
const raii::string& ban(void)const;
const raii::string& unban(void)const;
const raii::string& invite(void)const;
const raii::string& room_members(void)const;
raii::string messages(const raii::string_base& homeserver, const raii::string_base& access_token,
const raii::string_base& roomid, const raii::string_base& from, const raii::string_base& to,
const raii::string_base& dir, int limit)const;
raii::string messages(const session_info& session, const raii::string_base& roomid,
const raii::string_base& from, const raii::string_base& to,
const raii::string_base& dir, int limit)const;
void repopulate(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid, const raii::string_base& roomid);
raii::string power_level(const session_info& session, const raii::string_base& roomid)const;
void repopulate(const session_info& session, const raii::string_base& roomid);
void invalidate_accesstoken(void);
private:
static constexpr const char* s_proto = "https://";

8
include/matrix/session.hpp
View File

@ -20,7 +20,6 @@
#define MATRIX_SESSION_HPP
#include "matrix/client.hpp"
#include "matrix/syncer.hpp"
#include "matrix/session_info.hpp"
#include "matrix/auth.hpp"
#include "raii/curler.hpp"
@ -119,13 +118,6 @@ namespace matrix{
* Returns: a new matrix::client.
*/
client spawn_client(void)const;
/*
* Create a matrix::syncer which shares login details with this session.
* Note the syncer and session will share memory for generated urls, homeserver, access_token, and
* useragent. Changing any of these fields after spawning a syncer MUST be synchronized across threads.
* Returns: a new matrix::syncer.
*/
syncer spawn_syncer(void)const;
/*
* NOT thread safe.

8
include/matrix/sync_response.hpp
View File

@ -117,14 +117,14 @@ namespace matrix::sync{
/*
Class returned by a sync. Makes for theoretically easier processing than a pure raw response
*/
class response
class client_response
{
private:
raii::rjp_ptr m_root = nullptr;
public:
constexpr response(void) = default;
response(const raii::string_base& src);
response(RJP_value* root);
constexpr client_response(void) = default;
client_response(const raii::string_base& src);
client_response(RJP_value* root);
room_list room_join_events(void)const;
room_list room_invite_events(void)const;

63
include/matrix/syncer.hpp
View File

@ -1,63 +0,0 @@
/**
This file is a part of rexy's matrix client
Copyright (C) 2019 rexy712
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef MATRIX_SYNCER_HPP
#define MATRIX_SYNCER_HPP
#include "raii/curler.hpp"
#include "raii/rjp_string.hpp"
#include "raii/string.hpp"
#include "matrix/session_info.hpp"
#include "matrix/connection.hpp"
#include "matrix/sync_response.hpp"
#include "matrix/netreturn.hpp"
#include <cstdlib> //size_t
#include <memory> //shared_ptr
namespace matrix{
//Specialized class used for syncing up with homeserver.
//Designed to be run on a dedicated thread.
//Shares state with spawning session.
class syncer : public connection
{
private:
raii::rjp_string m_next_batch; //string which tracks where we are in the server history
public:
syncer(const std::shared_ptr<session_info>&);
//Copy and move ctor
syncer(const syncer& b) = default;
syncer(syncer&& b) = default;
//Dtor
~syncer(void) = default;
//Copy and move assignment
syncer& operator=(const syncer&) = default;
syncer& operator=(syncer&&) = default;
/*
* Sync state with the homeserver. Will wait for up to timeout ms.
* Returns: the raw json response from the homeserver.
*/
netreturn<sync::response> sync(size_t timeout);
};
}
#endif

30
src/matrix/client.cpp
View File

@ -41,11 +41,11 @@ namespace matrix{
return netreturn<void>(raii::string(), raii::string(), http_status());
}
netreturn<void> client::set_presence(const raii::string_base& status){
_put_curl(json::_presence_set(status), m_urls->presence(m_ses->homeserver, m_ses->access_token, m_ses->userid), raii::curl_llist());
_put_curl(json::_presence_set(status), m_urls->presence(*m_ses, m_ses->userid), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status());
}
netreturn<raii::rjp_string> client::get_presence(const raii::string_base& userid){
return _get_and_find(m_urls->presence(m_ses->homeserver, m_ses->access_token, userid), json::keys::client::presence());
return _get_and_find(m_urls->presence(*m_ses, userid), json::keys::client::presence());
}
//networked getter
@ -139,7 +139,7 @@ namespace matrix{
}
m_curl.setopt(CURLOPT_HEADERFUNCTION, _thumbnail_header_callback);
m_curl.setopt(CURLOPT_HEADERDATA, &reply_header);
i.data = _get_curl_binary(m_urls->file_thumbnail(m_ses->homeserver, info.m_fileurl, info.m_thumb.m_width, info.m_thumb.m_height, "crop"_ss));
i.data = _get_curl_binary(m_urls->file_thumbnail(*m_ses, info.m_fileurl, info.m_thumb.m_width, info.m_thumb.m_height, "crop"_ss));
m_curl.setopt(CURLOPT_HEADERFUNCTION, NULL);
m_curl.setopt(CURLOPT_HEADERDATA, NULL);
if(!i.data)
@ -160,9 +160,31 @@ namespace matrix{
return create_thumbnail(static_cast<uploaded_image&>(info));
}
raii::binary client::download_file(const raii::string_base& url){
return _get_curl_binary(m_urls->file_download(m_ses->homeserver, url));
return _get_curl_binary(m_urls->file_download(*m_ses, url));
}
netreturn<sync::client_response> client::sync(size_t timeout){
return sync(timeout, {});
}
netreturn<sync::client_response> client::sync(size_t timeout, const sync::client_response& last){
raii::string reply;
if(last.raw_handle())
reply = _get_curl(m_urls->sync(*m_ses, last.next_batch(), raii::itostr(timeout)));
else
reply = _get_curl(m_urls->sync(*m_ses, ""_ss, raii::itostr(timeout)));
if(!reply)
return netreturn<sync::client_response>(raii::string(), raii::string(), http_status(), {nullptr});
raii::rjp_ptr root(rjp_parse(reply));
netreturn<sync::client_response> retval = _create_netreturn(root, http_status());
if(!root)
return retval;
RJP_search_res res = rjp_search_member(root.get(), "next_batch", 0);
if(!res.value)
return retval;
retval.value() = sync::client_response(root.release());
return retval;
}
/*******************************
Internal functions
********************************/

51
src/matrix/rest/client_url_list.cpp
View File

@ -25,22 +25,6 @@ namespace matrix::rest{
client_url_list::client_url_list(const session_info& session){
repopulate(session);
}
void client_url_list::repopulate(const session_info& session){
m_create_room = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/createRoom?access_token=" + session.access_token;
m_file_upload = matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/upload?access_token=" + session.access_token;
m_room_list = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/joined_rooms?access_token=" + session.access_token;
m_displayname = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + session.userid + "/displayname?access_token=" + session.access_token;
m_profile_picture = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + session.userid + "/avatar_url?access_token=" + session.access_token;
m_alias_lookup = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/directory/room/";
}
void client_url_list::invalidate(void){
m_create_room.reset();
m_file_upload.reset();
m_room_list.reset();
m_displayname.reset();
m_profile_picture.reset();
m_alias_lookup.reset();
}
const raii::string& client_url_list::create_room(void)const{
return m_create_room;
}
@ -59,19 +43,42 @@ namespace matrix::rest{
const raii::string& client_url_list::profile_picture(void)const{
return m_profile_picture;
}
raii::string client_url_list::file_download(const raii::string_base& homeserver, const raii::string_base& fileurl){
raii::string client_url_list::file_download(const session_info& session, const raii::string_base& fileurl){
raii::string media = get_server_media_string(fileurl);
if(!media) return {};
return raii::string(matrix::rest::proto() + homeserver + "/_matrix/media/r0/download/" + media);
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/download/" + media);
}
raii::string client_url_list::file_thumbnail(const raii::string_base& homeserver, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const{
raii::string client_url_list::file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const{
raii::string media = get_server_media_string(fileurl);
if(!media) return {};
return raii::string(matrix::rest::proto() + homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method);
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method);
}
raii::string client_url_list::presence(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid)const{
return raii::string(matrix::rest::proto() + homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + access_token);
raii::string client_url_list::presence(const session_info& session, const raii::string_base& userid)const{
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token);
}
raii::string client_url_list::sync(const session_info& session, const raii::rjp_string& next_batch, const raii::string& timeout){
if(!next_batch)
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout);
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout + "&since=" + next_batch);
}
void client_url_list::repopulate(const session_info& session){
m_create_room = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/createRoom?access_token=" + session.access_token;
m_file_upload = matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/upload?access_token=" + session.access_token;
m_room_list = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/joined_rooms?access_token=" + session.access_token;
m_displayname = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + session.userid + "/displayname?access_token=" + session.access_token;
m_profile_picture = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + session.userid + "/avatar_url?access_token=" + session.access_token;
m_alias_lookup = matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/directory/room/";
}
void client_url_list::invalidate(void){
m_create_room.reset();
m_file_upload.reset();
m_room_list.reset();
m_displayname.reset();
m_profile_picture.reset();
m_alias_lookup.reset();
}
raii::string client_url_list::get_server_media_string(const raii::string_base& url){
if(!url || strncmp(url.get(), "mxc://", 6))
return {};

70
src/matrix/rest/room_url_list.cpp
View File

@ -21,37 +21,37 @@
namespace matrix{
room_url_list::room_url_list(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& userid):
m_typing(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + userid + "?access_token=" + access_token),
m_kick(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + access_token),
m_ban(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + access_token),
m_unban(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + access_token),
m_invite(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + access_token),
m_members(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + access_token){}
raii::string room_url_list::join(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + access_token);
room_url_list::room_url_list(const session_info& session, const raii::string_base& roomid):
m_typing(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token),
m_kick(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token),
m_ban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token),
m_unban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + session.access_token),
m_invite(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + session.access_token),
m_members(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + session.access_token){}
raii::string room_url_list::join(const session_info& session, const raii::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token);
}
raii::string room_url_list::leave(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + access_token);
raii::string room_url_list::leave(const session_info& session, const raii::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token);
}
raii::string room_url_list::forget(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + access_token);
raii::string room_url_list::forget(const session_info& session, const raii::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token);
}
raii::string room_url_list::upgrade(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + access_token);
raii::string room_url_list::upgrade(const session_info& session, const raii::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token);
}
raii::string room_url_list::read_receipt(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + access_token);
raii::string room_url_list::read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + session.access_token);
}
raii::string room_url_list::send(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventtype)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + access_token);
raii::string room_url_list::send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token);
}
raii::string room_url_list::redact(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + access_token);
raii::string room_url_list::redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token);
}
raii::string room_url_list::power_level(const session_info& session, const raii::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + session.access_token);
}
/*raii::string room_url_list::power_level(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + access_token);
}*/
const raii::string& room_url_list::typing(void)const{
return m_typing;
}
@ -70,22 +70,22 @@ namespace matrix{
const raii::string& room_url_list::room_members(void)const{
return m_members;
}
raii::string room_url_list::messages(const raii::string_base& homeserver, const raii::string_base& access_token,
const raii::string_base& roomid, const raii::string_base& from, const raii::string_base& to,
raii::string room_url_list::messages(const session_info& session, const raii::string_base& roomid,
const raii::string_base& from, const raii::string_base& to,
const raii::string_base& dir, int limit)const
{
if(to)
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + access_token);
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
else
return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + access_token);
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
}
void room_url_list::repopulate(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid, const raii::string_base& roomid){
m_typing = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + userid + "?access_token=" + access_token;
m_kick = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + access_token;
m_ban = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + access_token;
m_unban = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + access_token;
m_invite = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + access_token;
m_members = s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + access_token;
void room_url_list::repopulate(const session_info& session, const raii::string_base& roomid){
m_typing = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token;
m_kick = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token;
m_ban = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token;
m_unban = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + session.access_token;
m_invite = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + session.access_token;
m_members = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + session.access_token;
}
}

20
src/matrix/roomcxn.cpp
View File

@ -31,18 +31,18 @@ namespace matrix{
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, raii::string&& roomid):
connection(ses),
m_roomid(std::move(roomid)),
m_urls(ses->homeserver, ses->access_token, m_curl.encode(m_roomid), ses->userid){}
m_urls(*ses, m_curl.encode(m_roomid)){}
netreturn<void> roomcxn::join(void)const{
raii::string response = _post_curl(raii::string(), m_urls.join(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist());
raii::string response = _post_curl(raii::string(), m_urls.join(*m_ses, m_roomid), raii::curl_llist());
return _create_netreturn(response, http_status());
}
netreturn<void> roomcxn::leave(void)const{
raii::string response = _post_curl(raii::string(), m_urls.leave(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist());
raii::string response = _post_curl(raii::string(), m_urls.leave(*m_ses, m_roomid), raii::curl_llist());
return _create_netreturn(response, http_status());
}
netreturn<void> roomcxn::forget(void)const{
raii::string response = _post_curl(raii::string(), m_urls.forget(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist());
raii::string response = _post_curl(raii::string(), m_urls.forget(*m_ses, m_roomid), raii::curl_llist());
return _create_netreturn(response, http_status());
}
netreturn<void> roomcxn::accept_invite(void)const{
@ -102,7 +102,7 @@ namespace matrix{
netreturn<raii::rjp_string> roomcxn::send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const{
raii::string reply = _post_curl(event, m_urls.send(m_ses->homeserver, m_ses->access_token, m_curl.encode(m_roomid), eventtype), raii::curl_llist());
raii::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist());
if(!reply)
return _create_netreturn(reply, http_status());
@ -130,17 +130,17 @@ namespace matrix{
return _create_netreturn(_put_curl(json::_typing(active, timeout), m_urls.typing(), raii::curl_llist()), http_status());
}
netreturn<void> roomcxn::send_read_receipt(const raii::string_base& eventid)const{
return _create_netreturn(_post_curl(raii::string(), m_urls.read_receipt(m_ses->homeserver, m_ses->access_token, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status());
return _create_netreturn(_post_curl(raii::string(), m_urls.read_receipt(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status());
}
netreturn<raii::rjp_string> roomcxn::redact_event(const raii::string_base& eventid, const raii::string_base& reason)const{
return _put_and_find(json::_redact(reason), m_urls.redact(m_ses->homeserver, m_ses->access_token, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist(), json::keys::rooms::eventid());
return _put_and_find(json::_redact(reason), m_urls.redact(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist(), json::keys::rooms::eventid());
}
netreturn<raii::rjp_string> roomcxn::redact_event(const raii::string_base& eventid)const{
return redact_event(eventid, "No reason given"_ss);
}
netreturn<sync::roomcxn_message_event_list> roomcxn::_get_events(int amount, raii::static_string direction, const raii::string_base& from, const raii::string_base& to){
raii::string reply = _get_curl(m_urls.messages(m_ses->homeserver, m_ses->access_token, m_curl.encode(m_roomid), from, to, direction, amount));
raii::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount));
if(!reply) return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply.get()));
if(!root.get()) _create_netreturn(root, http_status());
@ -165,10 +165,10 @@ namespace matrix{
}
void roomcxn::regenerate_urls(void){
m_urls.repopulate(m_ses->homeserver, m_ses->access_token, m_ses->userid, m_roomid);
m_urls.repopulate(*m_ses, m_roomid);
}
netreturn<raii::rjp_string> roomcxn::upgrade(int version)const{
return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist(), json::keys::rooms::eventid());
return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(*m_ses, m_roomid), raii::curl_llist(), json::keys::rooms::eventid());
}
netreturn<raii::rjp_string> roomcxn::_send_message(const raii::string_base& msg)const{

3
src/matrix/session.cpp
View File

@ -96,9 +96,6 @@ namespace matrix{
client session::spawn_client(void)const{
return client(m_ses);
}
syncer session::spawn_syncer(void)const{
return syncer(m_ses);
}
void session::invalidate(void){
m_valid = false;
m_ses->useragent.reset();

30
src/matrix/sync_response.cpp
View File

@ -53,54 +53,54 @@ namespace matrix::sync{
}
//Sync response
response::response(const raii::string_base& s):
client_response::client_response(const raii::string_base& s):
m_root(rjp_parse(s)){}
response::response(RJP_value* root):
client_response::client_response(RJP_value* root):
m_root(root){}
room_list response::room_join_events(void)const{
room_list client_response::room_join_events(void)const{
return _find_room_list("join");
}
room_list response::room_invite_events(void)const{
room_list client_response::room_invite_events(void)const{
return _find_room_list("invite");
}
room_list response::room_leave_events(void)const{
room_list client_response::room_leave_events(void)const{
return _find_room_list("leave");
}
device_list response::device_lists(void)const{
device_list client_response::device_lists(void)const{
return rjp_search_member(m_root.get(), "device_lists", 0).value;
}
raii::static_string response::next_batch(void)const&{
raii::static_string client_response::next_batch(void)const&{
RJP_value* nb = rjp_search_member(m_root.get(), "next_batch", 0).value;
if(!nb) return {};
return raii::static_string(rjp_value_string(nb), rjp_value_string_length(nb));
}
raii::rjp_string response::next_batch(void)&&{
raii::rjp_string client_response::next_batch(void)&&{
return raii::rjp_string(rjp_search_member(m_root.get(), "next_batch", 0).value);
}
event_list response::to_device_events(void)const{
event_list client_response::to_device_events(void)const{
return rjp_search_member(rjp_search_member(m_root.get(), "to_device", 0).value, "events", 0).value;
}
event_list response::presence_events(void)const{
event_list client_response::presence_events(void)const{
return rjp_search_member(rjp_search_member(m_root.get(), "presence", 0).value, "events", 0).value;
}
RJP_value* response::device_one_time_keys_count(void)const{
RJP_value* client_response::device_one_time_keys_count(void)const{
return rjp_search_member(m_root.get(), "device_one_time_keys_count", 0).value;
}
RJP_value* response::raw_handle(void){
RJP_value* client_response::raw_handle(void){
return m_root.get();
}
const RJP_value* response::raw_handle(void)const{
const RJP_value* client_response::raw_handle(void)const{
return m_root.get();
}
raii::rjp_string response::raw_str(void)const{
raii::rjp_string client_response::raw_str(void)const{
#ifndef RJP_FORMAT_NONE
return raii::rjp_string(rjp_to_json(m_root.get()));
#else
return raii::rjp_string(rjp_to_json(m_root.get(), RJP_FORMAT_NONE));
#endif
}
RJP_value* response::_find_room_list(const char* segment)const{
RJP_value* client_response::_find_room_list(const char* segment)const{
RJP_search_res res = rjp_search_member(m_root.get(), "rooms", 0);
if(!res.value)
return nullptr;

46
src/matrix/syncer.cpp
View File

@ -1,46 +0,0 @@
/**
This file is a part of rexy's matrix client
Copyright (C) 2019 rexy712
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "matrix/syncer.hpp"
#include "raii/string_base.hpp"
#include "raii/rjp_ptr.hpp"
#include "raii/util.hpp"
#include "matrix/rest/sync_urls.hpp"
namespace matrix{
syncer::syncer(const std::shared_ptr<session_info>& ses):
connection(ses){}
netreturn<sync::response> syncer::sync(size_t timeout){
raii::string reply = _get_curl(rest::sync_urls::sync(*m_ses, m_next_batch, raii::itostr(timeout)));
if(!reply)
return netreturn<sync::response>(raii::string(), raii::string(), http_status(), {nullptr});
raii::rjp_ptr root(rjp_parse(reply));
netreturn<sync::response> retval = _create_netreturn(root, http_status());
if(!root)
return retval;
RJP_search_res res = rjp_search_member(root.get(), "next_batch", 0);
if(!res.value)
return retval;
m_next_batch = res.value;
retval.value() = sync::response(root.release());
return retval;
}
}

51
src/test.cpp
View File

@ -28,34 +28,6 @@
#include <future>
#include <chrono>
void sync_fn(matrix::syncer syn, std::atomic_bool& should_quit){
syn.sync(0);
printf("paused\n");
getchar();
printf("continuing\n");
while(!should_quit){
auto sync_reply = syn.sync(30000);
for(auto room : sync_reply.value().room_join_events()){
for(auto event : room.timeline_events()){
printf("%s\n", event.sender().get());
}
}
}
}
void keyboard_fn(matrix::roomcxn cxn, std::atomic_bool& should_quit){
char buffer[2048];
while(!should_quit){
fgets(buffer, 2048, stdin);
if(!strcmp(buffer, "!exit\n")){
should_quit = true;
break;
}
cxn.send_message(raii::static_string(buffer));
}
}
matrix::auth_data read_auth_file(const char* filename){
raii::filerd fp(filename, "r");
if(!fp){
@ -108,21 +80,20 @@ int main(){
std::atomic_bool should_quit = false;
auto syn = ses.spawn_syncer();
auto client = ses.spawn_client();
auto room = client.spawn_room("!IaZlRZWhZiNMMsiZRl:rexy712.chickenkiller.com"_ss);
auto sync_res = client.sync(0).value();
while(true){
sync_res = client.sync(30000, sync_res).value();
for(auto room : sync_res.room_join_events()){
for(auto event : room.timeline_events()){
printf("%s\n", event.sender().get());
}
}
}
syn.sync(0);
auto status = room.send_message("test"_ss);
/* auto status = room.send_message("test"_ss);
if(!status.ok())
fprintf(stderr, "http error: %d\n", status.httpstatus());
if(status.mxerror())
fprintf(stderr, "matrix error: %s\n", status.mxerror().get());
//std::thread sync_thread(sync_fn, ses.spawn_syncer(), std::ref(should_quit));
//std::thread key_thread(keyboard_fn, ses.spawn_client().spawn_room("!cEIFONpAlHTbGBUFAE:rexy712.chickenkiller.com"_ss), std::ref(should_quit));
//sync_thread.join();
//key_thread.join();
fprintf(stderr, "matrix error: %s\n", status.mxerror().get());*/
}