336 lines
12 KiB
C++
336 lines
12 KiB
C++
/**
|
|
This file is a part of r0nk, atlas_moon, and 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/client.hpp"
|
|
#include "matrix/fat_strings.hpp"
|
|
#include "raii/filerd.hpp"
|
|
#include "raii/static_string.hpp"
|
|
#include "raii/rjp_ptr.hpp"
|
|
#include "raii/util.hpp"
|
|
|
|
#ifdef HAS_FREEIMAGE
|
|
# include "matrix/image_thumbnail_maker.hpp"
|
|
#endif
|
|
|
|
#ifdef HAS_FFMPEG
|
|
# define THUMBSIZE 500
|
|
# include "matrix/video_thumbnail_maker.hpp"
|
|
#endif
|
|
|
|
namespace matrix{
|
|
|
|
//Ctor
|
|
client::client(const std::shared_ptr<internal::session_info>& ses):
|
|
connection(ses){}
|
|
|
|
//local getter
|
|
const raii::rjp_string& client::access_token(void)const{
|
|
return m_ses->access_token;
|
|
}
|
|
const raii::rjp_string& client::userid(void)const{
|
|
return m_ses->userid;
|
|
}
|
|
const raii::string& client::useragent(void)const{
|
|
return m_ses->useragent;
|
|
}
|
|
|
|
//networked setter
|
|
void client::set_display_name(const raii::string_base& newname){
|
|
raii::string reply = _put_curl(raii::string("{\"displayname\":\"" + newname + "\"}"), m_ses->urls.displayname(), raii::curl_llist());
|
|
}
|
|
void client::set_profile_picture(const raii::string_base& media_url){
|
|
raii::string reply = _put_curl(raii::string("{\"avatar_url\":\"" + media_url + "\"}"), m_ses->urls.profile_picture(), raii::curl_llist());
|
|
}
|
|
|
|
//networked getter
|
|
raii::rjp_string client::get_display_name(void)const{
|
|
return _get_and_find(m_ses->urls.displayname(), "displayname"_ss);
|
|
}
|
|
raii::rjp_string client::get_profile_picture(void)const{
|
|
return _get_and_find(m_ses->urls.profile_picture(), "avatar_url"_ss);
|
|
}
|
|
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);
|
|
}
|
|
std::vector<raii::rjp_string> client::list_rooms(void)const{
|
|
std::vector<raii::rjp_string> ret;
|
|
raii::string reply = _get_curl(m_ses->urls.room_list());
|
|
if(!reply)
|
|
return ret;
|
|
|
|
raii::rjp_ptr root(rjp_parse(reply));
|
|
if(!root)
|
|
return ret;
|
|
|
|
RJP_search_res res = rjp_search_member(root.get(), "joined_rooms", 0);
|
|
if(!res.value)
|
|
return ret;
|
|
|
|
for(RJP_value* v = rjp_get_element(res.value);v;v = rjp_next_element(v)){
|
|
ret.emplace_back(v);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//room membership
|
|
raii::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_curl(postdata, m_ses->urls.create_room(), raii::curl_llist());
|
|
}
|
|
bool client::join_room(const raii::string_base& roomid)const{
|
|
return _post_curl(raii::string(), m_ses->urls.join_room(m_ses->homeserver, m_ses->access_token, m_curl.encode(roomid)), raii::curl_llist());
|
|
}
|
|
bool client::leave_room(const raii::string_base& roomid)const{
|
|
return _post_curl(raii::string(), m_ses->urls.leave_room(m_ses->homeserver, m_ses->access_token, m_curl.encode(roomid)), raii::curl_llist());
|
|
}
|
|
bool client::accept_invite(const raii::string_base& roomid)const{
|
|
return join_room(roomid);
|
|
}
|
|
bool client::reject_invite(const raii::string_base& roomid)const{
|
|
return leave_room(roomid);
|
|
}
|
|
|
|
//other network
|
|
void client::logout(void){
|
|
_get_curl(m_ses->urls.logout(m_ses->homeserver, m_ses->access_token));
|
|
}
|
|
|
|
|
|
//upload media
|
|
file_info client::upload_file(const raii::string_base& filename)const{
|
|
return upload_file(filename, raii::static_string());
|
|
}
|
|
file_info client::upload_file(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
raii::filerd fd(filename);
|
|
if(!fd) return {};
|
|
|
|
return file_info{_upload_file(fd, raii::curl_llist{}), alias ? alias : filename, {}, fd.length()};
|
|
}
|
|
image_info client::upload_image(const raii::string_base& filename)const{
|
|
return upload_image(filename, raii::static_string());
|
|
}
|
|
#ifdef HAS_FREEIMAGE
|
|
image_info client::upload_image(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
image_info ret;
|
|
FREE_IMAGE_FORMAT type = fipImage::identifyFIF(filename.get());
|
|
ret.mimetype = FreeImage_GetFIFMimeType(type);
|
|
raii::curl_llist header(raii::string("Content-Type: " + ret.mimetype));
|
|
|
|
{
|
|
raii::filerd fd(filename, "rb");
|
|
if(!fd)
|
|
return ret;
|
|
|
|
ret.filesize = fd.length();
|
|
ret.fileurl = _upload_file(fd, header);
|
|
}
|
|
fipImage image;
|
|
image.load(filename.get());
|
|
if(!image.isValid())
|
|
return {};
|
|
ret.width = image.getWidth();
|
|
ret.height = image.getHeight();
|
|
ret.filename = alias ? alias : filename;
|
|
std::vector<char> thumb_data = internal::_load_image_thumbnail_info(image, ret, type);
|
|
|
|
if(thumb_data.size())
|
|
ret.thumburl = _post_and_find(raii::static_string(thumb_data.data(), thumb_data.size()), m_ses->urls.file_upload(), header, "content_uri"_ss);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#else //HAS_FREEIMAGE
|
|
image_info client::upload_image(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
image_info ret = {};
|
|
ret = upload_file(filename, alias);
|
|
return ret;
|
|
}
|
|
#endif //HAS_FREEIMAGE
|
|
video_info client::upload_video(const raii::string_base& filename)const{
|
|
return upload_video(filename, raii::static_string());
|
|
}
|
|
audio_info client::upload_audio(const raii::string_base& filename)const{
|
|
return upload_audio(filename, raii::static_string());
|
|
}
|
|
#ifdef HAS_FFMPEG
|
|
video_info client::upload_video(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
internal::initlibav();
|
|
video_info ret = {};
|
|
|
|
libav::fmt::input_context in(filename);
|
|
if(!in) return {};
|
|
|
|
int stream_index = -1;
|
|
for(size_t i = 0;i < in->nb_streams;++i){
|
|
if(in->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
|
|
stream_index = i;
|
|
break;
|
|
}
|
|
}
|
|
if(stream_index == -1) return {};
|
|
|
|
libavcodec::context src_ctx(in, stream_index);
|
|
if(!src_ctx) return {};
|
|
|
|
src_ctx.open();
|
|
if(!src_ctx.is_open()) return {};
|
|
|
|
size_t thumbw, thumbh;
|
|
internal::_calc_video_thumbnail_dims(THUMB_SIZE, src_ctx->width, src_ctx->height, &thumbw, &thumbh);
|
|
libav::packet packet = internal::_create_video_thumbnail(in, src_ctx, stream_index, thumbw, thumbh);
|
|
|
|
if(packet){
|
|
raii::curl_llist header("Content-Type: image/jpeg");
|
|
ret.thumb_width = thumbw;
|
|
ret.thumb_height = thumbh;
|
|
ret.thumbsize = packet->size;
|
|
ret.thumburl = _post_and_find(raii::static_string((char*)packet->data, packet->size), m_ses->urls.file_upload(), header, "content_uri"_ss);
|
|
packet.reset();
|
|
}
|
|
|
|
ret.width = src_ctx->width;
|
|
ret.height = src_ctx->height;
|
|
ret.mimetype = internal::get_libav_mimetype(in);
|
|
src_ctx.reset();
|
|
in.reset();
|
|
|
|
raii::curl_llist header(raii::string("Content-Type:" + ret.mimetype));
|
|
header += "Transfer-Encoding: chunked";
|
|
raii::filerd fd(filename);
|
|
if(!fd) return {};
|
|
ret.filesize = fd.length();
|
|
ret.fileurl = _upload_file(fd, header);
|
|
ret.filename = alias ? alias : filename;
|
|
return ret;
|
|
}
|
|
audio_info client::upload_audio(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
audio_info ret = {};
|
|
|
|
libav::fmt::input_context in(filename);
|
|
ret.mimetype = internal::get_libav_mimetype(in);
|
|
in.reset();
|
|
|
|
raii::curl_llist header(raii::string("Content-Type:" + ret.mimetype));
|
|
raii::filerd fd(filename);
|
|
if(!fd) return {};
|
|
ret.filesize = fd.length();
|
|
ret.fileurl = _upload_file(fd, header);
|
|
ret.filename = alias ? alias : filename;
|
|
|
|
return ret;
|
|
}
|
|
#else //HAS_FFMPEG
|
|
video_info client::upload_video(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
video_info ret = {};
|
|
ret = upload_file(filename, alias);
|
|
return ret;
|
|
}
|
|
audio_info client::upload_audio(const raii::string_base& filename, const raii::string_base& alias)const{
|
|
audio_info ret = {};
|
|
ret = upload_file(filename, alias);
|
|
return ret;
|
|
}
|
|
#endif //HAS_FFMPEG
|
|
|
|
|
|
//send messages
|
|
raii::rjp_string client::send_file(const raii::string_base& room, const file_info& file)const{
|
|
return _send_message(room, detail::_file_body(file));
|
|
}
|
|
raii::rjp_string client::send_image(const raii::string_base& room, const image_info& image)const{
|
|
return _send_message(room, detail::_image_body(image));
|
|
}
|
|
raii::rjp_string client::send_video(const raii::string_base& room, const video_info& video)const{
|
|
return _send_message(room, detail::_video_body(video));
|
|
}
|
|
raii::rjp_string client::send_audio(const raii::string_base& room, const audio_info& audio)const{
|
|
return _send_message(room, detail::_audio_body(audio));
|
|
}
|
|
raii::rjp_string client::send_message(const raii::string_base& room, const raii::string_base& text)const{
|
|
return _send_message(room, detail::_message_body(text));
|
|
}
|
|
void client::send_typing(const raii::string_base& room, bool active, int timeout)const{
|
|
if(active)
|
|
_put_curl(raii::string("{\"timeout\":" + raii::itostr(timeout) + ",\"typing\":true}"), m_ses->urls.typing(m_ses->homeserver, m_ses->access_token, m_curl.encode(room), m_curl.encode(m_ses->userid)), raii::curl_llist());
|
|
else
|
|
_put_curl("{\"typing\":false}"_ss, m_ses->urls.typing(m_ses->homeserver, m_ses->access_token, m_curl.encode(room), m_curl.encode(m_ses->userid)), raii::curl_llist());
|
|
}
|
|
|
|
raii::rjp_string client::redact_event(const raii::string_base& roomid, const raii::string_base& eventid, const raii::string_base& reason)const{
|
|
auto ret = _put_curl(raii::string("{\"reason\":\"" + reason + "\"}"), m_ses->urls.redact(m_ses->homeserver, m_ses->access_token, m_curl.encode(roomid), m_curl.encode(eventid)), raii::curl_llist());
|
|
if(!ret) return {};
|
|
raii::rjp_ptr root(rjp_parse(ret.get()));
|
|
if(!root) return {};
|
|
|
|
RJP_search_res res = rjp_search_member(root.get(), "event_id", 0);
|
|
if(!res.value) return {};
|
|
return raii::rjp_string(res.value);
|
|
}
|
|
raii::rjp_string client::redact_event(const raii::string_base& roomid, const raii::string_base& eventid)const{
|
|
return redact_event(roomid, eventid, ""_ss);
|
|
}
|
|
|
|
/*******************************
|
|
Internal functions
|
|
********************************/
|
|
|
|
void client::_send_read_receipt(const raii::string_base& roomid, const raii::string_base& eventid)const{
|
|
_post_curl(""_ss, m_ses->urls.read_receipt(m_ses->homeserver, m_ses->access_token, m_curl.encode(roomid), m_curl.encode(eventid)), raii::curl_llist());
|
|
}
|
|
raii::rjp_string client::_upload_file(raii::filerd& fp, const raii::curl_llist& header)const{
|
|
raii::string fileurl;
|
|
m_curl.postreq();
|
|
m_curl.setopt(CURLOPT_POSTFIELDS, NULL);
|
|
m_curl.setopt(CURLOPT_READDATA, (void*)fp.get());
|
|
m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)fp.length());
|
|
m_curl.setopt(CURLOPT_INFILESIZE_LARGE, (curl_off_t)fp.length());
|
|
m_curl.seturl(m_ses->urls.file_upload());
|
|
m_curl.setheader(header);
|
|
m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
|
|
m_curl.setopt(CURLOPT_WRITEDATA, &fileurl);
|
|
CURLcode cres = m_curl.perform();
|
|
m_curl.setopt(CURLOPT_READDATA, NULL);
|
|
if(cres != CURLE_OK)
|
|
return {};
|
|
|
|
if(!fileurl)
|
|
return {};
|
|
|
|
raii::rjp_ptr root(rjp_parse(fileurl));
|
|
if(!root)
|
|
return {};
|
|
RJP_search_res res = rjp_search_member(root.get(), "content_uri", 0);
|
|
|
|
return res.value;
|
|
}
|
|
raii::rjp_string client::_send_message(const raii::string_base& room, const raii::string_base& msg)const{
|
|
raii::rjp_string reply = _post_and_find(
|
|
msg,
|
|
m_ses->urls.send(m_ses->homeserver, m_ses->access_token, m_curl.encode(room)),
|
|
raii::curl_llist(),
|
|
"event_id"_ss);
|
|
return reply;
|
|
}
|
|
}
|