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

Start work on centralizing strings

Browse Source
This commit is contained in:
rexy712 2019-10-27 12:54:52 -07:00
parent 76df53d003
commit 61743f00d1
10 changed files with 254 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/matrix/connection.hpp
View File

@ -99,7 +99,6 @@ namespace matrix{
void _set_curl_defaults(const raii::string_base& useragent)const;
static netreturn_base _create_netreturn(const raii::string_base& mxjson, int httpstatus);
static netreturn_base _create_netreturn(const raii::rjp_ptr& root, int httpstatus);
};
}

14
include/matrix/fat_strings.hpp
View File

@ -27,14 +27,26 @@
#include "raii/string.hpp"
#include "matrix/upload_info.hpp"
namespace matrix::detail{
namespace matrix::json{
raii::string _empty(void);
raii::string _image_body(const uploaded_image& image);
raii::string _video_body(const uploaded_video& video);
raii::string _file_body(const uploaded_file& video);
raii::string _audio_body(const uploaded_audio& audio);
raii::string _message_body(const raii::string_base& text);
raii::string _login_password(const raii::string_base& userid, const raii::string_base& password);
raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session);
raii::string _displayname_set(const raii::string_base& newname);
raii::string _avatar_set(const raii::string_base& mediaurl);
raii::string _presence_set(const raii::string_base& status);
raii::string _create_room(const raii::string_base& name, const raii::string_base& alias);
raii::string _userid(const raii::string_base& id);
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason);
raii::string _typing(bool active, int timeout);
raii::string _redact(const raii::string_base& reason);
raii::string _room_upgrade(int version);
}
#endif

63
include/matrix/json_targets.hpp Normal file
View File

@ -0,0 +1,63 @@
#ifndef MATRIX_JSON_TARGETS_HPP
#define MATRIX_JSON_TARGETS_HPP
#include "raii/static_string.hpp"
namespace matrix::json{
namespace message{
constexpr raii::static_string body(void){return "body"_ss;}
constexpr raii::static_string info(void){return "info"_ss;}
namespace infobody{
constexpr raii::static_string height(void){return "h"_ss;}
constexpr raii::static_string width(void){return "w"_ss;}
constexpr raii::static_string mimetype(void){return "mimetype"_ss;}
constexpr raii::static_string size(void){return "size"_ss;}
constexpr raii::static_string thumbinfo(void){return "thumbnail_info"_ss;}
namespace thumbnail{
constexpr raii::static_string height(void){return height();}
constexpr raii::static_string width(void){return width();}
constexpr raii::static_string mimetype(void){return mimetype();}
constexpr raii::static_string size(void){return size();}
}
constexpr raii::static_string thumburl(void){return "thumbnail_url"_ss;}
}
constexpr raii::static_string msgtype(void){return "msgtype"_ss;}
constexpr raii::static_string url(void){return "url"_ss;}
}
namespace auth{
constexpr raii::static_string type(void){return "type"_ss;}
constexpr raii::static_string identifier(void){return "identifier"_ss;}
constexpr raii::static_string password(void){return "password"_ss;}
constexpr raii::static_string newpassword(void){return "new_password"_ss;}
namespace identifierbody{
constexpr raii::static_string type(void){return type();}
constexpr raii::static_string user(void){return "user"_ss;}
constexpr raii::static_string session(void){return "session"_ss;}
constexpr raii::static_string password(void){return password();}
}
}
namespace rooms{
constexpr raii::static_string joined(void){return "joined"_ss;}
constexpr raii::static_string eventid(void){return "event_id"_ss;}
constexpr raii::static_string chunk(void){return "chunk"_ss;}
}
namespace client{
constexpr raii::static_string presence(void){return "presence"_ss;}
constexpr raii::static_string dispname(void){return "displayname"_ss;}
constexpr raii::static_string avatarurl(void){return "avatar_url"_ss;}
constexpr raii::static_string roomid(void){return "room_id"_ss;}
constexpr raii::static_string joinedrooms(void){return "joined_rooms"_ss;}
constexpr raii::static_string contenturi(void){return "content_uri"_ss;}
}
namespace session{
constexpr raii::static_string session(void){return "session"_ss;}
constexpr raii::static_string userid(void){return "user_id"_ss;}
constexpr raii::static_string accesstoken(void){return "access_token"_ss;}
}
}
#endif

1
include/matrix/session_info.hpp
View File

@ -28,6 +28,7 @@ namespace matrix::internal{
raii::string useragent; //useragent to identify our application
raii::string homeserver; //name of our homeserver
raii::rjp_string access_token; //authentication
raii::string auth_header;
raii::rjp_string userid; //userid including homeserver
client_url_list urls;
};

2
include/raii/static_string.hpp
View File

@ -55,7 +55,7 @@ namespace raii{
}
namespace{
inline raii::static_string operator"" _ss(const char* str, size_t len){
constexpr inline raii::static_string operator"" _ss(const char* str, size_t len){
return raii::static_string(str, len);
}
}

24
include/raii/string_base.hpp
View File

@ -291,24 +291,24 @@ namespace raii{
public:
template<class T, class U>
string_cat_expr(T&& l, U&& r):
constexpr string_cat_expr(T&& l, U&& r):
m_l(std::forward<Left>(l)),
m_r(std::forward<Right>(r)){}
string_cat_expr(const string_cat_expr& s):
constexpr string_cat_expr(const string_cat_expr& s):
m_l(s.m_l),
m_r(s.m_r){}
string_cat_expr(string_cat_expr&& s):
constexpr string_cat_expr(string_cat_expr&& s):
m_l(s.m_l),
m_r(s.m_r){}
size_t length(void)const{
constexpr size_t length(void)const{
return _llen() + _rlen();
}
auto get(void){
constexpr auto get(void){
return std::tuple_cat(_lget(), _rget());
}
private:
auto _lget(void){
constexpr auto _lget(void){
if constexpr(detail::is_string<Left>::value){
if constexpr(detail::is_tuple<decltype(m_l.get())>::value){
//string_cat_expr
@ -322,7 +322,7 @@ namespace raii{
return std::make_tuple(m_l, strlen(m_l));
}
}
auto _rget(void){
constexpr auto _rget(void){
if constexpr(detail::is_string<Right>::value){
if constexpr(detail::is_tuple<decltype(m_r.get())>::value){
return m_r.get();
@ -333,14 +333,14 @@ namespace raii{
return std::make_tuple(m_r, strlen(m_r));
}
}
size_t _llen(void)const{
constexpr size_t _llen(void)const{
if constexpr(detail::has_len<typename std::remove_reference<Left>::type>::value){
return m_l.length();
}else{
return strlen(m_l);
}
}
size_t _rlen(void)const{
constexpr size_t _rlen(void)const{
if constexpr(detail::has_len<typename std::remove_reference<Right>::type>::value){
return m_r.length();
}else{
@ -361,15 +361,15 @@ bool operator!=(Str1&& left, Str2&& right){
}
template<class Right, typename std::enable_if<raii::detail::is_string<Right>::value,void>::type* = nullptr>
auto operator+(const char* left, Right&& right){
constexpr auto operator+(const char* left, Right&& right){
return raii::string_cat_expr<const char*,decltype(std::forward<Right>(right))>(left, std::forward<Right>(right));
}
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::value,void>::type* = nullptr>
auto operator+(Left&& left, const char* right){
constexpr auto operator+(Left&& left, const char* right){
return raii::string_cat_expr<decltype(std::forward<Left>(left)),const char*>(std::forward<Left>(left), right);
}
template<class Left, class Right, typename std::enable_if<raii::detail::is_string<Left>::value&&raii::detail::is_string<Right>::value,void>::type* = nullptr>
auto operator+(Left&& l, Right&& r){
constexpr auto operator+(Left&& l, Right&& r){
return raii::string_cat_expr<decltype(std::forward<Left>(l)),decltype(std::forward<Right>(r))>(std::forward<Left>(l), std::forward<Right>(r));
}
template<class Left, class Right, typename std::enable_if<raii::detail::is_string<Left>::value&&raii::detail::is_string<Right>::value,void>::type* = nullptr>

27
src/matrix/client.cpp
View File

@ -18,6 +18,7 @@
#include "matrix/client.hpp"
#include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp"
#include "raii/filerd.hpp"
#include "raii/static_string.hpp"
#include "raii/rjp_ptr.hpp"
@ -31,31 +32,31 @@ namespace matrix{
//networked setter
netreturn<void> client::set_display_name(const raii::string_base& newname){
_put_curl(raii::string("{\"displayname\":\"" + newname + "\"}"), m_ses->urls.displayname(), raii::curl_llist());
_put_curl(json::_displayname_set(newname), m_ses->urls.displayname(), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status());
}
netreturn<void> client::set_profile_picture(const raii::string_base& media_url){
_put_curl(raii::string("{\"avatar_url\":\"" + media_url + "\"}"), m_ses->urls.profile_picture(), raii::curl_llist());
_put_curl(json::_avatar_set(media_url), m_ses->urls.profile_picture(), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status());
}
netreturn<void> client::set_presence(const raii::string_base& status){
_put_curl(raii::string("{\"presence\":\""_ss + status + "\"}"), m_ses->urls.presence(m_ses->homeserver, m_ses->access_token, m_ses->userid), raii::curl_llist());
_put_curl(json::_presence_set(status), m_ses->urls.presence(m_ses->homeserver, m_ses->access_token, 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_ses->urls.presence(m_ses->homeserver, m_ses->access_token, userid), "presence"_ss);
return _get_and_find(m_ses->urls.presence(m_ses->homeserver, m_ses->access_token, userid), json::client::presence());
}
//networked getter
netreturn<raii::rjp_string> client::get_display_name(void)const{
return _get_and_find(m_ses->urls.displayname(), "displayname"_ss);
return _get_and_find(m_ses->urls.displayname(), json::client::dispname());
}
netreturn<raii::rjp_string> client::get_profile_picture(void)const{
return _get_and_find(m_ses->urls.profile_picture(), "avatar_url"_ss);
return _get_and_find(m_ses->urls.profile_picture(), json::client::avatarurl());
}
netreturn<raii::rjp_string> client::room_alias_to_id(const raii::string_base& alias)const{
auto tmp = m_curl.encode(alias, alias.length());
return _get_and_find(raii::string(m_ses->urls.alias_lookup() + tmp), "room_id"_ss);
return _get_and_find(raii::string(m_ses->urls.alias_lookup() + tmp), json::client::roomid());
}
netreturn<std::vector<raii::rjp_string>> client::list_rooms(void)const{
raii::string reply = _get_curl(m_ses->urls.room_list());
@ -67,7 +68,7 @@ namespace matrix{
if(!root)
return retval;
RJP_search_res res = rjp_search_member(root.get(), "joined_rooms", 0);
RJP_search_res res = rjp_search_member(root.get(), json::client::joinedrooms(), 0);
if(!res.value)
return retval;
@ -79,13 +80,7 @@ namespace matrix{
//room membership
netreturn<raii::rjp_string> client::create_room(const raii::string_base& name, const raii::string_base& alias)const{
raii::string postdata;
if(alias)
postdata = "{\"name\": \"" + raii::json_escape(name) + "\",\"room_alias_name\": \"" + raii::json_escape(alias) + "\"}";
else
postdata = "{\"name\": \"" + raii::json_escape(name) + "\"}";
return _post_and_find(postdata, m_ses->urls.create_room(), raii::curl_llist(), "room_id"_ss);
return _post_and_find(json::_create_room(name, alias), m_ses->urls.create_room(), raii::curl_llist(), json::client::roomid());
}
roomcxn client::spawn_room(const raii::string_base& roomid)const{
return roomcxn(m_ses, roomid);
@ -207,7 +202,7 @@ namespace matrix{
netreturn<uploaded_file> retval = _create_netreturn(root, http_status());
if(!root)
return retval;
RJP_search_res res = rjp_search_member(root.get(), "content_uri", 0);
RJP_search_res res = rjp_search_member(root.get(), json::client::contenturi(), 0);
if(!res.value)
return retval;
retval.value().m_fileurl = res.value;

116
src/matrix/fat_strings.cpp
View File

@ -19,9 +19,23 @@
#include "matrix/fat_strings.hpp"
#include "matrix/upload_info.hpp"
#include "raii/static_string.hpp"
#include "matrix/json_targets.hpp"
#include "raii/util.hpp"
namespace matrix::detail{
namespace matrix::json{
static constexpr decltype(auto) quote(const raii::string_base& str){
return "\"" + str + "\"";
}
static constexpr decltype(auto) quotecomma(const raii::string_base& str){
return "\"" + str + "\",";
}
static constexpr decltype(auto) keyquote(const raii::string_base& str){
return "\"" + str + "\":";
}
raii::string _empty(void){
return raii::string("{}");
}
raii::string _image_body(const uploaded_image& image){
raii::string url = raii::json_escape(image.url());
@ -82,7 +96,6 @@ namespace matrix::detail{
"\"size\":" + raii::itostr(file.size()) +
"},"
"\"msgtype\":\"m.file\","
"\"body\":\"" + file.name() + "\","
"\"url\":\"" + raii::json_escape(file.url()) + "\""
"}");
}
@ -96,7 +109,6 @@ namespace matrix::detail{
"\"size\":" + raii::itostr(audio.size()) +
"},"
"\"msgtype\":\"m.audio\","
"\"body\":\"" + audio.name() + "\","
"\"url\":\"" + raii::json_escape(audio.url()) + "\""
"}");
}
@ -104,4 +116,102 @@ namespace matrix::detail{
raii::string _message_body(const raii::string_base& msg){
return raii::string("{\"body\":\""_ss + raii::json_escape(msg) + "\",\"msgtype\":\"m.text\"}"_ss);
}
raii::string _login_password(const raii::string_base& username, const raii::string_base& password){
return raii::string(
"{"
"\"type\":\"m.login.password\","
"\"identifier\":{"
"\"type\":\"m.id.user\","
"\"user\":\"" + raii::json_escape(username) + "\""
"},"
"\"password\":\"" + raii::json_escape(password) + "\""
"}"
);
}
raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session){
return raii::string(
"{"
"\"new_password\":\"" + raii::json_escape(newpass) + "\","
"\"auth\":{"
"\"type\":\"m.login.password\","
"\"session\":\"" + session + "\","
"\"user\":\"" + raii::json_escape(userid) + "\","
"\"password\":\"" + raii::json_escape(oldpass) + "\""
"}"
"}");
}
raii::string _displayname_set(const raii::string_base& newname){
return raii::string(
"{"
"\"displayname\":\"" + raii::json_escape(newname) + "\""
"}"
);
}
raii::string _avatar_set(const raii::string_base& mediaurl){
return raii::string(
"{"
"\"avatar_url\":\"" + raii::json_escape(mediaurl) + "\""
"}"
);
}
raii::string _presence_set(const raii::string_base& status){
return raii::string(
"{"
"\"presence\":\"" + status + "\""
"}"
);
}
raii::string _create_room(const raii::string_base& name, const raii::string_base& alias){
if(alias){
return raii::string(
"{"
"\"name\":\"" + raii::json_escape(name) + "\","
"\"room_alias_name\":\"" + raii::json_escape(alias) + "\""
"}"
);
}else{
return raii::string(
"{"
"\"name\":\"" + raii::json_escape(name) + "\""
"}"
);
}
}
raii::string _userid(const raii::string_base& id){
return raii::string(
"{"
"\"user_id\":\"" + raii::json_escape(id) + "\""
"}"
);
}
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason){
return raii::string(
"{"
"\"user_id\":\"" + raii::json_escape(id) + "\","
"\"reason\":\"" + raii::json_escape(reason) + "\""
"}"
);
}
raii::string _typing(bool active, int timeout){
return raii::string(
"{"
"\"typing\":" + (active ? "true"_ss : "false"_ss) + "\","
"\"timeout\":" + raii::itostr(timeout) +
"}"
);
}
raii::string _redact(const raii::string_base& reason){
return raii::string(
"{"
"\"reason\":\"" + raii::json_escape(reason) + "\""
"}"
);
}
raii::string _room_upgrade(int version){
return raii::string(
"{"
"\"new_version\":\"" + raii::itostr(version) + "\""
"}"
);
}
}

46
src/matrix/roomcxn.cpp
View File

@ -19,12 +19,11 @@
#include "matrix/roomcxn.hpp"
#include "raii/static_string.hpp"
#include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp"
#include "raii/util.hpp"
#include "raii/rjp_ptr.hpp"
#include <utility> //move
#include <map>
namespace matrix{
roomcxn::roomcxn(const std::shared_ptr<internal::session_info>& ses, const raii::string_base& roomid):
@ -60,7 +59,7 @@ namespace matrix{
if(!resp) return _create_netreturn(resp, http_status());
raii::rjp_ptr root(rjp_parse(resp.get()));
if(!root) return _create_netreturn(root, http_status());
RJP_search_res res = rjp_search_member(root.get(), "joined", 0);
RJP_search_res res = rjp_search_member(root.get(), json::rooms::joined(), 0);
if(!res.value) return _create_netreturn(root, http_status());
for(RJP_value* mem = rjp_get_member(res.value);mem;mem = rjp_next_member(mem)){
@ -70,7 +69,7 @@ namespace matrix{
return retval;
}
netreturn<void> roomcxn::invite(const raii::string_base& userid){
raii::string json("{\"user_id\":\"" + userid + "\"}");
raii::string json(json::_userid(userid));
printf("%s\n", json.get());
raii::string response = _post_curl(json, m_urls.invite(), raii::curl_llist());
return _create_netreturn(response, http_status());
@ -81,23 +80,23 @@ namespace matrix{
netreturn<void> roomcxn::kick(const raii::string_base& userid, const raii::string_base& reason){
raii::string response;
if(reason){
response = _post_curl(raii::string("{\"user_id\":\"" + userid + "\",\"reason\":\"" + reason + "\"}"), m_urls.kick(), raii::curl_llist());
response = _post_curl(json::_userid_reason(userid, reason), m_urls.kick(), raii::curl_llist());
}else{
response = _post_curl(raii::string("{\"user_id\":\"" + userid + "\"}"), m_urls.kick(), raii::curl_llist());
response = _post_curl(json::_userid(userid), m_urls.kick(), raii::curl_llist());
}
return _create_netreturn(response, http_status());
}
netreturn<void> roomcxn::ban(const raii::string_base& userid, const raii::string_base& reason){
raii::string response;
if(reason){
response = _post_curl(raii::string("{\"user_id\":\"" + userid + "\",\"reason\":\"" + reason + "\"}"), m_urls.ban(), raii::curl_llist());
response = _post_curl(json::_userid_reason(userid, reason), m_urls.ban(), raii::curl_llist());
}else{
response = _post_curl(raii::string("{\"user_id\":\"" + userid + "\"}"), m_urls.ban(), raii::curl_llist());
response = _post_curl(json::_userid(userid), m_urls.ban(), raii::curl_llist());
}
return _create_netreturn(response, http_status());
}
netreturn<void> roomcxn::unban(const raii::string_base& userid){
raii::string response = _post_curl(raii::string("{\"user_id\":\"" + userid + "\"}"), m_urls.unban(), raii::curl_llist());
raii::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist());
return _create_netreturn(response, http_status());
}
@ -109,36 +108,33 @@ namespace matrix{
raii::rjp_ptr root(rjp_parse(reply));
netreturn<raii::rjp_string> retval = _create_netreturn(root, http_status());
retval.value() = _curl_reply_search(root, "event_id"_ss);
retval.value() = _curl_reply_search(root, json::rooms::eventid());
return retval;
}
netreturn<raii::rjp_string> roomcxn::send_message(const raii::string_base& text)const{
return _send_message(detail::_message_body(text));
return _send_message(json::_message_body(text));
}
netreturn<raii::rjp_string> roomcxn::send_file(const uploaded_file& file)const{
return _send_message(detail::_file_body(file));
return _send_message(json::_file_body(file));
}
netreturn<raii::rjp_string> roomcxn::send_image(const uploaded_image& image)const{
return _send_message(detail::_image_body(image));
return _send_message(json::_image_body(image));
}
netreturn<raii::rjp_string> roomcxn::send_video(const uploaded_video& video)const{
return _send_message(detail::_video_body(video));
return _send_message(json::_video_body(video));
}
netreturn<raii::rjp_string> roomcxn::send_audio(const uploaded_audio& audio)const{
return _send_message(detail::_audio_body(audio));
return _send_message(json::_audio_body(audio));
}
netreturn<void> roomcxn::send_typing(bool active, int timeout)const{
if(active)
return _create_netreturn(_put_curl(raii::string("{\"timeout\":" + raii::itostr(timeout) + ",\"typing\":true}"), m_urls.typing(), raii::curl_llist()), http_status());
else
return _create_netreturn(_put_curl("{\"typing\":false}"_ss, m_urls.typing(), raii::curl_llist()), http_status());
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(""_ss, 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->homeserver, m_ses->access_token, 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(raii::string("{\"reason\":\"" + reason + "\"}"), m_urls.redact(m_ses->homeserver, m_ses->access_token, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist(), "event_id"_ss);
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::rooms::eventid());
}
netreturn<raii::rjp_string> roomcxn::redact_event(const raii::string_base& eventid)const{
return redact_event(eventid, "No reason given"_ss);
@ -150,16 +146,16 @@ namespace matrix{
if(!root.get()) _create_netreturn(root, http_status());
netreturn<sync::roomcxn_message_event_list> retval = _create_netreturn(root, http_status());
RJP_value* chunk = rjp_search_member(root.get(), "chunk", 0).value;
RJP_value* chunk = rjp_search_member(root.get(), json::rooms::chunk(), 0).value;
if(!chunk) return retval;
retval.value() = sync::roomcxn_message_event_list(root, rjp_get_element(chunk), m_roomid);
return retval;
}
netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_forward(int amount){
return _get_events(amount, "f"_ss, ""_ss, ""_ss);
return _get_events(amount, "f"_ss, raii::string(), raii::string());
}
netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_backward(int amount){
return _get_events(amount, "b"_ss, ""_ss, ""_ss);
return _get_events(amount, "b"_ss, raii::string(), raii::string());
}
netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_forward(int amount, const raii::string_base& from, const raii::string_base& to){
return _get_events(amount, "f"_ss, from, to);
@ -172,7 +168,7 @@ namespace matrix{
m_urls.repopulate(m_ses->homeserver, m_ses->access_token, m_ses->userid, m_roomid);
}
netreturn<raii::rjp_string> roomcxn::upgrade(int version)const{
return _post_and_find(raii::string("{\"new_version\":\""_ss + raii::itostr(version) + "\"}"_ss), m_urls.upgrade(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist(), "event_id"_ss);
return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(m_ses->homeserver, m_ses->access_token, m_roomid), raii::curl_llist(), json::rooms::eventid());
}
netreturn<raii::rjp_string> roomcxn::_send_message(const raii::string_base& msg)const{

27
src/matrix/session.cpp
View File

@ -21,9 +21,15 @@
#include "raii/curler.hpp"
#include "raii/util.hpp"
#include "raii/static_string.hpp"
#include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp"
namespace matrix{
static raii::string create_auth_header(const raii::string_base& token){
return raii::string("Authorization: Bearer " + token);
}
session::session(void):
connection(std::make_shared<internal::session_info>()){}
session::session(const auth_data& auth):
@ -50,9 +56,11 @@ namespace matrix{
}
void session::set_access_token(const raii::string_base& tok){
m_ses->access_token = tok;
m_ses->auth_header = create_auth_header(m_ses->access_token);
}
void session::set_access_token(raii::string&& tok){
m_ses->access_token = std::move(tok);
m_ses->auth_header = create_auth_header(m_ses->access_token);
}
netreturn<void> session::login(void){
@ -62,7 +70,7 @@ namespace matrix{
return _do_login(username, pass);
}
netreturn<void> session::logout(void){
raii::string reply = _post_curl(""_ss, m_ses->urls.logout(m_ses->homeserver, m_ses->access_token), raii::curl_llist());
raii::string reply = _post_curl(raii::string(), m_ses->urls.logout(m_ses->homeserver, m_ses->access_token), raii::curl_llist());
return _create_netreturn(reply, http_status());
}
@ -70,7 +78,7 @@ namespace matrix{
return m_valid;
}
netreturn<void> session::change_password(const raii::string_base& oldpass, const raii::string_base& newpass){
raii::string reply = _post_curl(raii::string("{}"), m_ses->urls.password(m_ses->homeserver, m_ses->access_token), raii::curl_llist());
raii::string reply = _post_curl(json::_empty(), m_ses->urls.password(m_ses->homeserver, m_ses->access_token), raii::curl_llist());
if(!reply)
return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply));
@ -79,8 +87,8 @@ namespace matrix{
return retval;
//attempt to change password via username/password login
RJP_search_res res = rjp_search_member(root.get(), "session", 0);
raii::string request = "{\"new_password\": \"" + raii::json_escape(newpass) + "\",\"auth\":{\"type\":\"m.login.password\",\"session\":\"" + raii::rjp_string(res.value) +"\",\"user\": \"" + raii::json_escape(m_ses->userid) + "\",\"password\":\"" + raii::json_escape(oldpass) + "\"}}";
RJP_search_res res = rjp_search_member(root.get(), json::session::session(), 0);
raii::string request = json::_change_psk_password(m_ses->userid, newpass, oldpass, raii::rjp_string(res.value));
reply = _post_curl(request, m_ses->urls.password(m_ses->homeserver, m_ses->access_token), raii::curl_llist());
return _create_netreturn(reply, http_status());
}
@ -112,6 +120,7 @@ namespace matrix{
auto& id = newtoken.value().second;
if(token && id){
m_ses->access_token = std::move(token);
m_ses->auth_header = create_auth_header(m_ses->access_token);
m_ses->userid = std::move(id);
m_ses->urls.repopulate(m_ses->homeserver, m_ses->access_token, m_ses->userid);
m_valid = true;
@ -136,15 +145,17 @@ namespace matrix{
m_ses->useragent = a.useragent;
m_ses->homeserver = a.homeserver;
m_ses->access_token = a.access_token;
if(m_ses->access_token)
m_ses->auth_header = create_auth_header(m_ses->access_token);
_do_login(a.name, a.pass);
}
raii::string session::_request_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl)const{
raii::string postdata("{\"type\":\"m.login.password\", \"identifier\":{\"type\":\"m.id.user\",\"user\":\"" + raii::json_escape(name) + "\"}, \"password\":\"" + raii::json_escape(pass) + "\"}");
raii::string postdata = json::_login_password(name, pass);
raii::string reply = _post_curl(postdata, loginurl, raii::curl_llist{});
return reply;
}
netreturn<raii::rjp_string> session::_get_userid(void){
return _get_and_find(client_url_list::stat_whoami(m_ses->homeserver, m_ses->access_token), "user_id"_ss);
return _get_and_find(client_url_list::stat_whoami(m_ses->homeserver, m_ses->access_token), json::session::userid());
}
netreturn<std::pair<raii::rjp_string,raii::rjp_string>> session::_get_new_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl){
raii::string reply = _request_access_token(name, pass, loginurl);
@ -154,9 +165,9 @@ namespace matrix{
netreturn<std::pair<raii::rjp_string,raii::rjp_string>> retval = _create_netreturn(root, http_status());
if(!root)
return retval;
RJP_search_res token = rjp_search_member(root.get(), "access_token", 0);
RJP_search_res token = rjp_search_member(root.get(), json::session::accesstoken(), 0);
retval.value().first = raii::rjp_string{token.value};
token = rjp_search_member(root.get(), "user_id", 0);
token = rjp_search_member(root.get(), json::session::userid(), 0);
retval.value().second = raii::rjp_string{token.value};
return retval;
}