126 lines
5.4 KiB
C++
126 lines
5.4 KiB
C++
#include <misc/endianness.h>
|
|
#include <LicenseRequest.pb.h>
|
|
|
|
#define DEFINE_HELPER
|
|
#include "LicenseRequest.h"
|
|
|
|
using namespace license;
|
|
using namespace std;
|
|
using namespace std::chrono;
|
|
|
|
void LicenceRequest::handlePacketDisconnect(const std::string& message) {
|
|
if(this->state != protocol::DISCONNECTING) {
|
|
/*
|
|
* We got an early disconnect.
|
|
* Test if we have a result. If so and the license is invalid then we could use that result
|
|
*/
|
|
if(this->response && !this->response->license_valid) {
|
|
this->currentFuture->executionSucceed(this->response);
|
|
} else {
|
|
LICENSE_FERR(this, UnexcpectedDisconnectException, "Remote side closed the connection unexpectedly (" + message + ")");
|
|
}
|
|
}
|
|
}
|
|
|
|
void LicenceRequest::handlePacketHandshake(const std::string& data) {
|
|
if(this->state != protocol::HANDSCAKE) LICENSE_FERR(this, InvalidResponseException, "Protocol state mismatch");
|
|
if(data.length() < 3) LICENSE_FERR(this, InvalidResponseException, "Invalid packet size");
|
|
|
|
if((uint8_t) data[0] != 0xAF || (uint8_t) data[1] != 0xFE) LICENSE_FERR(this, InvalidResponseException, "Invalid handshake");
|
|
if((uint8_t) data[2] != LICENSE_PROT_VERSION) LICENSE_FERR(this, InvalidResponseException, "Invalid license protocol version. Please update TeaSpeak!");
|
|
|
|
auto key_length = be2le16(data.data(), 3);
|
|
if(data.length() < key_length + 3) LICENSE_FERR(this, InvalidResponseException, "Invalid packet size");
|
|
this->cryptKey = data.substr(5, key_length);
|
|
|
|
ts::proto::license::ServerValidation request;
|
|
if(this->data->license) {
|
|
request.set_licensed(true);
|
|
request.set_license_info(true);
|
|
request.set_license(exportLocalLicense(this->data->license));
|
|
} else {
|
|
request.set_licensed(false);
|
|
request.set_license_info(false);
|
|
}
|
|
request.mutable_info()->set_uname(this->data->info->uname);
|
|
request.mutable_info()->set_version(this->data->info->version);
|
|
request.mutable_info()->set_timestamp(this->data->info->timestamp);
|
|
request.mutable_info()->set_unique_id(this->data->info->unique_identifier);
|
|
|
|
this->sendPacket(protocol::packet{protocol::PACKET_CLIENT_SERVER_VALIDATION, request});
|
|
this->state = protocol::LICENSE_INFO;
|
|
}
|
|
|
|
void LicenceRequest::handlePacketLicenseInfo(const std::string& message) {
|
|
ts::proto::license::LicenseResponse response;
|
|
if(!response.ParseFromString(message)) LICENSE_FERR(this, InvalidResponseException, "Could not parse response");
|
|
|
|
auto result = make_shared<LicenseRequestResponse>();
|
|
auto licenseInfo = make_shared<LicenseInfo>();
|
|
if(!response.has_license_info() && this->data->license && response.valid() && response.blacklist().state() == ts::proto::license::VALID) {
|
|
LICENSE_FERR(this, InvalidResponseException, "Missing license info");
|
|
}
|
|
|
|
if(this->data->license) {
|
|
licenseInfo->type = (LicenseType) response.license_info().type();
|
|
licenseInfo->email = response.license_info().email();
|
|
licenseInfo->username = response.license_info().username();
|
|
licenseInfo->first_name = response.license_info().first_name();
|
|
licenseInfo->last_name = response.license_info().last_name();
|
|
licenseInfo->creation = system_clock::time_point() + milliseconds(response.license_info().created());
|
|
licenseInfo->start = system_clock::time_point() + milliseconds(response.license_info().begin());
|
|
licenseInfo->end = system_clock::time_point() + milliseconds(response.license_info().end());
|
|
} else {
|
|
licenseInfo->type = LicenseType::DEMO;
|
|
licenseInfo->email = "license@teaspeak.de";
|
|
licenseInfo->username = "WolverinDEV";
|
|
licenseInfo->first_name = "Max";
|
|
licenseInfo->last_name = "Musterman";
|
|
licenseInfo->creation = system_clock::now();
|
|
licenseInfo->start = system_clock::now();
|
|
licenseInfo->end = system_clock::time_point();
|
|
}
|
|
result->license_valid = response.blacklist().state() == ts::proto::license::VALID; //TODO more detailed
|
|
result->age = system_clock::now();
|
|
|
|
result->license = licenseInfo;
|
|
this->response = result;
|
|
|
|
ts::proto::license::PropertyUpdateRequest infos;
|
|
infos.set_speach_total(this->data->speach_total);
|
|
infos.set_speach_dead(this->data->speach_dead);
|
|
infos.set_speach_online(this->data->speach_online);
|
|
infos.set_speach_varianz(this->data->speach_varianz);
|
|
|
|
infos.set_clients_online(this->data->client_online);
|
|
infos.set_bots_online(this->data->bots_online);
|
|
infos.set_queries_online(this->data->queries_online);
|
|
infos.set_servers_online(this->data->servers_online);
|
|
infos.set_web_clients_online(this->data->web_clients_online);
|
|
|
|
infos.set_web_cert_revision(this->data->web_certificate_revision);
|
|
this->sendPacket({protocol::PACKET_CLIENT_PROPERTY_ADJUSTMENT, infos});
|
|
this->state = protocol::PROPERTY_ADJUSTMENT;
|
|
}
|
|
|
|
void LicenceRequest::handlePacketInfoAdjustment(const std::string& message) {
|
|
ts::proto::license::PropertyUpdateResponse response{};
|
|
if(!response.ParseFromString(message)) LICENSE_FERR(this, InvalidResponseException, "Could not parse response");
|
|
|
|
this->response->properties_valid = response.accepted();
|
|
this->response->speach_varianz_adjustment = response.speach_varianz_corrector();
|
|
this->response->speach_reset = response.reset_speach();
|
|
|
|
if(response.has_web_certificate() && this->callback_update_certificate) {
|
|
WebCertificate cert{};
|
|
cert.revision = response.web_certificate().revision();
|
|
cert.key = response.web_certificate().key();
|
|
cert.certificate = response.web_certificate().certificate();
|
|
this->callback_update_certificate(cert);
|
|
}
|
|
|
|
this->currentFuture->executionSucceed(this->response);
|
|
this->response = nullptr;
|
|
|
|
this->disconnect("query succeeded!");
|
|
} |