tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix tdutils after merge.

Browse Source 
GitOrigin-RevId: 3eceb2e574a737a78dc5414e535e416c86d23f7a
This commit is contained in:
levlam 2019-08-13 23:52:54 +03:00
parent c99486e667
commit bb24ec0629
21 changed files with 106 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
td/telegram/files/FileDownloader.cpp
View File

@ -331,16 +331,15 @@ Result<size_t> FileDownloader::process_part(Part part, NetQueryPtr net_query) {
// Encryption
if (need_cdn_decrypt) {
UInt128 iv = as<UInt128>(cdn_encryption_iv_.c_str());
CHECK(part.offset % 16 == 0);
auto offset = narrow_cast<uint32>(part.offset / 16);
offset =
((offset & 0xff) << 24) | ((offset & 0xff00) << 8) | ((offset & 0xff0000) >> 8) | ((offset & 0xff000000) >> 24);
as<uint32>(iv.raw + 12) = offset;
UInt256 key = as<UInt256>(cdn_encryption_key_.c_str());
AesCtrState ctr_state;
ctr_state.init(as_slice(key), as_slice(iv));
string iv = cdn_encryption_iv_;
as<uint32>(&iv[12]) = offset;
ctr_state.init(cdn_encryption_key_, iv);
ctr_state.decrypt(bytes.as_slice(), bytes.as_slice());
}
if (encryption_key_.is_secret()) {

14
tdactor/test/actors_main.cpp
View File

@ -481,7 +481,7 @@ class XContext : public ActorContext {
int x = 1234;
};
class WithContext : public Actor {
class WithXContext : public Actor {
public:
void start_up() override {
set_context(std::make_shared<XContext>());
@ -491,8 +491,6 @@ class WithContext : public Actor {
void close() {
stop();
}
private:
};
void check_context() {
@ -510,11 +508,11 @@ TEST(Actors, context_during_destruction) {
{
auto guard = sched.get_main_guard();
auto with_context = create_actor<WithContext>("WithContext").release();
send_closure(with_context, &WithContext::f, create_lambda_guard([] { check_context(); }));
send_closure_later(with_context, &WithContext::close);
send_closure(with_context, &WithContext::f, create_lambda_guard([] { check_context(); }));
send_closure(with_context, &WithContext::f, create_lambda_guard([] { Scheduler::instance()->finish(); }));
auto with_context = create_actor<WithXContext>("WithXContext").release();
send_closure(with_context, &WithXContext::f, create_lambda_guard([] { check_context(); }));
send_closure_later(with_context, &WithXContext::close);
send_closure(with_context, &WithXContext::f, create_lambda_guard([] { check_context(); }));
send_closure(with_context, &WithXContext::f, create_lambda_guard([] { Scheduler::instance()->finish(); }));
}
sched.start();
while (sched.run_main(10)) {

11
tdutils/CMakeLists.txt
View File

@ -99,17 +99,17 @@ set(TDUTILS_SOURCE
td/utils/MpmcQueue.cpp
td/utils/OptionsParser.cpp
td/utils/Random.cpp
td/utils/Slice.cpp
td/utils/SharedSlice.cpp
td/utils/Slice.cpp
td/utils/StackAllocator.cpp
td/utils/Status.cpp
td/utils/StringBuilder.cpp
td/utils/tests.cpp
td/utils/Time.cpp
td/utils/Timer.cpp
td/utils/TsFileLog.cpp
td/utils/tests.cpp
td/utils/tl_parsers.cpp
td/utils/translit.cpp
td/utils/TsFileLog.cpp
td/utils/unicode.cpp
td/utils/utf8.cpp
@ -220,6 +220,7 @@ set(TDUTILS_SOURCE
td/utils/Random.h
td/utils/ScopeGuard.h
td/utils/SharedObjectPool.h
td/utils/SharedSlice.h
td/utils/Slice-decl.h
td/utils/Slice.h
td/utils/Span.h
@ -230,15 +231,16 @@ set(TDUTILS_SOURCE
td/utils/StorerBase.h
td/utils/StringBuilder.h
td/utils/tests.h
td/utils/ThreadLocalStorage.h
td/utils/ThreadSafeCounter.h
td/utils/Time.h
td/utils/TimedStat.h
td/utils/Timer.h
td/utils/TsFileLog.h
td/utils/tl_helpers.h
td/utils/tl_parsers.h
td/utils/tl_storers.h
td/utils/translit.h
td/utils/TsFileLog.h
td/utils/type_traits.h
td/utils/UInt.h
td/utils/uint128.h
@ -254,6 +256,7 @@ set(TDUTILS_TEST_SOURCE
${CMAKE_CURRENT_SOURCE_DIR}/test/ConcurrentHashMap.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/crypto.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/Enumerator.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/EpochBasedMemoryReclamation.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/filesystem.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/gzip.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/HazardPointers.cpp

2
tdutils/td/utils/FileLog.h
View File

@ -37,7 +37,7 @@ class FileLog : public LogInterface {
string path_;
int64 size_ = 0;
int64 rotate_threshold_ = 0;
bool redirect_stderr_;
bool redirect_stderr_ = false;
void do_rotate();
};

2
tdutils/td/utils/SharedSlice.cpp
View File

@ -11,7 +11,7 @@
namespace td {
BufferSlice SharedSlice::clone_as_buffer_slice() const {
return BufferSlice{as_slice().str()};
return BufferSlice{as_slice()};
}
} // namespace td

13
tdutils/td/utils/SharedSlice.h
View File

@ -15,7 +15,7 @@ namespace td {
namespace detail {
struct SharedSliceHeader {
explicit SharedSliceHeader(size_t size) : refcnt_{1}, size_{size} {
explicit SharedSliceHeader(size_t size) : size_{size} {
}
void inc() {
@ -37,7 +37,7 @@ struct SharedSliceHeader {
}
private:
std::atomic<uint64> refcnt_;
std::atomic<uint64> refcnt_{1};
size_t size_;
};
@ -107,9 +107,9 @@ class UnsafeSharedSlice {
static UnsafeSharedSlice create(size_t size) {
static_assert(std::is_standard_layout<HeaderT>::value, "HeaderT must have statdard layout");
auto ptr = std::make_unique<char[]>(size + sizeof(HeaderT));
auto ptr = std::make_unique<char[]>(sizeof(HeaderT) + size);
auto header_ptr = new (ptr.get()) HeaderT(size);
CHECK(reinterpret_cast<char *>(header_ptr) == ptr.get());
CHECK(header_ptr == reinterpret_cast<HeaderT *>(ptr.get()));
return UnsafeSharedSlice(std::move(ptr));
}
@ -160,8 +160,7 @@ class SharedSlice {
public:
SharedSlice() = default;
explicit SharedSlice(Slice slice) : impl_(Impl::create(slice.size())) {
impl_.as_mutable_slice().copy_from(slice);
explicit SharedSlice(Slice slice) : impl_(Impl::create(slice)) {
}
explicit SharedSlice(UniqueSharedSlice from);
@ -301,7 +300,7 @@ class UniqueSliceImpl {
explicit UniqueSliceImpl(size_t size) : impl_(Impl::create(size)) {
}
UniqueSliceImpl(size_t size, char c) : impl_(Impl::create(size)) {
std::memset(as_mutable_slice().data(), c, size);
as_mutable_slice().fill(c);
}
explicit UniqueSliceImpl(Slice slice) : impl_(Impl::create(slice)) {
}

7
tdutils/td/utils/Slice.cpp
View File

@ -5,6 +5,7 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/utils/Slice.h"
#if TD_HAVE_OPENSSL
#include <openssl/crypto.h>
#endif
@ -14,16 +15,18 @@ namespace td {
void MutableSlice::fill(char c) {
std::memset(data(), c, size());
}
void MutableSlice::fill_zero() {
fill(0);
fill('\0');
}
void MutableSlice::fill_zero_secure() {
#if TD_HAVE_OPENSSL
OPENSSL_cleanse(begin(), size());
#else
volatile char *ptr = begin();
for (size_t i = 0; i < size(); i++) {
ptr[i] = 0;
ptr[i] = '\0';
}
#endif
}

20
tdutils/td/utils/ThreadLocalStorage.h
View File

@ -6,14 +6,13 @@
//
#pragma once
#include "td/utils/port/thread.h"
#include "td/utils/port/thread_local.h"
#include "td/utils/int_types.h"
#include <atomic>
#include <array>
#include <atomic>
namespace td {
template <class T>
class ThreadLocalStorage {
public:
@ -23,15 +22,15 @@ class ThreadLocalStorage {
template <class F>
void for_each(F&& f) {
int n = max_thread_id_.load();
for (int i = 0; i < n; i++) {
int32 n = max_thread_id_.load();
for (int32 i = 0; i < n; i++) {
f(nodes_[i].value);
}
}
template <class F>
void for_each(F&& f) const {
int n = max_thread_id_.load();
for (int i = 0; i < n; i++) {
int32 n = max_thread_id_.load();
for (int32 i = 0; i < n; i++) {
f(nodes_[i].value);
}
}
@ -39,10 +38,10 @@ class ThreadLocalStorage {
private:
struct Node {
T value{};
char padding[128];
char padding[TD_CONCURRENCY_PAD];
};
static constexpr int MAX_THREAD_ID = 128;
std::atomic<int> max_thread_id_{MAX_THREAD_ID};
static constexpr int32 MAX_THREAD_ID = 128;
std::atomic<int32> max_thread_id_{MAX_THREAD_ID};
std::array<Node, MAX_THREAD_ID> nodes_;
Node& thread_local_node() {
@ -51,4 +50,5 @@ class ThreadLocalStorage {
return nodes_[thread_id];
}
};
} // namespace td

8
tdutils/td/utils/ThreadSafeCounter.h
View File

@ -5,13 +5,15 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma once
#include "td/utils/ThreadLocalStorage.h"
#include "td/utils/StringBuilder.h"
#include "td/utils/ThreadLocalStorage.h"
#include <array>
#include <mutex>
namespace td {
template <size_t N>
class ThreadSafeMultiCounter {
public:
@ -23,7 +25,7 @@ class ThreadSafeMultiCounter {
int64 sum(size_t index) const {
CHECK(index < N);
int64 res = 0;
tls_.for_each([&](auto &value) { res += value[index].load(); });
tls_.for_each([&](auto &value) { res += value[index].load(std::memory_order_relaxed); });
return res;
}
@ -75,7 +77,7 @@ class NamedThreadSafeCounter {
}
}
CHECK(names_.size() < N);
names_.push_back(name.str());
names_.emplase_back(name.begin(), name.size());
return get_counter_ref(names_.size() - 1);
}

28
tdutils/td/utils/TsFileLog.cpp
View File

@ -4,15 +4,21 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "TsFileLog.h"
#include "td/utils/TsFileLog.h"
#include "td/utils/logging.h"
#include <array>
namespace td {
namespace detail {
class TsFileLog : public LogInterface {
class TsFileLogImpl : public LogInterface {
public:
Status init(string path) {
path_ = std::move(path);
for (int i = 0; i < (int)logs_.size(); i++) {
for (int32 i = 0; i < static_cast<int32>(logs_.size()); i++) {
logs_[i].id = i;
}
return init_info(&logs_[0]);
@ -36,17 +42,17 @@ class TsFileLog : public LogInterface {
private:
struct Info {
FileLog log;
bool is_inited;
int id;
bool is_inited = false;
int32 id;
};
static constexpr int MAX_THREAD_ID = 128;
static constexpr int32 MAX_THREAD_ID = 128;
std::string path_;
std::array<Info, MAX_THREAD_ID> logs_;
LogInterface *get_current_logger() {
auto *info = get_current_info();
if (!info->is_inited) {
CHECK(init_info(info).is_ok());
init_info(info).ensure();
}
return &info->log;
}
@ -61,18 +67,20 @@ class TsFileLog : public LogInterface {
return Status::OK();
}
string get_path(Info *info) {
string get_path(const Info *info) {
if (info->id == 0) {
return path_;
}
return PSTRING() << path_ << "." << info->id;
}
};
} // namespace detail
Result<td::unique_ptr<LogInterface>> TsFileLog::create(string path) {
auto res = td::make_unique<detail::TsFileLog>();
Result<unique_ptr<LogInterface>> TsFileLog::create(string path) {
auto res = make_unique<detail::TsFileLogImpl>();
TRY_STATUS(res->init(path));
return std::move(res);
}
} // namespace td

7
tdutils/td/utils/TsFileLog.h
View File

@ -6,11 +6,16 @@
//
#pragma once
#include "td/utils/common.h"
#include "td/utils/FileLog.h"
#include "td/utils/logging.h"
#include "td/utils/Status.h"
namespace td {
class TsFileLog {
public:
static Result<td::unique_ptr<LogInterface>> create(string path);
static Result<unique_ptr<LogInterface>> create(string path);
};
} // namespace td

9
tdutils/td/utils/base64.cpp
View File

@ -7,11 +7,10 @@
#include "td/utils/base64.h"
#include "td/utils/common.h"
#include "td/utils/format.h"
#include "td/utils/Slice.h"
#include "td/utils/Status.h"
#include "td/utils/format.h"
#include <algorithm>
#include <iterator>
@ -110,8 +109,7 @@ Status base64_do_decode(Slice base64, F &&append) {
Result<string> base64_decode(Slice base64) {
init_base64_table();
TRY_RESULT(tmp, base64_drop_padding(base64));
base64 = tmp;
TRY_RESULT_ASSIGN(base64, base64_drop_padding(base64));
string output;
output.reserve(((base64.size() + 3) >> 2) * 3);
@ -122,8 +120,7 @@ Result<string> base64_decode(Slice base64) {
Result<SecureString> base64_decode_secure(Slice base64) {
init_base64_table();
TRY_RESULT(tmp, base64_drop_padding(base64));
base64 = tmp;
TRY_RESULT_ASSIGN(base64, base64_drop_padding(base64));
SecureString output(((base64.size() + 3) >> 2) * 3);
char *ptr = output.as_mutable_slice().begin();

2
tdutils/td/utils/base64.h
View File

@ -7,8 +7,8 @@
#pragma once
#include "td/utils/common.h"
#include "td/utils/Slice.h"
#include "td/utils/SharedSlice.h"
#include "td/utils/Slice.h"
#include "td/utils/Status.h"
namespace td {

2
tdutils/td/utils/crypto.cpp
View File

@ -308,7 +308,7 @@ class AesCtrState::Impl {
if (AES_set_encrypt_key(key.ubegin(), 256, &aes_key) < 0) {
LOG(FATAL) << "Failed to set encrypt key";
}
counter.as_mutable_slice().copy_from(as_slice(iv));
counter.as_mutable_slice().copy_from(iv);
current_pos = 0;
}

2
tdutils/td/utils/crypto.h
View File

@ -8,8 +8,8 @@
#include "td/utils/buffer.h"
#include "td/utils/common.h"
#include "td/utils/Slice.h"
#include "td/utils/SharedSlice.h"
#include "td/utils/Slice.h"
#include "td/utils/Status.h"
namespace td {

4
tdutils/td/utils/filesystem.h
View File

@ -7,15 +7,15 @@
#pragma once
#include "td/utils/buffer.h"
#include "td/utils/Slice.h"
#include "td/utils/SharedSlice.h"
#include "td/utils/Slice.h"
#include "td/utils/Status.h"
namespace td {
Result<BufferSlice> read_file(CSlice path, int64 size = -1, int64 offset = 0);
Result<string> read_file_str(CSlice path, int64 size = -1, int64 offset = 0);
Result<SecureString> read_file_secure(CSlice path, int64 size = -1, int64 offset = 0);
Result<string> read_file_str(CSlice path, int64 size = -1, int64 offset = 0);
Status copy_file(CSlice from, CSlice to, int64 size = -1) TD_WARN_UNUSED_RESULT;

2
tdutils/td/utils/tl_helpers.h
View File

@ -9,8 +9,8 @@
#include "td/utils/common.h"
#include "td/utils/logging.h"
#include "td/utils/misc.h"
#include "td/utils/Slice.h"
#include "td/utils/SharedSlice.h"
#include "td/utils/Slice.h"
#include "td/utils/StackAllocator.h"
#include "td/utils/Status.h"
#include "td/utils/tl_parsers.h"

8
tdutils/td/utils/tl_parsers.h
View File

@ -156,12 +156,14 @@ class TlParser {
data += sizeof(int32);
} else {
check_len(sizeof(int32));
result_len = data[1] + (data[2] << 8) + (data[3] << 16) + (data[4] << 24) + (static_cast<uint64>(data[5]) << 32) +
(static_cast<uint64>(data[6]) << 40) + (static_cast<uint64>(data[7]) << 48);
if (result_len > std::numeric_limits<size_t>::max() - 3) {
auto result_len_uint64 = data[1] + (data[2] << 8) + (data[3] << 16) + (data[4] << 24) +
(static_cast<uint64>(data[5]) << 32) + (static_cast<uint64>(data[6]) << 40) +
(static_cast<uint64>(data[7]) << 48);
if (result_len_uint64 > std::numeric_limits<size_t>::max() - 3) {
set_error("Too big string found");
return T();
}
result_len = static_cast<size_t>(result_len_uint64);
result_begin = reinterpret_cast<const char *>(data + 8);
result_aligned_len = ((result_len + 3) >> 2) << 2;
data += sizeof(int64);

39
tdutils/test/SharedSlice.cpp
View File

@ -4,66 +4,65 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/utils/tests.h"
#include "td/utils/SharedSlice.h"
using namespace td;
#include "td/utils/tests.h"
TEST(SharedSlice, Hands) {
{
SharedSlice h("hello");
td::SharedSlice h("hello");
ASSERT_EQ("hello", h.as_slice());
// auto g = h; // CE
auto g = h.clone();
ASSERT_EQ("hello", h.as_slice());
ASSERT_EQ("hello", g.as_slice());
}
{
SharedSlice h("hello");
UniqueSharedSlice g(std::move(h));
td::SharedSlice h("hello");
td::UniqueSharedSlice g(std::move(h));
ASSERT_EQ("", h.as_slice());
ASSERT_EQ("hello", g.as_slice());
}
{
SharedSlice h("hello");
SharedSlice t = h.clone();
UniqueSharedSlice g(std::move(h));
td::SharedSlice h("hello");
td::SharedSlice t = h.clone();
td::UniqueSharedSlice g(std::move(h));
ASSERT_EQ("", h.as_slice());
ASSERT_EQ("hello", g.as_slice());
ASSERT_EQ("hello", t.as_slice());
}
{
UniqueSharedSlice g(5);
td::UniqueSharedSlice g(5);
g.as_mutable_slice().copy_from("hello");
SharedSlice h(std::move(g));
td::SharedSlice h(std::move(g));
ASSERT_EQ("hello", h);
ASSERT_EQ("", g);
}
{
UniqueSlice h("hello");
UniqueSlice g(std::move(h));
td::UniqueSlice h("hello");
td::UniqueSlice g(std::move(h));
ASSERT_EQ("", h.as_slice());
ASSERT_EQ("hello", g.as_slice());
}
{
SecureString h("hello");
SecureString g(std::move(h));
td::SecureString h("hello");
td::SecureString g(std::move(h));
ASSERT_EQ("", h.as_slice());
ASSERT_EQ("hello", g.as_slice());
}
{
Stage stage;
SharedSlice a, b;
std::vector<td::thread> threads(2);
td::Stage stage;
td::SharedSlice a, b;
td::vector<td::thread> threads(2);
for (int i = 0; i < 2; i++) {
threads[i] = td::thread([i, &stage, &a, &b] {
for (int j = 0; j < 10000; j++) {
if (i == 0) {
a = SharedSlice("hello");
a = td::SharedSlice("hello");
b = a.clone();
}
stage.wait((2 * j + 1) * 2);
@ -71,7 +70,7 @@ TEST(SharedSlice, Hands) {
ASSERT_EQ('h', a[0]);
a.clear();
} else {
UniqueSharedSlice c(std::move(b));
td::UniqueSharedSlice c(std::move(b));
c.as_mutable_slice()[0] = '!';
}
stage.wait((2 * j + 2) * 2);

9
tdutils/test/log.cpp
View File

@ -4,23 +4,22 @@
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/utils/tests.h"
#include "td/utils/benchmark.h"
#include "td/utils/FileLog.h"
#include "td/utils/TsFileLog.h"
#include "td/utils/logging.h"
#include "td/utils/port/path.h"
#include "td/utils/benchmark.h"
#include "td/utils/tests.h"
#include "td/utils/TsFileLog.h"
// Thread safe logging with tests
//
// LOG uses thread local LogInterface
// void append(CSlice slice, int log_level);
//
template <class Log>
class LogBenchmark : public td::Benchmark {
public:
explicit LogBenchmark(std::string name, int threads_n, std::function<td::unique_ptr<Log>()> creator)
LogBenchmark(std::string name, int threads_n, std::function<td::unique_ptr<Log>()> creator)
: name_(std::move(name)), threads_n_(threads_n), creator_(std::move(creator)) {
}
std::string get_description() const override {