procxx
/
kepka
mirror of https://github.com/procxx/kepka.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Add simple files and contacts export. 

Also move all API calls in export to Export::ApiWrap.
This commit is contained in:
John Preston 2018-06-11 21:35:27 +03:00
parent 0a1a5ed70e
commit cec8114b99
21 changed files with 951 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Telegram/SourceFiles/base/optional.h
View File

@ -160,12 +160,17 @@ class optional : public optional_variant<Type> {
public:
using parent::parent;
Type &operator*() {
Type &operator*() & {
Expects(parent::template is<Type>());
return parent::template get_unchecked<Type>();
}
const Type &operator*() const {
Type &&operator*() && {
Expects(parent::template is<Type>());
return std::move(parent::template get_unchecked<Type>());
}
const Type &operator*() const & {
Expects(parent::template is<Type>());
return parent::template get_unchecked<Type>();

200
Telegram/SourceFiles/export/data/export_data_types.cpp
View File

@ -18,53 +18,183 @@ Utf8String ParseString(const MTPstring &data) {
return data.v;
}
PersonalInfo ParsePersonalInfo(const MTPUserFull &data) {
Expects(data.type() == mtpc_userFull);
FileLocation ParseLocation(const MTPFileLocation &data) {
switch (data.type()) {
case mtpc_fileLocation: {
const auto &location = data.c_fileLocation();
return {
location.vdc_id.v,
MTP_inputFileLocation(
location.vvolume_id,
location.vlocal_id,
location.vsecret)
};
} break;
case mtpc_fileLocationUnavailable: {
const auto &location = data.c_fileLocationUnavailable();
return {
0,
MTP_inputFileLocation(
location.vvolume_id,
location.vlocal_id,
location.vsecret)
};
} break;
}
Unexpected("Type in ParseLocation.");
}
const auto &fields = data.c_userFull();
const auto &small = fields.vuser.c_user();
auto result = PersonalInfo();
if (small.has_first_name()) {
result.firstName = ParseString(small.vfirst_name);
}
if (small.has_last_name()) {
result.lastName = ParseString(small.vlast_name);
}
if (small.has_phone()) {
result.phoneNumber = ParseString(small.vphone);
}
if (small.has_username()) {
result.username = ParseString(small.vusername);
}
if (fields.has_about()) {
result.bio = ParseString(fields.vabout);
File ParseMaxImage(
const MTPVector<MTPPhotoSize> &data,
const QString &suggestedPath) {
auto result = File();
result.suggestedPath = suggestedPath;
auto maxArea = int64(0);
for (const auto &size : data.v) {
switch (size.type()) {
case mtpc_photoSize: {
const auto &fields = size.c_photoSize();
const auto area = fields.vw.v * int64(fields.vh.v);
if (area > maxArea) {
result.location = ParseLocation(fields.vlocation);
result.size = fields.vsize.v;
result.content = QByteArray();
maxArea = area;
}
} break;
case mtpc_photoCachedSize: {
const auto &fields = size.c_photoCachedSize();
const auto area = fields.vw.v * int64(fields.vh.v);
if (area > maxArea) {
result.location = ParseLocation(fields.vlocation);
result.size = fields.vbytes.v.size();
result.content = fields.vbytes.v;
maxArea = area;
}
} break;
}
}
return result;
}
Photo ParsePhoto(const MTPPhoto &data, const QString &suggestedPath) {
auto result = Photo();
switch (data.type()) {
case mtpc_photo: {
const auto &photo = data.c_photo();
result.id = photo.vid.v;
result.date = QDateTime::fromTime_t(photo.vdate.v);
result.image = ParseMaxImage(photo.vsizes, suggestedPath);
} break;
case mtpc_photoEmpty: {
const auto &photo = data.c_photoEmpty();
result.id = photo.vid.v;
} break;
default: Unexpected("Photo type in ParsePhoto.");
}
return result;
}
Utf8String FormatDateTime(
const int32 date,
QChar dateSeparator,
QChar timeSeparator,
QChar separator) {
const auto value = QDateTime::fromTime_t(date);
return (QString("%1") + dateSeparator + "%2" + dateSeparator + "%3"
+ separator + "%4" + timeSeparator + "%5" + timeSeparator + "%6"
).arg(value.date().year()
).arg(value.date().month(), 2, 10, QChar('0')
).arg(value.date().day(), 2, 10, QChar('0')
).arg(value.time().hour(), 2, 10, QChar('0')
).arg(value.time().minute(), 2, 10, QChar('0')
).arg(value.time().second(), 2, 10, QChar('0')
).toUtf8();
}
UserpicsSlice ParseUserpicsSlice(const MTPVector<MTPPhoto> &data) {
const auto &list = data.v;
auto result = UserpicsSlice();
result.list.reserve(list.size());
for (const auto &photo : list) {
switch (photo.type()) {
case mtpc_photo: {
const auto &fields = photo.c_photo();
auto userpic = Userpic();
userpic.id = fields.vid.v;
userpic.date = QDateTime::fromTime_t(fields.vdate.v);
userpic.image = File{ "(not saved)" };
result.list.push_back(std::move(userpic));
} break;
const auto suggestedPath = "PersonalPhotos/Photo_"
+ (photo.type() == mtpc_photo
? QString::fromUtf8(
FormatDateTime(photo.c_photo().vdate.v, '_', '_', '_'))
: "Empty")
+ ".jpg";
result.list.push_back(ParsePhoto(photo, suggestedPath));
}
return result;
}
case mtpc_photoEmpty: {
const auto &fields = photo.c_photoEmpty();
auto userpic = Userpic();
userpic.id = fields.vid.v;
result.list.push_back(std::move(userpic));
} break;
User ParseUser(const MTPUser &data) {
auto result = User();
switch (data.type()) {
case mtpc_user: {
const auto &fields = data.c_user();
result.id = fields.vid.v;
if (fields.has_first_name()) {
result.firstName = ParseString(fields.vfirst_name);
}
if (fields.has_last_name()) {
result.lastName = ParseString(fields.vlast_name);
}
if (fields.has_phone()) {
result.phoneNumber = ParseString(fields.vphone);
}
if (fields.has_username()) {
result.username = ParseString(fields.vusername);
}
} break;
default: Unexpected("Photo type in ParseUserpicsSlice.");
case mtpc_userEmpty: {
const auto &fields = data.c_userEmpty();
result.id = fields.vid.v;
} break;
default: Unexpected("Type in ParseUser.");
}
return result;
}
std::map<int, User> ParseUsersList(const MTPVector<MTPUser> &data) {
auto result = std::map<int, User>();
for (const auto &user : data.v) {
auto parsed = ParseUser(user);
result.emplace(parsed.id, std::move(parsed));
}
return result;
}
PersonalInfo ParsePersonalInfo(const MTPUserFull &data) {
Expects(data.type() == mtpc_userFull);
const auto &fields = data.c_userFull();
auto result = PersonalInfo();
result.user = ParseUser(fields.vuser);
if (fields.has_about()) {
result.bio = ParseString(fields.vabout);
}
return result;
}
ContactsList ParseContactsList(const MTPcontacts_Contacts &data) {
Expects(data.type() == mtpc_contacts_contacts);
auto result = ContactsList();
const auto &contacts = data.c_contacts_contacts();
const auto map = ParseUsersList(contacts.vusers);
for (const auto &contact : contacts.vcontacts.v) {
const auto userId = contact.c_contact().vuser_id.v;
if (const auto i = map.find(userId); i != end(map)) {
result.list.push_back(i->second);
} else {
result.list.push_back(User());
}
}
return result;

80
Telegram/SourceFiles/export/data/export_data_types.h
View File

@ -8,6 +8,7 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
#pragma once
#include "scheme.h"
#include "base/optional.h"
#include <QtCore/QDateTime>
#include <QtCore/QString>
@ -28,46 +29,64 @@ inline auto NumberToString(Type value)
return QByteArray(result.data(), int(result.size()));
}
struct PersonalInfo {
struct UserpicsInfo {
int count = 0;
};
struct FileLocation {
int dcId = 0;
MTPInputFileLocation data;
};
struct File {
FileLocation location;
int size = 0;
QByteArray content;
QString suggestedPath;
QString relativePath;
};
struct Photo {
uint64 id = 0;
QDateTime date;
int width = 0;
int height = 0;
File image;
};
struct UserpicsSlice {
std::vector<Photo> list;
};
UserpicsSlice ParseUserpicsSlice(const MTPVector<MTPPhoto> &data);
struct User {
int id = 0;
Utf8String firstName;
Utf8String lastName;
Utf8String phoneNumber;
Utf8String username;
};
User ParseUser(const MTPUser &user);
std::map<int, User> ParseUsersList(const MTPVector<MTPUser> &data);
struct PersonalInfo {
User user;
Utf8String bio;
};
PersonalInfo ParsePersonalInfo(const MTPUserFull &data);
struct UserpicsInfo {
int count = 0;
};
struct File {
QString relativePath;
};
struct Userpic {
uint64 id = 0;
QDateTime date;
File image;
};
struct UserpicsSlice {
std::vector<Userpic> list;
};
UserpicsSlice ParseUserpicsSlice(const MTPVector<MTPPhoto> &data);
struct Contact {
Utf8String firstName;
Utf8String lastName;
Utf8String phoneNumber;
};
struct ContactsList {
std::vector<Contact> list;
std::vector<User> list;
};
ContactsList ParseContactsList(const MTPcontacts_Contacts &data);
struct Session {
Utf8String platform;
Utf8String deviceModel;
@ -108,6 +127,11 @@ struct MessagesSlice {
};
Utf8String FormatPhoneNumber(const Utf8String &phoneNumber);
Utf8String FormatDateTime(
const int32 date,
QChar dateSeparator = QChar('.'),
QChar timeSeparator = QChar(':'),
QChar separator = QChar(' '));
} // namespace Data
} // namespace Export

364
Telegram/SourceFiles/export/export_api_wrap.cpp Normal file
View File

@ -0,0 +1,364 @@
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "export/export_api_wrap.h"
#include "export/data/export_data_types.h"
#include "export/output/export_output_file.h"
#include "mtproto/rpc_sender.h"
#include <deque>
namespace Export {
namespace {
constexpr auto kUserpicsSliceLimit = 2;
constexpr auto kFileChunkSize = 128 * 1024;
constexpr auto kFileRequestsCount = 2;
constexpr auto kFileNextRequestDelay = TimeMs(20);
} // namespace
struct ApiWrap::UserpicsProcess {
FnMut<void(Data::UserpicsInfo&&)> start;
Fn<void(Data::UserpicsSlice&&)> handleSlice;
FnMut<void()> finish;
base::optional<Data::UserpicsSlice> slice;
bool lastSlice = false;
int loading = -1;
};
struct ApiWrap::FileProcess {
FileProcess(const QString &path);
Output::File file;
QString relativePath;
FnMut<void(const QString &relativePath)> done;
Data::FileLocation location;
int offset = 0;
int size = 0;
struct Request {
int offset = 0;
QByteArray bytes;
};
std::deque<Request> requests;
};
ApiWrap::FileProcess::FileProcess(const QString &path) : file(path) {
}
template <typename Request>
auto ApiWrap::mainRequest(Request &&request) {
return std::move(_mtp.request(
std::move(request)
).fail([=](RPCError &&result) {
error(std::move(result));
}).toDC(MTP::ShiftDcId(0, MTP::kExportDcShift)));
}
auto ApiWrap::fileRequest(const Data::FileLocation &location, int offset) {
Expects(location.dcId != 0);
return std::move(_mtp.request(MTPupload_GetFile(
location.data,
MTP_int(offset),
MTP_int(kFileChunkSize)
)).fail([=](RPCError &&result) {
error(std::move(result));
}).toDC(MTP::ShiftDcId(location.dcId, MTP::kExportDcShift)));
}
ApiWrap::ApiWrap(Fn<void(FnMut<void()>)> runner)
: _mtp(std::move(runner)) {
}
void ApiWrap::setFilesBaseFolder(const QString &folder) {
Expects(folder.endsWith('/'));
_filesFolder = folder;
}
rpl::producer<RPCError> ApiWrap::errors() const {
return _errors.events();
}
void ApiWrap::requestPersonalInfo(FnMut<void(Data::PersonalInfo&&)> done) {
mainRequest(MTPusers_GetFullUser(
_user
)).done([=, done = std::move(done)](const MTPUserFull &result) mutable {
Expects(result.type() == mtpc_userFull);
const auto &full = result.c_userFull();
if (full.vuser.type() == mtpc_user) {
done(Data::ParsePersonalInfo(result));
} else {
error("Bad user type.");
}
}).send();
}
void ApiWrap::requestUserpics(
FnMut<void(Data::UserpicsInfo&&)> start,
Fn<void(Data::UserpicsSlice&&)> slice,
FnMut<void()> finish) {
_userpicsProcess = std::make_unique<UserpicsProcess>();
_userpicsProcess->start = std::move(start);
_userpicsProcess->handleSlice = std::move(slice);
_userpicsProcess->finish = std::move(finish);
mainRequest(MTPphotos_GetUserPhotos(
_user,
MTP_int(0),
MTP_long(0),
MTP_int(kUserpicsSliceLimit)
)).done([=](const MTPphotos_Photos &result) mutable {
Expects(_userpicsProcess != nullptr);
_userpicsProcess->start([&] {
auto info = Data::UserpicsInfo();
switch (result.type()) {
case mtpc_photos_photos: {
const auto &data = result.c_photos_photos();
info.count = data.vphotos.v.size();
} break;
case mtpc_photos_photosSlice: {
const auto &data = result.c_photos_photosSlice();
info.count = data.vcount.v;
} break;
default: Unexpected("Photos type in Controller::exportUserpics.");
}
return info;
}());
handleUserpicsSlice(result);
}).send();
}
void ApiWrap::handleUserpicsSlice(const MTPphotos_Photos &result) {
Expects(_userpicsProcess != nullptr);
switch (result.type()) {
case mtpc_photos_photos: {
const auto &data = result.c_photos_photos();
_userpicsProcess->lastSlice = true;
loadUserpicsFiles(Data::ParseUserpicsSlice(data.vphotos));
} break;
case mtpc_photos_photosSlice: {
const auto &data = result.c_photos_photosSlice();
loadUserpicsFiles(Data::ParseUserpicsSlice(data.vphotos));
} break;
default: Unexpected("Photos type in Controller::exportUserpicsSlice.");
}
}
void ApiWrap::loadUserpicsFiles(Data::UserpicsSlice &&slice) {
Expects(_userpicsProcess != nullptr);
Expects(!_userpicsProcess->slice.has_value());
if (slice.list.empty()) {
_userpicsProcess->lastSlice = true;
}
_userpicsProcess->slice = std::move(slice);
_userpicsProcess->loading = -1;
loadNextUserpic();
}
void ApiWrap::loadNextUserpic() {
Expects(_userpicsProcess != nullptr);
Expects(_userpicsProcess->slice.has_value());
const auto &list = _userpicsProcess->slice->list;
++_userpicsProcess->loading;
if (_userpicsProcess->loading < list.size()) {
loadFile(
list[_userpicsProcess->loading].image,
[=](const QString &path) { loadUserpicDone(path); });
return;
}
const auto lastUserpicId = list.empty()
? base::none
: base::make_optional(list.back().id);
_userpicsProcess->handleSlice(*base::take(_userpicsProcess->slice));
if (_userpicsProcess->lastSlice) {
finishUserpics();
return;
}
Assert(lastUserpicId.has_value());
mainRequest(MTPphotos_GetUserPhotos(
_user,
MTP_int(0),
MTP_long(*lastUserpicId),
MTP_int(kUserpicsSliceLimit)
)).done([=](const MTPphotos_Photos &result) {
handleUserpicsSlice(result);
}).send();
}
void ApiWrap::loadUserpicDone(const QString &relativePath) {
Expects(_userpicsProcess != nullptr);
Expects(_userpicsProcess->slice.has_value());
Expects((_userpicsProcess->loading >= 0)
&& (_userpicsProcess->loading
< _userpicsProcess->slice->list.size()));
const auto index = _userpicsProcess->loading;
_userpicsProcess->slice->list[index].image.relativePath = relativePath;
loadNextUserpic();
}
void ApiWrap::finishUserpics() {
Expects(_userpicsProcess != nullptr);
base::take(_userpicsProcess)->finish();
}
void ApiWrap::requestContacts(FnMut<void(Data::ContactsList&&)> done) {
const auto hash = 0;
mainRequest(MTPcontacts_GetContacts(
MTP_int(hash)
)).done([=, done = std::move(done)](
const MTPcontacts_Contacts &result) mutable {
if (result.type() == mtpc_contacts_contacts) {
done(Data::ParseContactsList(result));
} else {
error("Bad contacts type.");
}
}).send();
}
void ApiWrap::loadFile(const Data::File &file, FnMut<void(QString)> done) {
Expects(_fileProcess == nullptr);
if (!file.relativePath.isEmpty()) {
done(file.relativePath);
}
using namespace Output;
const auto relativePath = File::PrepareRelativePath(
_filesFolder,
file.suggestedPath);
_fileProcess = std::make_unique<FileProcess>(
_filesFolder + relativePath);
_fileProcess->relativePath = relativePath;
_fileProcess->location = file.location;
_fileProcess->done = std::move(done);
if (!file.content.isEmpty()) {
auto &output = _fileProcess->file;
if (output.writeBlock(file.content) == File::Result::Success) {
_fileProcess->done(relativePath);
} else {
error(QString("Could not open '%1'.").arg(relativePath));
}
} else if (!file.location.dcId) {
_fileProcess->done(QString());
} else {
loadFilePart();
}
}
void ApiWrap::loadFilePart() {
if (!_fileProcess
|| _fileProcess->requests.size() >= kFileRequestsCount
|| (_fileProcess->size > 0
&& _fileProcess->offset >= _fileProcess->size)) {
return;
}
const auto offset = _fileProcess->offset;
_fileProcess->requests.push_back({ offset });
fileRequest(
_fileProcess->location,
_fileProcess->offset
).done([=](const MTPupload_File &result) {
filePartDone(offset, result);
}).send();
_fileProcess->offset += kFileChunkSize;
if (_fileProcess->size > 0
&& _fileProcess->requests.size() < kFileRequestsCount) {
//const auto runner = _runner;
//crl::on_main([=] {
// QTimer::singleShot(kFileNextRequestDelay, [=] {
// runner([=] {
// loadFilePart();
// });
// });
//});
}
}
void ApiWrap::filePartDone(int offset, const MTPupload_File &result) {
Expects(_fileProcess != nullptr);
Expects(!_fileProcess->requests.empty());
if (result.type() == mtpc_upload_fileCdnRedirect) {
error("Cdn redirect is not supported.");
return;
}
const auto &data = result.c_upload_file();
if (data.vbytes.v.isEmpty()) {
if (_fileProcess->size > 0) {
error("Empty bytes received in file part.");
return;
}
} else {
using Request = FileProcess::Request;
auto &requests = _fileProcess->requests;
const auto i = ranges::find(
requests,
offset,
[](const Request &request) { return request.offset; });
Assert(i != end(requests));
i->bytes = data.vbytes.v;
auto &file = _fileProcess->file;
while (!requests.empty() && !requests.front().bytes.isEmpty()) {
const auto &bytes = requests.front().bytes;
if (file.writeBlock(bytes) != Output::File::Result::Success) {
error(QString("Could not write bytes to '%1'."
).arg(_fileProcess->relativePath));
return;
}
requests.pop_front();
}
if (!requests.empty()
|| !_fileProcess->size
|| _fileProcess->size > _fileProcess->offset) {
loadFilePart();
return;
}
}
auto process = base::take(_fileProcess);
process->done(process->relativePath);
}
void ApiWrap::error(RPCError &&error) {
_errors.fire(std::move(error));
}
void ApiWrap::error(const QString &text) {
error(MTP_rpc_error(MTP_int(0), MTP_string("API_ERROR: " + text)));
}
ApiWrap::~ApiWrap() = default;
} // namespace Export

76
Telegram/SourceFiles/export/export_api_wrap.h Normal file
View File

@ -0,0 +1,76 @@
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include "mtproto/concurrent_sender.h"
namespace Export {
namespace Data {
struct File;
struct FileLocation;
struct PersonalInfo;
struct UserpicsInfo;
struct UserpicsSlice;
struct ContactsList;
} // namespace Data
class ApiWrap {
public:
ApiWrap(Fn<void(FnMut<void()>)> runner);
void setFilesBaseFolder(const QString &folder);
rpl::producer<RPCError> errors() const;
void requestPersonalInfo(FnMut<void(Data::PersonalInfo&&)> done);
void requestUserpics(
FnMut<void(Data::UserpicsInfo&&)> start,
Fn<void(Data::UserpicsSlice&&)> slice,
FnMut<void()> finish);
void requestContacts(FnMut<void(Data::ContactsList&&)> done);
~ApiWrap();
private:
void handleUserpicsSlice(const MTPphotos_Photos &result);
void loadUserpicsFiles(Data::UserpicsSlice &&slice);
void loadNextUserpic();
void loadUserpicDone(const QString &relativePath);
void finishUserpics();
void loadFile(const Data::File &file, FnMut<void(QString)> done);
void loadFilePart();
void filePartDone(int offset, const MTPupload_File &result);
template <typename Request>
[[nodiscard]] auto mainRequest(Request &&request);
[[nodiscard]] auto fileRequest(
const Data::FileLocation &location,
int offset);
void error(RPCError &&error);
void error(const QString &text);
MTP::ConcurrentSender _mtp;
QString _filesFolder;
MTPInputUser _user = MTP_inputUserSelf();
struct UserpicsProcess;
std::unique_ptr<UserpicsProcess> _userpicsProcess;
struct FileProcess;
std::unique_ptr<FileProcess> _fileProcess;
rpl::event_stream<RPCError> _errors;
};
} // namespace Export

160
Telegram/SourceFiles/export/export_controller.cpp
View File

@ -7,18 +7,12 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "export/export_controller.h"
#include "export/export_api_wrap.h"
#include "export/export_settings.h"
#include "export/data/export_data_types.h"
#include "export/output/export_output_abstract.h"
#include "mtproto/rpc_sender.h"
#include "mtproto/concurrent_sender.h"
namespace Export {
namespace {
constexpr auto kUserpicsSliceLimit = 100;
} // namespace
class Controller {
public:
@ -40,8 +34,6 @@ private:
using Step = ProcessingState::Step;
void setState(State &&state);
void apiError(const RPCError &error);
void apiError(const QString &error);
void ioError(const QString &path);
void setFinishedState();
@ -56,11 +48,9 @@ private:
void exportSessions();
void exportChats();
void exportUserpicsSlice(const MTPphotos_Photos &result);
bool normalizePath();
MTP::ConcurrentSender _mtp;
ApiWrap _api;
Settings _settings;
// rpl::variable<State> fails to compile in MSVC :(
@ -73,14 +63,23 @@ private:
std::vector<ProcessingState::Step> _steps;
int _stepIndex = -1;
MTPInputUser _user = MTP_inputUserSelf();
rpl::lifetime _lifetime;
};
Controller::Controller(crl::weak_on_queue<Controller> weak)
: _mtp(weak)
: _api(weak.runner())
, _state(PasswordCheckState{}) {
requestPasswordState();
_api.errors(
) | rpl::start_with_next([=](RPCError &&error) {
setState(ErrorState{ ErrorState::Type::API, std::move(error) });
}, _lifetime);
//requestPasswordState();
auto state = PasswordCheckState();
state.checked = false;
state.requesting = false;
setState(std::move(state));
}
rpl::producer<State> Controller::state() const {
@ -99,14 +98,6 @@ void Controller::setState(State &&state) {
_stateChanges.fire_copy(_state);
}
void Controller::apiError(const RPCError &error) {
setState(ErrorState{ ErrorState::Type::API, error });
}
void Controller::apiError(const QString &error) {
apiError(MTP_rpc_error(MTP_int(0), MTP_string("API_ERROR: " + error)));
}
void Controller::ioError(const QString &path) {
setState(ErrorState{ ErrorState::Type::IO, base::none, path });
}
@ -124,7 +115,7 @@ rpl::producer<PasswordUpdate> Controller::passwordUpdate() const {
}
void Controller::reloadPasswordState() {
_mtp.request(base::take(_passwordRequestId)).cancel();
//_mtp.request(base::take(_passwordRequestId)).cancel();
requestPasswordState();
}
@ -132,13 +123,13 @@ void Controller::requestPasswordState() {
if (_passwordRequestId) {
return;
}
_passwordRequestId = _mtp.request(MTPaccount_GetPassword(
)).done([=](const MTPaccount_Password &result) {
_passwordRequestId = 0;
passwordStateDone(result);
}).fail([=](const RPCError &error) {
apiError(error);
}).send();
//_passwordRequestId = _mtp.request(MTPaccount_GetPassword(
//)).done([=](const MTPaccount_Password &result) {
// _passwordRequestId = 0;
// passwordStateDone(result);
//}).fail([=](const RPCError &error) {
// apiError(error);
//}).send();
}
void Controller::passwordStateDone(const MTPaccount_Password &result) {
@ -156,6 +147,9 @@ void Controller::cancelUnconfirmedPassword() {
}
void Controller::startExport(const Settings &settings) {
if (!_settings.path.isEmpty()) {
return;
}
_settings = base::duplicate(settings);
if (!normalizePath()) {
@ -163,6 +157,7 @@ void Controller::startExport(const Settings &settings) {
return;
}
_writer = Output::CreateWriter(_settings.format);
_api.setFilesBaseFolder(_settings.path);
fillExportSteps();
exportNext();
}
@ -182,7 +177,7 @@ bool Controller::normalizePath() {
return true;
}
const auto date = QDate::currentDate();
const auto base = QString("DataExport.%1.%2.%3"
const auto base = QString("DataExport_%1_%2_%3"
).arg(date.day(), 2, 10, QChar('0')
).arg(date.month(), 2, 10, QChar('0')
).arg(date.year());
@ -241,101 +236,28 @@ void Controller::exportNext() {
}
void Controller::exportPersonalInfo() {
if (!(_settings.types & Settings::Type::PersonalInfo)) {
exportUserpics();
return;
}
_mtp.request(MTPusers_GetFullUser(
_user
)).done([=](const MTPUserFull &result) {
Expects(result.type() == mtpc_userFull);
const auto &full = result.c_userFull();
if (full.vuser.type() == mtpc_user) {
_writer->writePersonal(Data::ParsePersonalInfo(result));
exportNext();
} else {
apiError("Bad user type.");
}
}).fail([=](const RPCError &error) {
apiError(error);
}).send();
_api.requestPersonalInfo([=](Data::PersonalInfo &&result) {
_writer->writePersonal(result);
exportNext();
});
}
void Controller::exportUserpics() {
_mtp.request(MTPphotos_GetUserPhotos(
_user,
MTP_int(0),
MTP_long(0),
MTP_int(kUserpicsSliceLimit)
)).done([=](const MTPphotos_Photos &result) {
_writer->writeUserpicsStart([&] {
auto info = Data::UserpicsInfo();
switch (result.type()) {
case mtpc_photos_photos: {
const auto &data = result.c_photos_photos();
info.count = data.vphotos.v.size();
} break;
case mtpc_photos_photosSlice: {
const auto &data = result.c_photos_photosSlice();
info.count = data.vcount.v;
} break;
default: Unexpected("Photos type in Controller::exportUserpics.");
}
return info;
}());
exportUserpicsSlice(result);
}).fail([=](const RPCError &error) {
apiError(error);
}).send();
}
void Controller::exportUserpicsSlice(const MTPphotos_Photos &result) {
const auto finish = [&] {
_api.requestUserpics([=](Data::UserpicsInfo &&start) {
_writer->writeUserpicsStart(start);
}, [=](Data::UserpicsSlice &&slice) {
_writer->writeUserpicsSlice(slice);
}, [=] {
_writer->writeUserpicsEnd();
exportNext();
};
switch (result.type()) {
case mtpc_photos_photos: {
const auto &data = result.c_photos_photos();
_writer->writeUserpicsSlice(
Data::ParseUserpicsSlice(data.vphotos));
finish();
} break;
case mtpc_photos_photosSlice: {
const auto &data = result.c_photos_photosSlice();
const auto slice = Data::ParseUserpicsSlice(data.vphotos);
_writer->writeUserpicsSlice(slice);
if (slice.list.empty()) {
finish();
} else {
_mtp.request(MTPphotos_GetUserPhotos(
_user,
MTP_int(0),
MTP_long(slice.list.back().id),
MTP_int(kUserpicsSliceLimit)
)).done([=](const MTPphotos_Photos &result) {
exportUserpicsSlice(result);
}).fail([=](const RPCError &error) {
apiError(error);
}).send();
}
} break;
default: Unexpected("Photos type in Controller::exportUserpicsSlice.");
}
});
}
void Controller::exportContacts() {
exportNext();
_api.requestContacts([=](Data::ContactsList &&result) {
_writer->writeContactsList(result);
exportNext();
});
}
void Controller::exportSessions() {

7
Telegram/SourceFiles/export/export_pch.h
View File

@ -7,6 +7,7 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QTextStream>
#include <QtCore/QDateTime>
@ -14,6 +15,12 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
#include <rpl/rpl.h>
#include <vector>
#include <map>
#include <deque>
#include <range/v3/all.hpp>
#ifdef Q_OS_WIN
#include "platform/win/windows_range_v3_helpers.h"
#endif // Q_OS_WIN
#include "scheme.h"
#include "logs.h"

39
Telegram/SourceFiles/export/output/export_output_file.cpp
View File

@ -7,6 +7,8 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "export/output/export_output_file.h"
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <gsl/gsl_util>
namespace Export {
@ -46,10 +48,45 @@ File::Result File::reopen() {
} else if (_offset > 0) {
return Result::FatalError;
}
return _file->open(QIODevice::Append)
if (_file->open(QIODevice::Append)) {
return Result::Success;
}
const auto info = QFileInfo(_path);
const auto dir = info.absoluteDir();
return (!dir.exists()
&& dir.mkpath(dir.absolutePath())
&& _file->open(QIODevice::Append))
? Result::Success
: Result::Error;
}
QString File::PrepareRelativePath(
const QString &folder,
const QString &suggested) {
if (!QFile::exists(folder + suggested)) {
return suggested;
}
// Not lastIndexOf('.') so that "file.tar.xz" won't be messed up.
const auto position = suggested.indexOf('.');
const auto base = suggested.midRef(0, position);
const auto extension = (position >= 0)
? suggested.midRef(position)
: QStringRef();
const auto relativePart = [&](int attempt) {
auto result = QString(" (%1)").arg(attempt);
result.prepend(base);
result.append(extension);
return result;
};
auto attempt = 0;
while (true) {
const auto relativePath = relativePart(++attempt);
if (!QFile::exists(folder + relativePath)) {
return relativePath;
}
}
}
} // namespace Output
} // namespace File

4
Telegram/SourceFiles/export/output/export_output_file.h
View File

@ -27,6 +27,10 @@ public:
};
Result writeBlock(const QByteArray &block);
static QString PrepareRelativePath(
const QString &folder,
const QString &suggested);
private:
Result reopen();
Result writeBlockAttempt(const QByteArray &block);

94
Telegram/SourceFiles/export/output/export_output_text.cpp
View File

@ -35,6 +35,32 @@ void SerializeMultiline(
} while (newline > 0);
}
QByteArray JoinList(
const QByteArray &separator,
const std::vector<QByteArray> &list) {
if (list.empty()) {
return QByteArray();
} else if (list.size() == 1) {
return list[0];
}
auto size = (list.size() - 1) * separator.size();
for (const auto &value : list) {
size += value.size();
}
auto result = QByteArray();
result.reserve(size);
auto counter = 0;
while (true) {
result.append(list[counter]);
if (++counter == list.size()) {
break;
} else {
result.append(separator);
}
}
return result;
}
QByteArray SerializeKeyValue(
std::vector<std::pair<QByteArray, QByteArray>> &&values) {
auto result = QByteArray();
@ -74,10 +100,10 @@ bool TextWriter::writePersonal(const Data::PersonalInfo &data) {
+ kLineBreak
+ kLineBreak
+ SerializeKeyValue({
{ "First name", data.firstName },
{ "Last name", data.lastName },
{ "Phone number", Data::FormatPhoneNumber(data.phoneNumber) },
{ "Username", FormatUsername(data.username) },
{ "First name", data.user.firstName },
{ "Last name", data.user.lastName },
{ "Phone number", Data::FormatPhoneNumber(data.user.phoneNumber) },
{ "Username", FormatUsername(data.user.username) },
{ "Bio", data.bio },
})
+ kLineBreak;
@ -101,8 +127,17 @@ bool TextWriter::writeUserpicsStart(const Data::UserpicsInfo &data) {
bool TextWriter::writeUserpicsSlice(const Data::UserpicsSlice &data) {
auto lines = QByteArray();
for (const auto &userpic : data.list) {
lines.append(userpic.date.toString().toUtf8()).append(": ");
lines.append(userpic.image.relativePath.toUtf8());
if (!userpic.date.isValid()) {
lines.append("(empty photo)");
} else {
lines.append(Data::FormatDateTime(userpic.date.toTime_t()));
lines.append(" - ");
if (userpic.image.relativePath.isEmpty()) {
lines.append("(file unavailable)");
} else {
lines.append(userpic.image.relativePath.toUtf8());
}
}
lines.append(kLineBreak);
}
return _result->writeBlock(lines) == File::Result::Success;
@ -115,7 +150,52 @@ bool TextWriter::writeUserpicsEnd() {
}
bool TextWriter::writeContactsList(const Data::ContactsList &data) {
return true;
if (data.list.empty()) {
return true;
}
// Get sorted by name indices.
const auto names = ranges::view::all(
data.list
) | ranges::view::transform([](const Data::User &user) {
return (QString::fromUtf8(user.firstName)
+ ' '
+ QString::fromUtf8(user.lastName)).toLower();
}) | ranges::to_vector;
auto indices = ranges::view::ints(0, int(data.list.size()))
| ranges::to_vector;
ranges::sort(indices, [&](int i, int j) {
return names[i] < names[j];
});
const auto header = "Contacts "
"(" + Data::NumberToString(data.list.size()) + ")"
+ kLineBreak
+ kLineBreak;
auto list = std::vector<QByteArray>();
list.reserve(data.list.size());
for (const auto &index : indices) {
const auto &contact = data.list[index];
if (!contact.id) {
list.push_back("(user unavailable)");
} else if (contact.firstName.isEmpty()
&& contact.lastName.isEmpty()
&& contact.phoneNumber.isEmpty()) {
list.push_back("(empty user)" + kLineBreak);
} else {
list.push_back(SerializeKeyValue({
{ "First name", contact.firstName },
{ "Last name", contact.lastName },
{
"Phone number",
Data::FormatPhoneNumber(contact.phoneNumber)
},
}));
}
}
const auto full = header + JoinList(kLineBreak, list) + kLineBreak;
return _result->writeBlock(full) == File::Result::Success;
}
bool TextWriter::writeSessionsList(const Data::SessionsList &data) {

2
Telegram/SourceFiles/export/view/export_view_settings.cpp
View File

@ -93,6 +93,7 @@ void SettingsWidget::refreshButtons(not_null<Ui::RpWidget*> container) {
st::defaultBoxButton)
: nullptr;
if (start) {
start->show();
_startClicks = start->clicks();
container->sizeValue(
@ -107,6 +108,7 @@ void SettingsWidget::refreshButtons(not_null<Ui::RpWidget*> container) {
container.get(),
langFactory(lng_cancel),
st::defaultBoxButton);
cancel->show();
_cancelClicks = cancel->clicks();
rpl::combine(

28
Telegram/SourceFiles/mtproto/concurrent_sender.cpp
View File

@ -16,7 +16,7 @@ class ConcurrentSender::RPCDoneHandler : public RPCAbstractDoneHandler {
public:
RPCDoneHandler(
not_null<ConcurrentSender*> sender,
Fn<void(FnMut<void()>)> run);
Fn<void(FnMut<void()>)> runner);
void operator()(
mtpRequestId requestId,
@ -25,7 +25,7 @@ public:
private:
base::weak_ptr<ConcurrentSender> _weak;
Fn<void(FnMut<void()>)> _run;
Fn<void(FnMut<void()>)> _runner;
};
@ -33,7 +33,7 @@ class ConcurrentSender::RPCFailHandler : public RPCAbstractFailHandler {
public:
RPCFailHandler(
not_null<ConcurrentSender*> sender,
Fn<void(FnMut<void()>)> run,
Fn<void(FnMut<void()>)> runner,
FailSkipPolicy skipPolicy);
bool operator()(
@ -42,16 +42,16 @@ public:
private:
base::weak_ptr<ConcurrentSender> _weak;
Fn<void(FnMut<void()>)> _run;
Fn<void(FnMut<void()>)> _runner;
FailSkipPolicy _skipPolicy = FailSkipPolicy::Simple;
};
ConcurrentSender::RPCDoneHandler::RPCDoneHandler(
not_null<ConcurrentSender*> sender,
Fn<void(FnMut<void()>)> run)
Fn<void(FnMut<void()>)> runner)
: _weak(sender)
, _run(std::move(run)) {
, _runner(std::move(runner)) {
}
void ConcurrentSender::RPCDoneHandler::operator()(
@ -61,7 +61,7 @@ void ConcurrentSender::RPCDoneHandler::operator()(
auto response = gsl::make_span(
from,
end - from);
_run([=, weak = _weak, moved = bytes::make_vector(response)]() mutable {
_runner([=, weak = _weak, moved = bytes::make_vector(response)]() mutable {
if (const auto strong = weak.get()) {
strong->senderRequestDone(requestId, std::move(moved));
}
@ -70,10 +70,10 @@ void ConcurrentSender::RPCDoneHandler::operator()(
ConcurrentSender::RPCFailHandler::RPCFailHandler(
not_null<ConcurrentSender*> sender,
Fn<void(FnMut<void()>)> run,
Fn<void(FnMut<void()>)> runner,
FailSkipPolicy skipPolicy)
: _weak(sender)
, _run(std::move(run))
, _runner(std::move(runner))
, _skipPolicy(skipPolicy) {
}
@ -89,7 +89,7 @@ bool ConcurrentSender::RPCFailHandler::operator()(
return false;
}
}
_run([=, weak = _weak, error = error]() mutable {
_runner([=, weak = _weak, error = error]() mutable {
if (const auto strong = weak.get()) {
strong->senderRequestFail(requestId, std::move(error));
}
@ -142,10 +142,10 @@ mtpRequestId ConcurrentSender::RequestBuilder::send() {
_sender->with_instance([
=,
request = std::move(_serialized),
done = std::make_shared<RPCDoneHandler>(_sender, _sender->_run),
done = std::make_shared<RPCDoneHandler>(_sender, _sender->_runner),
fail = std::make_shared<RPCFailHandler>(
_sender,
_sender->_run,
_sender->_runner,
_failSkipPolicy)
](not_null<Instance*> instance) mutable {
instance->sendSerialized(
@ -160,8 +160,8 @@ mtpRequestId ConcurrentSender::RequestBuilder::send() {
return requestId;
}
ConcurrentSender::ConcurrentSender(Fn<void(FnMut<void()>)> run)
: _run(run) {
ConcurrentSender::ConcurrentSender(Fn<void(FnMut<void()>)> runner)
: _runner(runner) {
}
ConcurrentSender::~ConcurrentSender() {

51
Telegram/SourceFiles/mtproto/concurrent_sender.h
View File

@ -8,7 +8,6 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
#pragma once
#include <rpl/details/callable.h>
#include <crl/crl_object_on_queue.h>
#include "base/bytes.h"
#include "base/weak_ptr.h"
#include "base/flat_map.h"
@ -81,10 +80,7 @@ class ConcurrentSender : public base::has_weak_ptr {
};
public:
ConcurrentSender(Fn<void(FnMut<void()>)> run);
template <typename Type>
ConcurrentSender(const crl::weak_on_queue<Type> &weak);
ConcurrentSender(Fn<void(FnMut<void()>)> runner);
template <typename Request>
class SpecificRequestBuilder : public RequestBuilder {
@ -107,21 +103,21 @@ public:
#ifdef _DEBUG
// Allow code completion to show response type.
[[nodiscard]] SpecificRequestBuilder &done(Fn<void()> &&handler);
[[nodiscard]] SpecificRequestBuilder &done(Fn<void(
[[nodiscard]] SpecificRequestBuilder &done(FnMut<void()> &&handler);
[[nodiscard]] SpecificRequestBuilder &done(FnMut<void(
mtpRequestId)> &&handler);
[[nodiscard]] SpecificRequestBuilder &done(Fn<void(
[[nodiscard]] SpecificRequestBuilder &done(FnMut<void(
mtpRequestId,
Response &&)> &&handler);
[[nodiscard]] SpecificRequestBuilder &done(Fn<void(
[[nodiscard]] SpecificRequestBuilder &done(FnMut<void(
Response &&)> &&handler);
[[nodiscard]] SpecificRequestBuilder &fail(Fn<void()> &&handler);
[[nodiscard]] SpecificRequestBuilder &fail(Fn<void(
[[nodiscard]] SpecificRequestBuilder &fail(FnMut<void()> &&handler);
[[nodiscard]] SpecificRequestBuilder &fail(FnMut<void(
mtpRequestId)> &&handler);
[[nodiscard]] SpecificRequestBuilder &fail(Fn<void(
[[nodiscard]] SpecificRequestBuilder &fail(FnMut<void(
mtpRequestId,
RPCError &&)> &&handler);
[[nodiscard]] SpecificRequestBuilder &fail(Fn<void(
[[nodiscard]] SpecificRequestBuilder &fail(FnMut<void(
RPCError &&)> &&handler);
#else // _DEBUG
template <typename Handler>
@ -194,20 +190,11 @@ private:
void senderRequestCancel(mtpRequestId requestId);
void senderRequestCancelAll();
const Fn<void(FnMut<void()>)> _run;
const Fn<void(FnMut<void()>)> _runner;
base::flat_map<mtpRequestId, Handlers> _requests;
};
template <typename Type>
ConcurrentSender::ConcurrentSender(const crl::weak_on_queue<Type> &weak)
: ConcurrentSender([=](FnMut<void()> method) {
weak.with([method = std::move(method)](Type&) mutable {
std::move(method)();
});
}) {
}
template <typename Response, typename InvokeFullDone>
void ConcurrentSender::RequestBuilder::setDoneHandler(
InvokeFullDone &&invoke) noexcept {
@ -256,7 +243,7 @@ template <typename Request>
// Allow code completion to show response type.
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::done(
Fn<void(Response &&)> &&handler)
FnMut<void(Response &&)> &&handler)
-> SpecificRequestBuilder & {
setDoneHandler<Response>([handler = std::move(handler)](
mtpRequestId requestId,
@ -268,7 +255,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::done(
Fn<void(mtpRequestId, Response &&)> &&handler)
FnMut<void(mtpRequestId, Response &&)> &&handler)
-> SpecificRequestBuilder & {
setDoneHandler<Response>(std::move(handler));
return *this;
@ -276,7 +263,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::done(
Fn<void(mtpRequestId)> &&handler) -> SpecificRequestBuilder & {
FnMut<void(mtpRequestId)> &&handler) -> SpecificRequestBuilder & {
setDoneHandler<Response>([handler = std::move(handler)](
mtpRequestId requestId,
Response &&result) mutable {
@ -287,7 +274,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::done(
Fn<void()> &&handler) -> SpecificRequestBuilder & {
FnMut<void()> &&handler) -> SpecificRequestBuilder & {
setDoneHandler<Response>([handler = std::move(handler)](
mtpRequestId requestId,
Response &&result) mutable {
@ -298,7 +285,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::fail(
Fn<void(RPCError &&)> &&handler) -> SpecificRequestBuilder & {
FnMut<void(RPCError &&)> &&handler) -> SpecificRequestBuilder & {
setFailHandler([handler = std::move(handler)](
mtpRequestId requestId,
RPCError &&error) mutable {
@ -309,7 +296,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::fail(
Fn<void(mtpRequestId, RPCError &&)> &&handler)
FnMut<void(mtpRequestId, RPCError &&)> &&handler)
-> SpecificRequestBuilder & {
setFailHandler(std::move(handler));
return *this;
@ -317,7 +304,7 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::fail(
Fn<void(mtpRequestId)> &&handler) -> SpecificRequestBuilder & {
FnMut<void(mtpRequestId)> &&handler) -> SpecificRequestBuilder & {
setFailHandler([handler = std::move(handler)](
mtpRequestId requestId,
RPCError &&error) mutable {
@ -328,8 +315,8 @@ template <typename Request>
template <typename Request>
[[nodiscard]] auto ConcurrentSender::SpecificRequestBuilder<Request>::fail(
Fn<void()> &&handler) -> SpecificRequestBuilder & {
setFailHandler([handler = move(handler)](
FnMut<void()> &&handler) -> SpecificRequestBuilder & {
setFailHandler([handler = std::move(handler)](
mtpRequestId requestId,
RPCError &&error) mutable {
std::move(handler)();

26
Telegram/SourceFiles/mtproto/connection.cpp
View File

@ -376,9 +376,9 @@ void ConnectionPrivate::appendTestConnection(
}
int16 ConnectionPrivate::getProtocolDcId() const {
const auto dcId = MTP::bareDcId(_shiftedDcId);
const auto simpleDcId = MTP::isTemporaryDcId(dcId)
? MTP::getRealIdFromTemporaryDcId(dcId)
const auto dcId = BareDcId(_shiftedDcId);
const auto simpleDcId = isTemporaryDcId(dcId)
? getRealIdFromTemporaryDcId(dcId)
: dcId;
const auto testedDcId = cTestMode()
? (kTestModeDcIdShift + simpleDcId)
@ -724,13 +724,13 @@ void ConnectionPrivate::tryToSend() {
int32 state = getState();
bool prependOnly = (state != ConnectedState);
mtpRequest pingRequest;
if (_shiftedDcId == bareDcId(_shiftedDcId)) { // main session
if (_shiftedDcId == BareDcId(_shiftedDcId)) { // main session
if (!prependOnly && !_pingIdToSend && !_pingId && _pingSendAt <= getms(true)) {
_pingIdToSend = rand_value<mtpPingId>();
}
}
if (_pingIdToSend) {
if (prependOnly || _shiftedDcId != bareDcId(_shiftedDcId)) {
if (prependOnly || _shiftedDcId != BareDcId(_shiftedDcId)) {
MTPPing ping(MTPping(MTP_long(_pingIdToSend)));
uint32 pingSize = ping.innerLength() >> 2; // copy from Session::send
pingRequest = mtpRequestData::prepare(pingSize);
@ -748,7 +748,7 @@ void ConnectionPrivate::tryToSend() {
_pingSendAt = pingRequest->msDate + kPingSendAfter;
pingRequest->requestId = 0; // dont add to haveSent / wereAcked maps
if (_shiftedDcId == bareDcId(_shiftedDcId) && !prependOnly) { // main session
if (_shiftedDcId == BareDcId(_shiftedDcId) && !prependOnly) { // main session
_pingSender.callOnce(kPingSendAfterForce);
}
@ -916,7 +916,7 @@ void ConnectionPrivate::tryToSend() {
mtpRequest wrappedRequest(mtpRequestData::prepare(toSendSize));
memcpy(wrappedRequest->data(), toSendRequest->constData(), 7 * sizeof(mtpPrime)); // all except length
wrappedRequest->push_back(mtpc_invokeWithLayer);
wrappedRequest->push_back(MTP::internal::CurrentLayer);
wrappedRequest->push_back(internal::CurrentLayer);
initWrapper.write(*wrappedRequest);
wrappedRequest->resize(wrappedRequest->size() + noWrapSize);
memcpy(wrappedRequest->data() + wrappedRequest->size() - noWrapSize, toSendRequest->constData() + 8, noWrapSize * sizeof(mtpPrime));
@ -948,7 +948,7 @@ void ConnectionPrivate::tryToSend() {
if (willNeedInit) {
initSerialized.reserve(initSizeInInts);
initSerialized.push_back(mtpc_invokeWithLayer);
initSerialized.push_back(MTP::internal::CurrentLayer);
initSerialized.push_back(internal::CurrentLayer);
initWrapper.write(initSerialized);
}
toSendRequest = mtpRequestData::prepare(containerSize, containerSize + 3 * toSend.size()); // prepare container + each in invoke after
@ -1080,7 +1080,7 @@ void ConnectionPrivate::connectToServer(bool afterConfig) {
sessionData->connectionOptions());
hasKey = (sessionData->getKey() != nullptr);
}
auto bareDc = bareDcId(_shiftedDcId);
auto bareDc = BareDcId(_shiftedDcId);
_dcType = _instance->dcOptions()->dcType(_shiftedDcId);
// Use media_only addresses only if key for this dc is already created.
@ -2570,7 +2570,7 @@ void ConnectionPrivate::pqAnswered() {
}
auto rsaKey = internal::RSAPublicKey();
if (!_instance->dcOptions()->getDcRSAKey(bareDcId(_shiftedDcId), res_pq.c_resPQ().vserver_public_key_fingerprints.v, &rsaKey)) {
if (!_instance->dcOptions()->getDcRSAKey(BareDcId(_shiftedDcId), res_pq.c_resPQ().vserver_public_key_fingerprints.v, &rsaKey)) {
if (_dcType == DcType::Cdn) {
LOG(("Warning: CDN public RSA key not found"));
requestCDNConfig();
@ -2587,7 +2587,7 @@ void ConnectionPrivate::pqAnswered() {
auto &pq = res_pq_data.vpq.v;
auto p = QByteArray();
auto q = QByteArray();
if (!MTP::internal::parsePQ(pq, p, q)) {
if (!internal::parsePQ(pq, p, q)) {
LOG(("AuthKey Error: could not factor pq!"));
DEBUG_LOG(("AuthKey Error: problematic pq: %1").arg(Logs::mb(pq.constData(), pq.length()).str()));
return restart();
@ -2624,7 +2624,7 @@ void ConnectionPrivate::pqAnswered() {
bytes::vector ConnectionPrivate::encryptPQInnerRSA(
const MTPP_Q_inner_data &data,
const MTP::internal::RSAPublicKey &key) {
const internal::RSAPublicKey &key) {
auto p_q_inner_size = data.innerLength();
auto encSize = (p_q_inner_size >> 2) + 6;
if (encSize >= 65) {
@ -2880,7 +2880,7 @@ void ConnectionPrivate::dhClientParamsAnswered() {
uint64 salt1 = _authKeyData->new_nonce.l.l, salt2 = _authKeyData->server_nonce.l, serverSalt = salt1 ^ salt2;
sessionData->setSalt(serverSalt);
auto authKey = std::make_shared<AuthKey>(AuthKey::Type::Generated, bareDcId(_shiftedDcId), _authKeyStrings->auth_key);
auto authKey = std::make_shared<AuthKey>(AuthKey::Type::Generated, BareDcId(_shiftedDcId), _authKeyStrings->auth_key);
DEBUG_LOG(("AuthKey Info: auth key gen succeed, id: %1, server salt: %2").arg(authKey->keyId()).arg(serverSalt));

2
Telegram/SourceFiles/mtproto/connection.h
View File

@ -190,7 +190,7 @@ private:
bool setState(int32 state, int32 ifState = Connection::UpdateAlways);
bytes::vector encryptPQInnerRSA(const MTPP_Q_inner_data &data, const MTP::internal::RSAPublicKey &key);
bytes::vector encryptPQInnerRSA(const MTPP_Q_inner_data &data, const internal::RSAPublicKey &key);
std::string encryptClientDHInner(const MTPClient_DH_Inner_Data &data);
void appendTestConnection(
DcOptions::Variants::Protocol protocol,

22
Telegram/SourceFiles/mtproto/core_types.h
View File

@ -24,6 +24,28 @@ namespace MTP {
using DcId = int32;
using ShiftedDcId = int32;
constexpr auto kDcShift = ShiftedDcId(10000);
constexpr auto kConfigDcShift = 0x01;
constexpr auto kLogoutDcShift = 0x02;
constexpr auto kUpdaterDcShift = 0x03;
constexpr auto kExportDcShift = 0x04;
constexpr auto kMaxMediaDcCount = 0x10;
constexpr auto kBaseDownloadDcShift = 0x10;
constexpr auto kBaseUploadDcShift = 0x20;
constexpr auto kDestroyKeyStartDcShift = 0x100;
constexpr DcId BareDcId(ShiftedDcId shiftedDcId) {
return (shiftedDcId % kDcShift);
}
constexpr ShiftedDcId ShiftDcId(DcId dcId, int value) {
return dcId + kDcShift * value;
}
constexpr int GetDcIdShift(ShiftedDcId shiftedDcId) {
return shiftedDcId / kDcShift;
}
} // namespace MTP
using mtpPrime = int32;

8
Telegram/SourceFiles/mtproto/dc_options.cpp
View File

@ -233,7 +233,7 @@ void DcOptions::constructAddOne(
int port,
const bytes::vector &secret) {
WriteLocker lock(this);
applyOneGuarded(bareDcId(id), flags, ip, port, secret);
applyOneGuarded(BareDcId(id), flags, ip, port, secret);
}
bool DcOptions::applyOneGuarded(
@ -525,7 +525,7 @@ DcType DcOptions::dcType(ShiftedDcId shiftedDcId) const {
return DcType::Temporary;
}
ReadLocker lock(this);
if (_cdnDcIds.find(bareDcId(shiftedDcId)) != _cdnDcIds.cend()) {
if (_cdnDcIds.find(BareDcId(shiftedDcId)) != _cdnDcIds.cend()) {
return DcType::Cdn;
}
if (isDownloadDcId(shiftedDcId)) {
@ -642,7 +642,7 @@ void DcOptions::computeCdnDcIds() {
for (auto &item : _data) {
Assert(!item.second.empty());
if (item.second.front().flags & Flag::f_cdn) {
_cdnDcIds.insert(bareDcId(item.first));
_cdnDcIds.insert(BareDcId(item.first));
}
}
}
@ -675,7 +675,7 @@ bool DcOptions::loadFromFile(const QString &path) {
auto ip = components[1];
auto port = components[2].toInt();
auto host = QHostAddress();
if (dcId <= 0 || dcId >= internal::kDcShift || !host.setAddress(ip) || port <= 0) {
if (dcId <= 0 || dcId >= kDcShift || !host.setAddress(ip) || port <= 0) {
return error();
}
auto flags = Flags(0);

50
Telegram/SourceFiles/mtproto/facade.h
View File

@ -18,15 +18,6 @@ bool paused();
void pause();
void unpause();
constexpr auto kDcShift = ShiftedDcId(10000);
constexpr auto kConfigDcShift = 0x01;
constexpr auto kLogoutDcShift = 0x02;
constexpr auto kUpdaterDcShift = 0x03;
constexpr auto kMaxMediaDcCount = 0x10;
constexpr auto kBaseDownloadDcShift = 0x10;
constexpr auto kBaseUploadDcShift = 0x20;
constexpr auto kDestroyKeyStartDcShift = 0x100;
} // namespace internal
class PauseHolder {
@ -53,29 +44,19 @@ private:
};
constexpr DcId bareDcId(ShiftedDcId shiftedDcId) {
return (shiftedDcId % internal::kDcShift);
}
constexpr ShiftedDcId shiftDcId(DcId dcId, int value) {
return dcId + internal::kDcShift * value;
}
constexpr int getDcIdShift(ShiftedDcId shiftedDcId) {
return shiftedDcId / internal::kDcShift;
}
// send(MTPhelp_GetConfig(), MTP::configDcId(dc)) - for dc enumeration
constexpr ShiftedDcId configDcId(DcId dcId) {
return shiftDcId(dcId, internal::kConfigDcShift);
return ShiftDcId(dcId, kConfigDcShift);
}
// send(MTPauth_LogOut(), MTP::logoutDcId(dc)) - for logout of guest dcs enumeration
constexpr ShiftedDcId logoutDcId(DcId dcId) {
return shiftDcId(dcId, internal::kLogoutDcShift);
return ShiftDcId(dcId, kLogoutDcShift);
}
// send(MTPupload_GetFile(), MTP::updaterDcId(dc)) - for autoupdater
constexpr ShiftedDcId updaterDcId(DcId dcId) {
return shiftDcId(dcId, internal::kUpdaterDcShift);
return ShiftDcId(dcId, kUpdaterDcShift);
}
constexpr auto kDownloadSessionsCount = 2;
@ -84,8 +65,8 @@ constexpr auto kUploadSessionsCount = 2;
namespace internal {
constexpr ShiftedDcId downloadDcId(DcId dcId, int index) {
static_assert(kDownloadSessionsCount < internal::kMaxMediaDcCount, "Too large MTPDownloadSessionsCount!");
return shiftDcId(dcId, internal::kBaseDownloadDcShift + index);
static_assert(kDownloadSessionsCount < kMaxMediaDcCount, "Too large MTPDownloadSessionsCount!");
return ShiftDcId(dcId, kBaseDownloadDcShift + index);
};
} // namespace internal
@ -97,7 +78,7 @@ inline ShiftedDcId downloadDcId(DcId dcId, int index) {
}
inline constexpr bool isDownloadDcId(ShiftedDcId shiftedDcId) {
return (shiftedDcId >= internal::downloadDcId(0, 0)) && (shiftedDcId < internal::downloadDcId(0, kDownloadSessionsCount - 1) + internal::kDcShift);
return (shiftedDcId >= internal::downloadDcId(0, 0)) && (shiftedDcId < internal::downloadDcId(0, kDownloadSessionsCount - 1) + kDcShift);
}
inline bool isCdnDc(MTPDdcOption::Flags flags) {
@ -105,43 +86,44 @@ inline bool isCdnDc(MTPDdcOption::Flags flags) {
}
inline bool isTemporaryDcId(ShiftedDcId shiftedDcId) {
auto dcId = bareDcId(shiftedDcId);
auto dcId = BareDcId(shiftedDcId);
return (dcId >= Instance::Config::kTemporaryMainDc);
}
inline DcId getRealIdFromTemporaryDcId(ShiftedDcId shiftedDcId) {
auto dcId = bareDcId(shiftedDcId);
auto dcId = BareDcId(shiftedDcId);
return (dcId >= Instance::Config::kTemporaryMainDc) ? (dcId - Instance::Config::kTemporaryMainDc) : 0;
}
inline DcId getTemporaryIdFromRealDcId(ShiftedDcId shiftedDcId) {
auto dcId = bareDcId(shiftedDcId);
auto dcId = BareDcId(shiftedDcId);
return (dcId < Instance::Config::kTemporaryMainDc) ? (dcId + Instance::Config::kTemporaryMainDc) : 0;
}
namespace internal {
constexpr ShiftedDcId uploadDcId(DcId dcId, int index) {
static_assert(kUploadSessionsCount < internal::kMaxMediaDcCount, "Too large MTPUploadSessionsCount!");
return shiftDcId(dcId, internal::kBaseUploadDcShift + index);
static_assert(kUploadSessionsCount < kMaxMediaDcCount, "Too large MTPUploadSessionsCount!");
return ShiftDcId(dcId, kBaseUploadDcShift + index);
};
} // namespace internal
// send(req, callbacks, MTP::uploadDcId(index)) - for upload shifted dc id
// uploading always to the main dc so bareDcId == 0
// uploading always to the main dc so BareDcId(result) == 0
inline ShiftedDcId uploadDcId(int index) {
Expects(index >= 0 && index < kUploadSessionsCount);
return internal::uploadDcId(0, index);
};
constexpr bool isUploadDcId(ShiftedDcId shiftedDcId) {
return (shiftedDcId >= internal::uploadDcId(0, 0)) && (shiftedDcId < internal::uploadDcId(0, kUploadSessionsCount - 1) + internal::kDcShift);
return (shiftedDcId >= internal::uploadDcId(0, 0)) && (shiftedDcId < internal::uploadDcId(0, kUploadSessionsCount - 1) + kDcShift);
}
inline ShiftedDcId destroyKeyNextDcId(ShiftedDcId shiftedDcId) {
auto shift = getDcIdShift(shiftedDcId);
return shiftDcId(bareDcId(shiftedDcId), shift ? (shift + 1) : internal::kDestroyKeyStartDcShift);
const auto shift = GetDcIdShift(shiftedDcId);
return ShiftDcId(BareDcId(shiftedDcId), shift ? (shift + 1) : kDestroyKeyStartDcShift);
}
enum {

32
Telegram/SourceFiles/mtproto/mtp_instance.cpp
View File

@ -460,9 +460,9 @@ void Instance::Private::restart() {
}
void Instance::Private::restart(ShiftedDcId shiftedDcId) {
auto dcId = bareDcId(shiftedDcId);
auto dcId = BareDcId(shiftedDcId);
for (auto &session : _sessions) {
if (bareDcId(session.second->getDcWithShift()) == dcId) {
if (BareDcId(session.second->getDcWithShift()) == dcId) {
session.second->restart();
}
}
@ -474,9 +474,9 @@ int32 Instance::Private::dcstate(ShiftedDcId shiftedDcId) {
return _mainSession->getState();
}
if (!bareDcId(shiftedDcId)) {
if (!BareDcId(shiftedDcId)) {
Assert(_mainSession != nullptr);
shiftedDcId += bareDcId(_mainSession->getDcWithShift());
shiftedDcId += BareDcId(_mainSession->getDcWithShift());
}
auto it = _sessions.find(shiftedDcId);
@ -492,9 +492,9 @@ QString Instance::Private::dctransport(ShiftedDcId shiftedDcId) {
Assert(_mainSession != nullptr);
return _mainSession->transport();
}
if (!bareDcId(shiftedDcId)) {
if (!BareDcId(shiftedDcId)) {
Assert(_mainSession != nullptr);
shiftedDcId += bareDcId(_mainSession->getDcWithShift());
shiftedDcId += BareDcId(_mainSession->getDcWithShift());
}
auto it = _sessions.find(shiftedDcId);
@ -583,7 +583,7 @@ void Instance::Private::stopSession(ShiftedDcId shiftedDcId) {
void Instance::Private::reInitConnection(DcId dcId) {
for (auto &session : _sessions) {
if (bareDcId(session.second->getDcWithShift()) == dcId) {
if (BareDcId(session.second->getDcWithShift()) == dcId) {
session.second->reInitConnection();
}
}
@ -632,7 +632,7 @@ bool Instance::Private::logoutGuestDone(mtpRequestId requestId) {
std::shared_ptr<internal::Dcenter> Instance::Private::getDcById(ShiftedDcId shiftedDcId) {
auto it = _dcenters.find(shiftedDcId);
if (it == _dcenters.cend()) {
auto dcId = bareDcId(shiftedDcId);
auto dcId = BareDcId(shiftedDcId);
if (isTemporaryDcId(dcId)) {
if (auto realDcId = getRealIdFromTemporaryDcId(dcId)) {
dcId = realDcId;
@ -809,7 +809,7 @@ base::optional<ShiftedDcId> Instance::Private::changeRequestByDc(
if (it->second < 0) {
it->second = -newdc;
} else {
it->second = shiftDcId(newdc, getDcIdShift(it->second));
it->second = ShiftDcId(newdc, GetDcIdShift(it->second));
}
return it->second;
}
@ -1081,7 +1081,7 @@ void Instance::Private::importDone(const MTPauth_Authorization &result, mtpReque
//}
return;
}
auto newdc = bareDcId(*shiftedDcId);
auto newdc = BareDcId(*shiftedDcId);
DEBUG_LOG(("MTP Info: auth import to dc %1 succeeded").arg(newdc));
@ -1149,7 +1149,7 @@ bool Instance::Private::exportFail(const RPCError &error, mtpRequestId requestId
auto it = _authExportRequests.find(requestId);
if (it != _authExportRequests.cend()) {
_authWaiters[bareDcId(it->second)].clear();
_authWaiters[BareDcId(it->second)].clear();
}
//
// Don't log out on export/import problems, perhaps this is a server side error.
@ -1203,7 +1203,7 @@ bool Instance::Private::onErrorDefault(mtpRequestId requestId, const RPCError &e
_instance->setMainDcId(newdcWithShift);
}
} else {
newdcWithShift = shiftDcId(newdcWithShift, getDcIdShift(dcWithShift));
newdcWithShift = ShiftDcId(newdcWithShift, GetDcIdShift(dcWithShift));
}
auto request = mtpRequest();
@ -1255,7 +1255,7 @@ bool Instance::Private::onErrorDefault(mtpRequestId requestId, const RPCError &e
} else {
LOG(("MTP Error: unauthorized request without dc info, requestId %1").arg(requestId));
}
auto newdc = bareDcId(qAbs(dcWithShift));
auto newdc = BareDcId(qAbs(dcWithShift));
if (!newdc || newdc == mainDcId() || !hasAuthorization()) {
if (!badGuestDc && _globalHandler.onFail) {
(*_globalHandler.onFail)(requestId, error); // auth failed in main dc
@ -1336,7 +1336,7 @@ bool Instance::Private::onErrorDefault(mtpRequestId requestId, const RPCError &e
request->needsLayer = true;
session->sendPrepared(request);
} else {
auto newdc = bareDcId(qAbs(dcWithShift));
auto newdc = BareDcId(qAbs(dcWithShift));
auto &waiters(_authWaiters[newdc]);
if (base::contains(waiters, request->after->requestId)) {
if (!base::contains(waiters, requestId)) {
@ -1372,9 +1372,9 @@ not_null<internal::Session*> Instance::Private::getSession(
Assert(_mainSession != nullptr);
return _mainSession;
}
if (!bareDcId(shiftedDcId)) {
if (!BareDcId(shiftedDcId)) {
Assert(_mainSession != nullptr);
shiftedDcId += bareDcId(_mainSession->getDcWithShift());
shiftedDcId += BareDcId(_mainSession->getDcWithShift());
}
auto it = _sessions.find(shiftedDcId);

2
Telegram/SourceFiles/mtproto/session.cpp
View File

@ -596,7 +596,7 @@ void Session::tryToReceive() {
}
}
if (isUpdate) {
if (dcWithShift == bareDcId(dcWithShift)) { // call globalCallback only in main session
if (dcWithShift == BareDcId(dcWithShift)) { // call globalCallback only in main session
_instance->globalCallback(message.constData(), message.constData() + message.size());
}
} else {

2
Telegram/gyp/lib_export.gyp
View File

@ -50,6 +50,8 @@
'<(submodules_loc)/crl/src',
],
'sources': [
'<(src_loc)/export/export_api_wrap.cpp',
'<(src_loc)/export/export_api_wrap.h',
'<(src_loc)/export/export_controller.cpp',
'<(src_loc)/export/export_controller.h',
'<(src_loc)/export/export_settings.h',