Nagram/TMessagesProj/jni/libtgvoip3/TgVoip.cpp
2020-04-24 12:21:58 +03:00

506 lines
15 KiB
C++

#include "TgVoip.h"
#include "VoIPController.h"
#include "VoIPServerConfig.h"
#include <mutex>
#include <cstdarg>
#ifndef TGVOIP_USE_CUSTOM_CRYPTO
extern "C"
{
#include <openssl/aes.h>
//#include <openssl/modes.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
}
void tgvoip_openssl_aes_ige_encrypt(const std::uint8_t* in, std::uint8_t* out, std::size_t length, const std::uint8_t* key, std::uint8_t* iv)
{
AES_KEY akey;
AES_set_encrypt_key(key, 32 * 8, &akey);
AES_ige_encrypt(in, out, length, &akey, iv, AES_ENCRYPT);
}
void tgvoip_openssl_aes_ige_decrypt(const std::uint8_t* in, std::uint8_t* out, std::size_t length, const std::uint8_t* key, std::uint8_t* iv)
{
AES_KEY akey;
AES_set_decrypt_key(key, 32 * 8, &akey);
AES_ige_encrypt(in, out, length, &akey, iv, AES_DECRYPT);
}
void tgvoip_openssl_rand_bytes(std::uint8_t* buffer, std::size_t len)
{
RAND_bytes(buffer, static_cast<int>(len));
}
void tgvoip_openssl_sha1(const std::uint8_t* msg, std::size_t len, std::uint8_t* output)
{
SHA1(msg, len, output);
}
void tgvoip_openssl_sha256(const std::uint8_t* msg, std::size_t len, std::uint8_t* output)
{
SHA256(msg, len, output);
}
void tgvoip_openssl_aes_ctr_encrypt(std::uint8_t* inout, std::size_t length, const std::uint8_t* key, std::uint8_t* iv, std::uint8_t* ecount, std::uint32_t* num)
{
AES_KEY akey;
AES_set_encrypt_key(key, 32 * 8, &akey);
AES_ctr128_encrypt(inout, inout, length, &akey, iv, ecount, num);
}
void tgvoip_openssl_aes_cbc_encrypt(const std::uint8_t* in, std::uint8_t* out, std::size_t length, const std::uint8_t* key, std::uint8_t* iv)
{
AES_KEY akey;
AES_set_encrypt_key(key, 256, &akey);
AES_cbc_encrypt(in, out, length, &akey, iv, AES_ENCRYPT);
}
void tgvoip_openssl_aes_cbc_decrypt(const std::uint8_t* in, std::uint8_t* out, std::size_t length, const std::uint8_t* key, std::uint8_t* iv)
{
AES_KEY akey;
AES_set_decrypt_key(key, 256, &akey);
AES_cbc_encrypt(in, out, length, &akey, iv, AES_DECRYPT);
}
tgvoip::CryptoFunctions tgvoip::VoIPController::crypto =
{
tgvoip_openssl_rand_bytes,
tgvoip_openssl_sha1,
tgvoip_openssl_sha256,
tgvoip_openssl_aes_ige_encrypt,
tgvoip_openssl_aes_ige_decrypt,
tgvoip_openssl_aes_ctr_encrypt,
tgvoip_openssl_aes_cbc_encrypt,
tgvoip_openssl_aes_cbc_decrypt
};
#endif
class TgVoipImpl : public TgVoip
{
public:
TgVoipImpl(
std::vector<TgVoipEndpoint> const& endpoints,
TgVoipPersistentState const& persistentState,
std::unique_ptr<TgVoipProxy> const& proxy,
TgVoipConfig const& config,
TgVoipEncryptionKey const& encryptionKey,
TgVoipNetworkType initialNetworkType
#ifdef TGVOIP_USE_CUSTOM_CRYPTO
,
TgVoipCrypto const& crypto
#endif
#ifdef TGVOIP_USE_CALLBACK_AUDIO_IO
,
TgVoipAudioDataCallbacks const& audioDataCallbacks
#endif
);
~TgVoipImpl() override;
void setOnStateUpdated(std::function<void(TgVoipState)> onStateUpdated) override;
void setOnSignalBarsUpdated(std::function<void(int)> onSignalBarsUpdated) override;
void setNetworkType(TgVoipNetworkType networkType) final;
void setMuteMicrophone(bool muteMicrophone) override;
void setAudioOutputGainControlEnabled(bool enabled) override;
void setEchoCancellationStrength(int strength) override;
std::string getLastError() override;
std::string getDebugInfo() override;
std::int64_t getPreferredRelayId() override;
TgVoipTrafficStats getTrafficStats() override;
TgVoipPersistentState getPersistentState() override;
TgVoipFinalState stop() override;
static void controllerStateCallback(tgvoip::VoIPController* controller, tgvoip::State state);
static void signalBarsCallback(tgvoip::VoIPController* controller, int signalBars);
private:
tgvoip::VoIPController* m_controller;
std::function<void(TgVoipState)> m_onStateUpdated;
std::function<void(int)> m_onSignalBarsUpdated;
std::mutex m_mutexOnStateUpdated, m_mutexOnSignalBarsUpdated;
};
TgVoipImpl::TgVoipImpl(
std::vector<TgVoipEndpoint> const& endpoints,
TgVoipPersistentState const& persistentState,
std::unique_ptr<TgVoipProxy> const& proxy,
TgVoipConfig const& config,
TgVoipEncryptionKey const& encryptionKey,
TgVoipNetworkType initialNetworkType
#ifdef TGVOIP_USE_CUSTOM_CRYPTO
,
TgVoipCrypto const& crypto
#endif
#ifdef TGVOIP_USE_CALLBACK_AUDIO_IO
,
TgVoipAudioDataCallbacks const& audioDataCallbacks
#endif
)
{
#ifdef TGVOIP_USE_CUSTOM_CRYPTO
tgvoip::VoIPController::crypto.sha1 = crypto.sha1;
tgvoip::VoIPController::crypto.sha256 = crypto.sha256;
tgvoip::VoIPController::crypto.rand_bytes = crypto.rand_bytes;
tgvoip::VoIPController::crypto.aes_ige_encrypt = crypto.aes_ige_encrypt;
tgvoip::VoIPController::crypto.aes_ige_decrypt = crypto.aes_ige_decrypt;
tgvoip::VoIPController::crypto.aes_ctr_encrypt = crypto.aes_ctr_encrypt;
#endif
m_controller = new tgvoip::VoIPController();
m_controller->implData = this;
#ifdef TGVOIP_USE_CALLBACK_AUDIO_IO
m_controller->SetAudioDataCallbacks(audioDataCallbacks.input, audioDataCallbacks.output, audioDataCallbacks.preprocessed);
#endif
m_controller->SetPersistentState(persistentState.value);
if (proxy != nullptr)
{
m_controller->SetProxy(tgvoip::Proxy::SOCKS5, proxy->host, proxy->port, proxy->login, proxy->password);
}
auto callbacks = tgvoip::VoIPController::Callbacks();
callbacks.connectionStateChanged = &TgVoipImpl::controllerStateCallback;
callbacks.groupCallKeyReceived = nullptr;
callbacks.groupCallKeySent = nullptr;
callbacks.signalBarCountChanged = &TgVoipImpl::signalBarsCallback;
callbacks.upgradeToGroupCallRequested = nullptr;
m_controller->SetCallbacks(callbacks);
std::vector<tgvoip::Endpoint> mappedEndpoints;
for (const TgVoipEndpoint& endpoint : endpoints)
{
tgvoip::Endpoint::Type mappedType;
switch (endpoint.type)
{
case TgVoipEndpointType::UdpRelay:
mappedType = tgvoip::Endpoint::Type::UDP_RELAY;
break;
case TgVoipEndpointType::Lan:
mappedType = tgvoip::Endpoint::Type::UDP_P2P_LAN;
break;
case TgVoipEndpointType::Inet:
mappedType = tgvoip::Endpoint::Type::UDP_P2P_INET;
break;
case TgVoipEndpointType::TcpRelay:
mappedType = tgvoip::Endpoint::Type::TCP_RELAY;
break;
// default:
// mappedType = tgvoip::Endpoint::Type::UDP_RELAY;
// break;
}
tgvoip::IPv4Address address(endpoint.host.ipv4);
tgvoip::IPv6Address addressv6(endpoint.host.ipv6);
mappedEndpoints.emplace_back(endpoint.endpointId, endpoint.port, address, addressv6, mappedType, endpoint.peerTag);
}
tgvoip::DataSaving mappedDataSaving;
switch (config.dataSaving)
{
case TgVoipDataSaving::Mobile:
mappedDataSaving = tgvoip::DataSaving::MOBILE;
break;
case TgVoipDataSaving::Always:
mappedDataSaving = tgvoip::DataSaving::ALWAYS;
break;
case TgVoipDataSaving::Never:
mappedDataSaving = tgvoip::DataSaving::NEVER;
break;
}
tgvoip::VoIPController::Config mappedConfig(
config.initializationTimeout,
config.receiveTimeout,
mappedDataSaving,
config.enableAEC,
config.enableNS,
config.enableAGC,
config.enableCallUpgrade);
mappedConfig.logFilePath = config.logPath;
mappedConfig.statsDumpFilePath = {};
m_controller->SetConfig(mappedConfig);
setNetworkType(initialNetworkType);
std::vector<std::uint8_t> encryptionKeyValue = encryptionKey.value;
m_controller->SetEncryptionKey(reinterpret_cast<char*>(encryptionKeyValue.data()), encryptionKey.isOutgoing);
m_controller->SetRemoteEndpoints(mappedEndpoints, config.enableP2P, config.maxApiLayer);
m_controller->Start();
m_controller->Connect();
}
TgVoipImpl::~TgVoipImpl() = default;
void TgVoipImpl::setOnStateUpdated(std::function<void(TgVoipState)> onStateUpdated)
{
std::lock_guard<std::mutex> lock(m_mutexOnStateUpdated);
m_onStateUpdated = onStateUpdated;
}
void TgVoipImpl::setOnSignalBarsUpdated(std::function<void(int)> onSignalBarsUpdated)
{
std::lock_guard<std::mutex> lock(m_mutexOnSignalBarsUpdated);
m_onSignalBarsUpdated = onSignalBarsUpdated;
}
void TgVoipImpl::setNetworkType(TgVoipNetworkType networkType)
{
tgvoip::NetType mappedType;
switch (networkType)
{
case TgVoipNetworkType::Unknown:
mappedType = tgvoip::NetType::UNKNOWN;
break;
case TgVoipNetworkType::Gprs:
mappedType = tgvoip::NetType::GPRS;
break;
case TgVoipNetworkType::Edge:
mappedType = tgvoip::NetType::EDGE;
break;
case TgVoipNetworkType::ThirdGeneration:
mappedType = tgvoip::NetType::THREE_G;
break;
case TgVoipNetworkType::Hspa:
mappedType = tgvoip::NetType::HSPA;
break;
case TgVoipNetworkType::Lte:
mappedType = tgvoip::NetType::LTE;
break;
case TgVoipNetworkType::WiFi:
mappedType = tgvoip::NetType::WIFI;
break;
case TgVoipNetworkType::Ethernet:
mappedType = tgvoip::NetType::ETHERNET;
break;
case TgVoipNetworkType::OtherHighSpeed:
mappedType = tgvoip::NetType::OTHER_HIGH_SPEED;
break;
case TgVoipNetworkType::OtherLowSpeed:
mappedType = tgvoip::NetType::OTHER_LOW_SPEED;
break;
case TgVoipNetworkType::OtherMobile:
mappedType = tgvoip::NetType::OTHER_MOBILE;
break;
case TgVoipNetworkType::Dialup:
mappedType = tgvoip::NetType::DIALUP;
break;
// default:
// mappedType = tgvoip::NetType::UNKNOWN;
// break;
}
m_controller->SetNetworkType(mappedType);
}
void TgVoipImpl::setMuteMicrophone(bool muteMicrophone)
{
m_controller->SetMicMute(muteMicrophone);
}
void TgVoipImpl::setAudioOutputGainControlEnabled(bool enabled)
{
m_controller->SetAudioOutputGainControlEnabled(enabled);
}
void TgVoipImpl::setEchoCancellationStrength(int strength)
{
m_controller->SetEchoCancellationStrength(strength);
}
std::string TgVoipImpl::getLastError()
{
tgvoip::Error error = m_controller->GetLastError();
switch (error)
{
case tgvoip::Error::INCOMPATIBLE:
return "Error::INCOMPATIBLE";
case tgvoip::Error::TIMEOUT:
return "Error::TIMEOUT";
case tgvoip::Error::AUDIO_IO:
return "Error::AUDIO_IO";
case tgvoip::Error::PROXY:
return "Error::PROXY";
case tgvoip::Error::UNKNOWN:
return "Error::UNKNOWN";
}
throw std::runtime_error("Error " + std::to_string(static_cast<int>(error)) + " is not one of enum values!");
}
std::string TgVoipImpl::getDebugInfo()
{
return m_controller->GetDebugString();
}
std::int64_t TgVoipImpl::getPreferredRelayId()
{
return m_controller->GetPreferredRelayID();
}
TgVoipTrafficStats TgVoipImpl::getTrafficStats()
{
tgvoip::VoIPController::TrafficStats stats;
m_controller->GetStats(&stats);
return TgVoipTrafficStats
{
.bytesSentWifi = stats.bytesSentWifi,
.bytesReceivedWifi = stats.bytesRecvdWifi,
.bytesSentMobile = stats.bytesSentMobile,
.bytesReceivedMobile = stats.bytesRecvdMobile
};
}
TgVoipPersistentState TgVoipImpl::getPersistentState()
{
return {m_controller->GetPersistentState()};
}
TgVoipFinalState TgVoipImpl::stop()
{
m_controller->Stop();
TgVoipFinalState finalState =
{
.persistentState = getPersistentState(),
.debugLog = m_controller->GetDebugLog(),
.trafficStats = getTrafficStats(),
.isRatingSuggested = m_controller->NeedRate()
};
delete m_controller;
m_controller = nullptr;
return finalState;
}
void TgVoipImpl::controllerStateCallback(tgvoip::VoIPController* controller, tgvoip::State state)
{
TgVoipImpl* self = reinterpret_cast<TgVoipImpl*>(controller->implData);
std::lock_guard<std::mutex> lock(self->m_mutexOnStateUpdated);
if (self->m_onStateUpdated)
{
TgVoipState mappedState;
switch (state)
{
case tgvoip::State::WAIT_INIT:
mappedState = TgVoipState::WaitInit;
break;
case tgvoip::State::WAIT_INIT_ACK:
mappedState = TgVoipState::WaitInitAck;
break;
case tgvoip::State::ESTABLISHED:
mappedState = TgVoipState::Estabilished;
break;
case tgvoip::State::FAILED:
mappedState = TgVoipState::Failed;
break;
case tgvoip::State::RECONNECTING:
mappedState = TgVoipState::Reconnecting;
break;
// default:
// mappedState = TgVoipState::Estabilished;
// break;
}
self->m_onStateUpdated(mappedState);
}
}
void TgVoipImpl::signalBarsCallback(tgvoip::VoIPController* controller, int signalBars)
{
TgVoipImpl* self = reinterpret_cast<TgVoipImpl*>(controller->implData);
std::lock_guard<std::mutex> lock(self->m_mutexOnSignalBarsUpdated);
if (self->m_onSignalBarsUpdated)
{
self->m_onSignalBarsUpdated(signalBars);
}
}
static std::function<void(std::string const&)> globalLoggingFunction;
void __tgvoip_call_tglog(const char* format, ...)
{
va_list vaArgs;
va_start(vaArgs, format);
va_list vaCopy;
va_copy(vaCopy, vaArgs);
const int length = std::vsnprintf(nullptr, 0, format, vaCopy);
va_end(vaCopy);
std::vector<char> zc(static_cast<std::size_t>(length) + 1);
std::vsnprintf(zc.data(), zc.size(), format, vaArgs);
va_end(vaArgs);
if (globalLoggingFunction != nullptr)
{
globalLoggingFunction(std::string(zc.data(), zc.size()));
}
}
void TgVoip::setLoggingFunction(std::function<void(std::string const&)> loggingFunction)
{
globalLoggingFunction = std::move(loggingFunction);
}
void TgVoip::setGlobalServerConfig(const std::string& serverConfig)
{
tgvoip::ServerConfig::GetSharedInstance()->Update(serverConfig);
}
int TgVoip::getConnectionMaxLayer()
{
return tgvoip::VoIPController::GetConnectionMaxLayer();
}
std::string TgVoip::getVersion()
{
return tgvoip::VoIPController::GetVersion();
}
TgVoip* TgVoip::makeInstance(
TgVoipConfig const& config,
TgVoipPersistentState const& persistentState,
std::vector<TgVoipEndpoint> const& endpoints,
std::unique_ptr<TgVoipProxy> const& proxy,
TgVoipNetworkType initialNetworkType,
TgVoipEncryptionKey const& encryptionKey
#ifdef TGVOIP_USE_CUSTOM_CRYPTO
,
TgVoipCrypto const& crypto
#endif
#ifdef TGVOIP_USE_CALLBACK_AUDIO_IO
,
TgVoipAudioDataCallbacks const& audioDataCallbacks
#endif
)
{
return new TgVoipImpl(
endpoints,
persistentState,
proxy,
config,
encryptionKey,
initialNetworkType
#ifdef TGVOIP_USE_CUSTOM_CRYPTO
,
crypto
#endif
#ifdef TGVOIP_USE_CALLBACK_AUDIO_IO
,
audioDataCallbacks
#endif
);
}
TgVoip::~TgVoip() = default;