NetworkServicePImpl(int port, IPVersion version)
: localEndpoint(version == IPVersion::IPv4 ? asio::ip::udp::v4() : asio::ip::udp::v6(), port)
, socket(service, localEndpoint)
{
Expects(port == 0 || port > 1024);
Expects(port < 65536);
}
std::unique_ptr<uint8_t[]> DecodeTga(array_view<uint8_t> data) {
if (data.size() < sizeof(TgaHeader)) {
throw TempleException("Not enough data for TGA header");
}
auto header = reinterpret_cast<const TgaHeader*>(data.data());
if (header->colorMapType != TgaColorMapType::TrueColor) {
throw TempleException("Only true color TGA images are supported.");
}
if (header->dataType != TgaDataType::UncompressedRgb) {
throw TempleException("Only uncompressed RGB TGA images are supported.");
}
if (header->bpp != 24 && header->bpp != 32) {
throw TempleException("Only uncompressed RGB 24-bpp or 32-bpp TGA images are supported.");
}
auto result(std::make_unique<uint8_t[]>(header->width * header->height * 4));
auto dest = result.get();
// Points to the start of the TGA image data
auto srcStart = data.data() + sizeof(TgaHeader) + header->imageIdLength;
auto srcSize = data.size() - sizeof(TgaHeader) - header->imageIdLength;
if (header->bpp == 24) {
auto srcPitch = header->width * 3;
Expects((int) srcSize >= header->height * srcPitch);
for (int y = 0; y < header->height; ++y) {
auto src = srcStart + (header->height - y - 1) * srcPitch;
for (int x = 0; x < header->width; ++x) {
*dest++ = *src++;
*dest++ = *src++;
*dest++ = *src++;
*dest++ = 0xFF; // Fixed alpha
}
}
} else {
auto srcPitch = header->width * 4;
Expects((int) srcSize >= header->height * srcPitch);
for (int y = 0; y < header->height; ++y) {
auto src = srcStart + (header->height - y - 1) * srcPitch;
for (int x = 0; x < header->width; ++x) {
*dest++ = *src++;
*dest++ = *src++;
*dest++ = *src++;
*dest++ = *src++;
}
}
}
return result;
}
void Element::attachToBlock(not_null<HistoryBlock*> block, int index) {
Expects(!_data->isLogEntry());
Expects(_block == nullptr);
Expects(_indexInBlock < 0);
Expects(index >= 0);
_block = block;
_indexInBlock = index;
_data->setMainView(this);
previousInBlocksChanged();
}
void PeerListContent::appendSearchRow(std::unique_ptr<PeerListRow> row) {
Expects(row != nullptr);
Expects(showingSearch());
if (_rowsById.find(row->id()) == _rowsById.cend()) {
row->setAbsoluteIndex(_searchRows.size());
row->setIsSearchResult(true);
addRowEntry(row.get());
_filterResults.push_back(row.get());
_searchRows.push_back(std::move(row));
}
}
void MessagesList::Slice::merge(
const Range &moreMessages,
MessagesRange moreNoSkipRange) {
Expects(moreNoSkipRange.from <= range.till);
Expects(range.from <= moreNoSkipRange.till);
messages.merge(std::begin(moreMessages), std::end(moreMessages));
range = {
qMin(range.from, moreNoSkipRange.from),
qMax(range.till, moreNoSkipRange.till)
};
}
AasAnimatedModelFactory::AasAnimatedModelFactory(const AasConfig& config) : mConfig(config) {
Expects(!sInstance);
sInstance = this;
LegacyAasConfig legacyConfig;
legacyConfig.scaleX = config.scaleX;
legacyConfig.scaleY = config.scaleY;
legacyConfig.getSkaFilename = [](int meshId, char* filenameOut) -> AasStatus {
if (sInstance->mConfig.resolveSkaFile) {
auto filename(sInstance->mConfig.resolveSkaFile(meshId));
if (!filename.empty()) {
Expects(filename.size() < MAX_PATH);
strncpy(filenameOut, filename.c_str(), MAX_PATH);
return AAS_OK;
}
}
return AAS_ERROR;
};
legacyConfig.getSkmFilename = [](int meshId, char* filenameOut) -> AasStatus {
if (sInstance->mConfig.resolveSkmFile) {
auto filename(sInstance->mConfig.resolveSkmFile(meshId));
if (!filename.empty()) {
Expects(filename.size() < MAX_PATH);
strncpy(filenameOut, filename.c_str(), MAX_PATH);
return AAS_OK;
}
}
return AAS_ERROR;
};
legacyConfig.runScript = [](const char* script) {
if (sInstance->mConfig.runScript) {
sInstance->mConfig.runScript(script);
}
};
if (functions.Init(&legacyConfig)) {
throw TempleException("Unable to initialize the animation system.");
}
// The MDF resolver is not configurable, so we have to set it here manually
MH_CreateHook(temple::GetPointer<void*>(0x10269430), &AasResolveMaterial, nullptr);
MH_CreateHook(functions.Free, &AasFreeModel, (void**)&mOrgModelFree);
MH_EnableHook(nullptr);
auto meshesMapping = MesFile::ParseFile("art/meshes/meshes.mes");
mMapping.insert(meshesMapping.begin(), meshesMapping.end());
logger->debug("Loaded mapping for {} meshes from art/meshes/meshes.mes",
meshesMapping.size());
}
void Controller::replaceFloatPlayerDelegate(
not_null<Media::Player::FloatDelegate*> replacement) {
Expects(_floatPlayers != nullptr);
_replacementFloatPlayerDelegate = replacement;
_floatPlayers->replaceDelegate(replacement);
}
void ChangePhoneBox::EnterPhone::sendPhoneDone(const QString &phoneNumber, const MTPauth_SentCode &result) {
Expects(result.type() == mtpc_auth_sentCode);
_requestId = 0;
auto codeLength = 0;
auto &data = result.c_auth_sentCode();
switch (data.vtype.type()) {
case mtpc_auth_sentCodeTypeApp:
LOG(("Error: should not be in-app code!"));
showError(Lang::Hard::ServerError());
return;
case mtpc_auth_sentCodeTypeSms: codeLength = data.vtype.c_auth_sentCodeTypeSms().vlength.v; break;
case mtpc_auth_sentCodeTypeCall: codeLength = data.vtype.c_auth_sentCodeTypeCall().vlength.v; break;
case mtpc_auth_sentCodeTypeFlashCall:
LOG(("Error: should not be flashcall!"));
showError(Lang::Hard::ServerError());
return;
}
auto phoneCodeHash = qs(data.vphone_code_hash);
auto callTimeout = 0;
if (data.has_next_type() && data.vnext_type.type() == mtpc_auth_codeTypeCall) {
callTimeout = data.has_timeout() ? data.vtimeout.v : 60;
}
Ui::show(
Box<EnterCode>(
phoneNumber,
phoneCodeHash,
codeLength,
callTimeout),
LayerOption::KeepOther);
}
void CodeWidget::gotPassword(const MTPaccount_Password &result) {
Expects(result.type() == mtpc_account_password);
stopCheck();
_sentRequest = 0;
const auto &d = result.c_account_password();
getData()->pwdRequest = Core::ParseCloudPasswordCheckRequest(d);
if (!d.has_current_algo() || !d.has_srp_id() || !d.has_srp_B()) {
LOG(("API Error: No current password received on login."));
_code->setFocus();
return;
} else if (!getData()->pwdRequest) {
const auto box = std::make_shared<QPointer<BoxContent>>();
const auto callback = [=] {
Core::UpdateApplication();
if (*box) (*box)->closeBox();
};
*box = Ui::show(Box<ConfirmBox>(
lang(lng_passport_app_out_of_date),
lang(lng_menu_update),
callback));
return;
}
getData()->hasRecovery = d.is_has_recovery();
getData()->pwdHint = qs(d.vhint);
getData()->pwdNotEmptyPassport = d.is_has_secure_values();
goReplace(new Intro::PwdCheckWidget(parentWidget(), getData()));
}
std::unique_ptr<ContentMemento> Memento::DefaultContent(
PeerId peerId,
Section section) {
Expects(peerId != 0);
auto peer = Auth().data().peer(peerId);
if (auto to = peer->migrateTo()) {
peer = to;
}
auto migrated = peer->migrateFrom();
peerId = peer->id;
auto migratedPeerId = migrated ? migrated->id : PeerId(0);
switch (section.type()) {
case Section::Type::Profile:
return std::make_unique<Profile::Memento>(
peerId,
migratedPeerId);
case Section::Type::Media:
return std::make_unique<Media::Memento>(
peerId,
migratedPeerId,
section.mediaType());
case Section::Type::CommonGroups:
Assert(peerIsUser(peerId));
return std::make_unique<CommonGroups::Memento>(
peerToUser(peerId));
case Section::Type::Members:
return std::make_unique<Members::Memento>(
peerId,
migratedPeerId);
}
Unexpected("Wrong section type in Info::Memento::DefaultContent()");
}
void Entry::removeChatListEntryByLetter(Mode list, QChar letter) {
Expects(letter != 0);
if (inChatList(list)) {
chatListLinks(list).remove(letter);
}
}
rpl::producer<SparseIdsMergedSlice> SearchController::idsSlice(
SparseIdsMergedSlice::UniversalMsgId aroundId,
int limitBefore,
int limitAfter) {
Expects(_current != _cache.cend());
auto query = (const Query&)_current->first;
auto createSimpleViewer = [=](
PeerId peerId,
SparseIdsSlice::Key simpleKey,
int limitBefore,
int limitAfter) {
return simpleIdsSlice(
peerId,
simpleKey,
query,
limitBefore,
limitAfter);
};
return SparseIdsMergedSlice::CreateViewer(
SparseIdsMergedSlice::Key(
query.peerId,
query.migratedPeerId,
aroundId),
limitBefore,
limitAfter,
std::move(createSimpleViewer));
}
void MessagesList::addRange(
const Range &messages,
MessagesRange noSkipRange,
std::optional<int> count,
bool incrementCount) {
Expects(!count || !incrementCount);
auto wasCount = _count;
auto update = MessagesSliceUpdate();
auto result = addRangeItemsAndCountNew(
update,
messages,
noSkipRange);
if (count) {
_count = count;
} else if (incrementCount && _count && result > 0) {
*_count += result;
}
if (_slices.size() == 1) {
if (_slices.front().range == FullMessagesRange) {
_count = _slices.front().messages.size();
}
}
update.count = _count;
_sliceUpdated.fire(std::move(update));
}
AasRenderer::AasRenderer(AasAnimatedModelFactory &aasFactory,
RenderingDevice& device,
ShapeRenderer2d &shapeRenderer2d,
ShapeRenderer3d &shapeRenderer3d,
MdfMaterialFactory &mdfFactory)
: mDevice(device),
mMdfFactory(mdfFactory),
mShapeRenderer2d(shapeRenderer2d),
mShapeRenderer3d(shapeRenderer3d),
mAasFactory(aasFactory),
mGeometryShadowMaterial(CreateGeometryShadowMaterial(device)),
mShadowTarget(device.CreateRenderTargetTexture(D3DFMT_A8R8G8B8, ShadowMapWidth, ShadowMapHeight)),
mShadowTargetTmp(device.CreateRenderTargetTexture(D3DFMT_A8R8G8B8, ShadowMapWidth, ShadowMapHeight)),
mShadowMapMaterial(CreateShadowMapMaterial(device)),
mGaussBlurHor(CreateGaussBlurMaterial(device, mShadowTarget, true)),
mGaussBlurVer(CreateGaussBlurMaterial(device, mShadowTargetTmp, false)) {
Expects(!aasRenderer);
/*
When an AAS handle is freed by the factory, remove all associated
rendering data here as well.
*/
mListenerHandle = aasFactory.AddFreeListener([&](AasHandle handle) {
auto it = mRenderDataCache.find(handle);
if (it != mRenderDataCache.end()) {
mRenderDataCache.erase(it);
}
});
}
object_ptr<TabbedSelector::InnerFooter> GifsListWidget::createFooter() {
Expects(_footer == nullptr);
auto result = object_ptr<Footer>(this);
_footer = result;
return std::move(result);
}
int MessagesList::addRangeItemsAndCountNew(
MessagesSliceUpdate &update,
const Range &messages,
MessagesRange noSkipRange) {
Expects(noSkipRange.from <= noSkipRange.till);
auto uniteFrom = ranges::lower_bound(
_slices,
noSkipRange.from,
std::less<>(),
[](const Slice &slice) { return slice.range.till; });
auto uniteTill = ranges::upper_bound(
_slices,
noSkipRange.till,
std::less<>(),
[](const Slice &slice) { return slice.range.from; });
if (uniteFrom < uniteTill) {
return uniteAndAdd(update, uniteFrom, uniteTill, messages, noSkipRange);
}
auto sliceMessages = base::flat_set<MessagePosition> {
std::begin(messages),
std::end(messages) };
auto slice = _slices.emplace(
std::move(sliceMessages),
noSkipRange
).first;
update.messages = &slice->messages;
update.range = slice->range;
return slice->messages.size();
}
PeerListBox::PeerListBox(
QWidget*,
std::unique_ptr<PeerListController> controller,
base::lambda<void(not_null<PeerListBox*>)> init)
: _controller(std::move(controller))
, _init(std::move(init)) {
Expects(_controller != nullptr);
}
void PeerListContent::appendFoundRow(not_null<PeerListRow*> row) {
Expects(showingSearch());
auto index = findRowIndex(row);
if (index.value < 0) {
_filterResults.push_back(row);
}
}
Header Header::parse(const char* data)
{
Expects(data != nullptr);
return Header{
static_cast<Transport_code>(data[0]),
*(reinterpret_cast<const uint32_t*>(&data[1]))
};
}
std::pair<std::string, std::string> LedToken::split(const Delimiter& del) const
{
Expects(value.size() >= 3);
const auto first_of_del = value.find_first_of(del);
Expects(first_of_del != std::string::npos);
Expects(first_of_del != 0);
Expects(first_of_del != value.size() - 1);
const auto& split_point = value.begin() + first_of_del;
auto left = std::string{value.begin(), split_point};
auto right = std::string{split_point + 1, value.end()};
return std::make_pair(left, right);
}
void Controller::setDefaultFloatPlayerDelegate(
not_null<Media::Player::FloatDelegate*> delegate) {
Expects(_defaultFloatPlayerDelegate == nullptr);
_defaultFloatPlayerDelegate = delegate;
_floatPlayers = std::make_unique<Media::Player::FloatController>(
delegate);
_floatPlayers->closeEvents();
}
void BinlogWrapper::finish(size_type rollback) {
Expects(rollback >= 0);
if (rollback > 0) {
_failed = true;
}
rollback += _part.size();
_binlog.seek(_binlog.offset() - rollback);
}
void Ethernet::receive(Packet_ptr pckt) {
Expects(pckt->size() > 0);
header* eth = reinterpret_cast<header*>(pckt->buffer());
/** Do we pass on ethernet headers? As for now, yes.
data += sizeof(header);
len -= sizeof(header);
*/
debug2("<Ethernet IN> %s => %s , Eth.type: 0x%x ",
eth->src.str().c_str(), eth->dest.str().c_str(), eth->type);
// Stat increment packets received
packets_rx_++;
bool dropped = false;
switch(eth->type) {
case ETH_IP4:
debug2("IPv4 packet\n");
ip4_upstream_(std::move(pckt));
break;
case ETH_IP6:
debug2("IPv6 packet\n");
ip6_upstream_(std::move(pckt));
break;
case ETH_ARP:
debug2("ARP packet\n");
arp_upstream_(std::move(pckt));
break;
case ETH_WOL:
dropped = true;
debug2("Wake-on-LAN packet\n");
break;
case ETH_VLAN:
dropped = true;
debug("VLAN tagged frame (not yet supported)");
break;
default:
dropped = true;
// This might be 802.3 LLC traffic
if (net::ntohs(eth->type) > 1500) {
debug2("<Ethernet> UNKNOWN ethertype 0x%x\n", ntohs(eth->type));
}else {
debug2("IEEE802.3 Length field: 0x%x\n", ntohs(eth->type));
}
break;
}
if(dropped)
packets_dropped_++;
}
void Ethernet::transmit(net::Packet_ptr pckt)
{
auto* hdr = reinterpret_cast<header*>(pckt->buffer());
// Verify ethernet header
Expects(hdr->dest.major != 0 || hdr->dest.minor !=0);
Expects(hdr->type != 0);
// Add source address
hdr->src = mac_;
debug2("<Ethernet OUT> Transmitting %i b, from %s -> %s. Type: %i\n",
pckt->size(), mac_.str().c_str(), hdr->dest.str().c_str(), hdr->type);
// Stat increment packets transmitted
packets_tx_++;
physical_downstream_(std::move(pckt));
}
void PeerListContent::prependRow(std::unique_ptr<PeerListRow> row) {
Expects(row != nullptr);
if (_rowsById.find(row->id()) == _rowsById.cend()) {
addRowEntry(row.get());
_rows.insert(_rows.begin(), std::move(row));
refreshIndices();
}
}
void PeerListContent::appendRow(std::unique_ptr<PeerListRow> row) {
Expects(row != nullptr);
if (_rowsById.find(row->id()) == _rowsById.cend()) {
row->setAbsoluteIndex(_rows.size());
addRowEntry(row.get());
_rows.push_back(std::move(row));
}
}
void Controller::restoreFloatPlayerDelegate(
not_null<Media::Player::FloatDelegate*> replacement) {
Expects(_floatPlayers != nullptr);
if (_replacementFloatPlayerDelegate == replacement) {
_replacementFloatPlayerDelegate = nullptr;
_floatPlayers->replaceDelegate(_defaultFloatPlayerDelegate);
}
}
void computeFingerprint() {
Expects(isValid());
mtpBuffer string;
MTP_bytes(toBytes(_rsa->n)).write(string);
MTP_bytes(toBytes(_rsa->e)).write(string);
uchar sha1Buffer[20];
_fingerprint = *(uint64*)(hashSha1(&string[0], string.size() * sizeof(mtpPrime), sha1Buffer) + 3);
}
SharedMediaWithLastSlice::Value SharedMediaWithLastSlice::operator[](int index) const {
Expects(index >= 0 && index < size());
if (_reversed) {
index = size() - index - 1;
}
return (index < _slice.size())
? Value(_slice[index])
: Value(Auth().data().photo(*_lastPhotoId));
}
void calculate_candidates(
grid::const_span<symbol_type> sudoku,
grid::index_type cell_index,
candidate_set& candidates)
{
Expects(candidates.size() == constants::symbols.size());
clear(candidates);
for (auto i = decltype(constants::symbols.size()){0}; i < constants::symbols.size(); ++i)
candidates[i] = digit_is_candidate(sudoku, cell_index, constants::symbols[i]);
}
