From 61743f00d190058382478c06259b74c12b7043d3 Mon Sep 17 00:00:00 2001 From: rexy712 Date: Sun, 27 Oct 2019 12:54:52 -0700 Subject: [PATCH] Start work on centralizing strings --- include/matrix/connection.hpp | 1 - include/matrix/fat_strings.hpp | 14 +++- include/matrix/json_targets.hpp | 63 +++++++++++++++++ include/matrix/session_info.hpp | 1 + include/raii/static_string.hpp | 2 +- include/raii/string_base.hpp | 24 +++---- src/matrix/client.cpp | 27 +++----- src/matrix/fat_strings.cpp | 116 +++++++++++++++++++++++++++++++- src/matrix/roomcxn.cpp | 46 ++++++------- src/matrix/session.cpp | 27 +++++--- 10 files changed, 254 insertions(+), 67 deletions(-) create mode 100644 include/matrix/json_targets.hpp diff --git a/include/matrix/connection.hpp b/include/matrix/connection.hpp index 2de8765..976baa5 100644 --- a/include/matrix/connection.hpp +++ b/include/matrix/connection.hpp @@ -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); - }; } diff --git a/include/matrix/fat_strings.hpp b/include/matrix/fat_strings.hpp index c8e1fba..80687e1 100644 --- a/include/matrix/fat_strings.hpp +++ b/include/matrix/fat_strings.hpp @@ -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 diff --git a/include/matrix/json_targets.hpp b/include/matrix/json_targets.hpp new file mode 100644 index 0000000..41c7fe0 --- /dev/null +++ b/include/matrix/json_targets.hpp @@ -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 diff --git a/include/matrix/session_info.hpp b/include/matrix/session_info.hpp index 3b13302..66abf4a 100644 --- a/include/matrix/session_info.hpp +++ b/include/matrix/session_info.hpp @@ -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; }; diff --git a/include/raii/static_string.hpp b/include/raii/static_string.hpp index 840a16a..06d1536 100644 --- a/include/raii/static_string.hpp +++ b/include/raii/static_string.hpp @@ -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); } } diff --git a/include/raii/string_base.hpp b/include/raii/string_base.hpp index ea3d922..21b0279 100644 --- a/include/raii/string_base.hpp +++ b/include/raii/string_base.hpp @@ -291,24 +291,24 @@ namespace raii{ public: template - string_cat_expr(T&& l, U&& r): + constexpr string_cat_expr(T&& l, U&& r): m_l(std::forward(l)), m_r(std::forward(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::value){ if constexpr(detail::is_tuple::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::value){ if constexpr(detail::is_tuple::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::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::type>::value){ return m_r.length(); }else{ @@ -361,15 +361,15 @@ bool operator!=(Str1&& left, Str2&& right){ } template::value,void>::type* = nullptr> -auto operator+(const char* left, Right&& right){ +constexpr auto operator+(const char* left, Right&& right){ return raii::string_cat_expr(right))>(left, std::forward(right)); } template::value,void>::type* = nullptr> -auto operator+(Left&& left, const char* right){ +constexpr auto operator+(Left&& left, const char* right){ return raii::string_cat_expr(left)),const char*>(std::forward(left), right); } template::value&&raii::detail::is_string::value,void>::type* = nullptr> -auto operator+(Left&& l, Right&& r){ +constexpr auto operator+(Left&& l, Right&& r){ return raii::string_cat_expr(l)),decltype(std::forward(r))>(std::forward(l), std::forward(r)); } template::value&&raii::detail::is_string::value,void>::type* = nullptr> diff --git a/src/matrix/client.cpp b/src/matrix/client.cpp index 5ccb00c..17b2245 100644 --- a/src/matrix/client.cpp +++ b/src/matrix/client.cpp @@ -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 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(raii::string(), raii::string(), http_status()); } netreturn 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(raii::string(), raii::string(), http_status()); } netreturn 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(raii::string(), raii::string(), http_status()); } netreturn 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 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 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 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> 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 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 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; diff --git a/src/matrix/fat_strings.cpp b/src/matrix/fat_strings.cpp index 42db123..0ba7004 100644 --- a/src/matrix/fat_strings.cpp +++ b/src/matrix/fat_strings.cpp @@ -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) + "\"" + "}" + ); + } } diff --git a/src/matrix/roomcxn.cpp b/src/matrix/roomcxn.cpp index a87d761..2f6ccd0 100644 --- a/src/matrix/roomcxn.cpp +++ b/src/matrix/roomcxn.cpp @@ -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 //move -#include - namespace matrix{ roomcxn::roomcxn(const std::shared_ptr& 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 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 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 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 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 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 roomcxn::send_message(const raii::string_base& text)const{ - return _send_message(detail::_message_body(text)); + return _send_message(json::_message_body(text)); } netreturn roomcxn::send_file(const uploaded_file& file)const{ - return _send_message(detail::_file_body(file)); + return _send_message(json::_file_body(file)); } netreturn roomcxn::send_image(const uploaded_image& image)const{ - return _send_message(detail::_image_body(image)); + return _send_message(json::_image_body(image)); } netreturn roomcxn::send_video(const uploaded_video& video)const{ - return _send_message(detail::_video_body(video)); + return _send_message(json::_video_body(video)); } netreturn roomcxn::send_audio(const uploaded_audio& audio)const{ - return _send_message(detail::_audio_body(audio)); + return _send_message(json::_audio_body(audio)); } netreturn 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 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 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 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 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 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 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 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 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 roomcxn::_send_message(const raii::string_base& msg)const{ diff --git a/src/matrix/session.cpp b/src/matrix/session.cpp index be0d00e..3e66829 100644 --- a/src/matrix/session.cpp +++ b/src/matrix/session.cpp @@ -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()){} 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 session::login(void){ @@ -62,7 +70,7 @@ namespace matrix{ return _do_login(username, pass); } netreturn 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 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 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> 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> 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; }