TeaSpeak
/
TeaSpeakLibrary
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Some updates

This commit is contained in:
WolverinDEV 2020-02-15 14:01:07 +01:00
parent 3f57ad4678
commit 9e2249462c
11 changed files with 67 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@ -188,16 +188,6 @@ if(HAVE_OPEN_SSL)
)
endif()
if (NOT WIN32)
#TODO: Do we really need that anymroe?
set(SOURCE_FILES ${SOURCE_FILES}
#src/misc/TraceUtils.cpp
)
set(HEADER_FILES ${HEADER_FILES}
)
endif ()
add_library(TeaSpeak STATIC ${SOURCE_FILES} ${HEADER_FILES})
target_link_libraries(TeaSpeak PUBLIC threadpool::static jsoncpp_lib)
target_compile_options(TeaSpeak PRIVATE "-Wall")

3
src/Error.cpp
View File

@ -36,7 +36,8 @@ const std::vector<ErrorType> ts::avariableErrors = {
{0x0211, "client_unknown" , "client is not known" },
{0x0212, "client_join_rate_limit_reached" , "client has reached his join attempt limit" },
{0x0213, "client_is_already_member_of_group" , "client is already a member of the group" },
{0x0213, "client_is_not_member_of_group" , "client is not a member of the group" },
{0x0214, "client_is_not_member_of_group" , "client is not a member of the group" },
{0x0215, "client_type_is_not_allowed" , "client type is not allowed to join the server" },
{0x0300, "channel_invalid_id" , "invalid channelID" },
{0x0301, "channel_protocol_limit_reached" , "max channels protocol limit reached" },

1
src/Error.h
View File

@ -49,6 +49,7 @@ namespace ts {
client_join_rate_limit_reached = 0x0212,
client_is_already_member_of_group = 0x0213,
client_is_not_member_of_group = 0x0214,
client_type_is_not_allowed = 0x0215,
channel_invalid_id = 0x300,
channel_protocol_limit_reached = 0x301,

4
src/EventLoop.h
View File

@ -24,6 +24,7 @@ namespace ts {
class ProxiedEventEntry : public event::EventEntry {
public:
using callback_t = void(class_t::*)(const std::chrono::system_clock::time_point &);
using static_callback_t = void(*)(class_t *, const std::chrono::system_clock::time_point &);
ProxiedEventEntry(const std::shared_ptr<class_t>& _instance, callback_t callback) : instance(_instance), callback(callback) { }
@ -35,7 +36,8 @@ namespace ts {
if(!_instance)
return;
((void(*)(class_t*, const std::chrono::system_clock::time_point &)) (void*) this->callback)(&*_instance, point);
auto callback_ptr = (void**) &this->callback;
(*(static_callback_t*) callback_ptr)(&*_instance, point);
}
};

2
src/PermissionManager.cpp
View File

@ -1120,7 +1120,6 @@ void v2::PermissionManager::load_permission(const ts::permission::PermissionType
permission_container->flags.grant_set = flag_grant;
}
static constexpr v2::PermissionFlags empty_flags = {false, false, false, false, false, false, 0};
const v2::PermissionFlags v2::PermissionManager::permission_flags(const ts::permission::PermissionType &permission) {
if(permission < 0 || permission >= PermissionType::permission_id_max)
return empty_flags;
@ -1175,7 +1174,6 @@ const v2::PermissionFlaggedValue v2::PermissionManager::permission_granted_flagg
return result;
}
static constexpr v2::PermissionContainer empty_channel_permission = {empty_flags, v2::empty_permission_values};
const v2::PermissionContainer v2::PermissionManager::channel_permission(const PermissionType &permission, ts::ChannelId channel_id) {
if(permission < 0 || permission >= PermissionType::permission_id_max)
return empty_channel_permission;

2
src/PermissionManager.h
View File

@ -775,6 +775,8 @@ namespace ts {
ChannelId channel_id;
};
static_assert(sizeof(ChannelPermissionContainer) == 19);
static constexpr v2::PermissionFlags empty_flags = {false, false, false, false, false, false, false};
static constexpr v2::PermissionContainer empty_channel_permission = {empty_flags, v2::empty_permission_values};
#pragma pack(pop)

14
src/protocol/Packet.cpp
View File

@ -216,24 +216,24 @@ namespace ts {
}
uint16_t IncomingClientPacketParser::packet_id() const { return be2le16(this->_buffer.data_ptr<uint8_t>(), IncomingClientPacketParser::kHeaderOffset + 0); }
uint16_t IncomingClientPacketParser::client_id() const { return be2le16(this->_buffer.data_ptr<uint8_t>(), IncomingClientPacketParser::kHeaderOffset + 2); }
uint8_t IncomingClientPacketParser::type() const { return this->_buffer[IncomingClientPacketParser::kHeaderOffset + 4] & 0xF; }
uint8_t IncomingClientPacketParser::flags() const { return this->_buffer[IncomingClientPacketParser::kHeaderOffset + 4] & 0xF0; }
uint16_t ClientPacketParser::packet_id() const { return be2le16(this->_buffer.data_ptr<uint8_t>(), ClientPacketParser::kHeaderOffset + 0); }
uint16_t ClientPacketParser::client_id() const { return be2le16(this->_buffer.data_ptr<uint8_t>(), ClientPacketParser::kHeaderOffset + 2); }
uint8_t ClientPacketParser::type() const { return (uint8_t) this->_buffer[ClientPacketParser::kHeaderOffset + 4] & 0xFU; }
uint8_t ClientPacketParser::flags() const { return (uint8_t) this->_buffer[ClientPacketParser::kHeaderOffset + 4] & 0xF0U; }
bool IncomingClientPacketParser::is_encrypted() const {
bool ClientPacketParser::is_encrypted() const {
if(this->decrypted) return false;
return (this->flags() & PacketFlag::Unencrypted) == 0;
}
bool IncomingClientPacketParser::is_compressed() const {
bool ClientPacketParser::is_compressed() const {
if(this->uncompressed) return false;
return (this->flags() & PacketFlag::Compressed) > 0;
}
bool IncomingClientPacketParser::is_fragmented() const {
bool ClientPacketParser::is_fragmented() const {
if(this->defragmented) return false;
return (this->flags() & PacketFlag::Fragmented) > 0;

12
src/protocol/Packet.h
View File

@ -286,14 +286,14 @@ namespace ts {
void setPacketId(uint16_t, uint16_t) override;
};
class IncomingClientPacketParser {
class ClientPacketParser {
public:
constexpr static auto kHeaderOffset = 8;
constexpr static auto kHeaderLength = CLIENT_HEADER_SIZE;
constexpr static auto kPayloadOffset = kHeaderOffset + CLIENT_HEADER_SIZE;
explicit IncomingClientPacketParser(pipes::buffer_view buffer) : _buffer{std::move(buffer)} {}
IncomingClientPacketParser(const IncomingClientPacketParser&) = delete;
explicit ClientPacketParser(pipes::buffer_view buffer) : _buffer{std::move(buffer)} {}
ClientPacketParser(const ClientPacketParser&) = delete;
[[nodiscard]] inline bool valid() const {
if(this->_buffer.length() < kPayloadOffset) return false;
@ -304,8 +304,8 @@ namespace ts {
[[nodiscard]] inline void* mutable_data_ptr() { return (void*) this->_buffer.data_ptr(); }
[[nodiscard]] inline pipes::buffer_view buffer() const { return this->_buffer; }
[[nodiscard]] inline const pipes::buffer_view mac() const { return this->_buffer.view(0, 8); }
[[nodiscard]] inline const pipes::buffer_view payload() const { return this->_buffer.view(kPayloadOffset); }
[[nodiscard]] inline pipes::buffer_view mac() const { return this->_buffer.view(0, 8); }
[[nodiscard]] inline pipes::buffer_view payload() const { return this->_buffer.view(kPayloadOffset); }
[[nodiscard]] inline size_t payload_length() const { return this->_buffer.length() - kPayloadOffset; }
[[nodiscard]] uint16_t client_id() const;
@ -318,7 +318,7 @@ namespace ts {
[[nodiscard]] bool is_fragmented() const;
[[nodiscard]] uint16_t estimated_generation() const { return this->generation; }
void set_estimated_generation(uint16_t generation) { this->generation = generation; }
void set_estimated_generation(uint16_t gen) { this->generation = gen; }
inline void set_decrypted() { this->decrypted = true; }
inline void set_uncompressed() { this->uncompressed = true; }

1
src/query/Command.h
View File

@ -198,6 +198,7 @@ operator type(){ \
void push_bulk_front();
bool hasParm(std::string);
void clear_parameters() { this->paramethers.clear(); }
std::deque<std::string> parms();
void enableParm(const std::string& key){ toggleParm(key, true); }
void disableParm(const std::string& key){ toggleParm(key, false); }

4
src/sql/mysql/MySQL.cpp
View File

@ -7,7 +7,7 @@
#include <memory>
#include <utility>
#include <mysql/mysql.h>
#include <mysql.h>
#define CR_CONNECTION_ERROR (2002)
#define CR_SERVER_GONE_ERROR (2006)
@ -215,7 +215,7 @@ result MySQLManager::connect(const std::string &url) {
return {-1, "failed to allocate connection " + to_string(index)};
{
my_bool reconnect = 1;
bool reconnect{true};
mysql_options(connection->handle, MYSQL_OPT_RECONNECT, &reconnect);
}
mysql_options(connection->handle, MYSQL_SET_CHARSET_NAME, "utf8");

88
src/sql/mysql/MySQL.h
View File

@ -7,70 +7,68 @@
#include "sql/SqlQuery.h"
#include "../../misc/spin_lock.h"
#include <mysql/mysql.h>
#include <mysql.h>
#define ERROR_MYSQL_MISSING_DRIVER -1
#define ERROR_MYSQL_INVLID_CONNECT -2
#define ERROR_MYSQL_INVLID_PROPERTIES -3
#define ERROR_MYSQL_INVLID_URL -4
namespace sql {
namespace mysql {
class MySQLManager;
namespace sql::mysql {
class MySQLManager;
bool evaluate_sql_query(std::string& sql, const std::vector<variable>& vars, std::vector<variable>& result);
bool evaluate_sql_query(std::string& sql, const std::vector<variable>& vars, std::vector<variable>& result);
class MySQLCommand : public CommandData { };
class MySQLCommand : public CommandData { };
struct Connection {
MYSQL* handle = nullptr;
struct Connection {
MYSQL* handle = nullptr;
spin_lock used_lock;
bool used = false;
spin_lock used_lock;
bool used = false;
~Connection();
};
~Connection();
};
struct AcquiredConnection {
MySQLManager* owner;
std::shared_ptr<Connection> connection;
struct AcquiredConnection {
MySQLManager* owner;
std::shared_ptr<Connection> connection;
AcquiredConnection(MySQLManager* owner, std::shared_ptr<Connection> );
~AcquiredConnection();
};
AcquiredConnection(MySQLManager* owner, std::shared_ptr<Connection> );
~AcquiredConnection();
};
class MySQLManager : public SqlManager {
friend struct AcquiredConnection;
public:
//typedef std::function<void(const std::shared_ptr<ConnectionEntry>&)> ListenerConnectionDisconnect;
//typedef std::function<void(const std::shared_ptr<ConnectionEntry>&)> ListenerConnectionCreated;
class MySQLManager : public SqlManager {
friend struct AcquiredConnection;
public:
//typedef std::function<void(const std::shared_ptr<ConnectionEntry>&)> ListenerConnectionDisconnect;
//typedef std::function<void(const std::shared_ptr<ConnectionEntry>&)> ListenerConnectionCreated;
typedef std::function<void()> ListenerConnected;
typedef std::function<void(bool /* wanted */)> ListenerDisconnected;
typedef std::function<void()> ListenerConnected;
typedef std::function<void(bool /* wanted */)> ListenerDisconnected;
MySQLManager();
virtual ~MySQLManager();
MySQLManager();
virtual ~MySQLManager();
result connect(const std::string &string) override;
bool connected() override;
result disconnect() override;
result connect(const std::string &string) override;
bool connected() override;
result disconnect() override;
ListenerDisconnected listener_disconnected;
protected:
std::shared_ptr<CommandData> copyCommandData(std::shared_ptr<CommandData> ptr) override;
std::shared_ptr<CommandData> allocateCommandData() override;
result executeCommand(std::shared_ptr<CommandData> ptr) override;
result queryCommand(std::shared_ptr<CommandData> ptr, const QueryCallback &fn) override;
ListenerDisconnected listener_disconnected;
protected:
std::shared_ptr<CommandData> copyCommandData(std::shared_ptr<CommandData> ptr) override;
std::shared_ptr<CommandData> allocateCommandData() override;
result executeCommand(std::shared_ptr<CommandData> ptr) override;
result queryCommand(std::shared_ptr<CommandData> ptr, const QueryCallback &fn) override;
public:
std::unique_ptr<AcquiredConnection> next_connection();
void connection_closed(const std::shared_ptr<Connection>& /* connection */);
public:
std::unique_ptr<AcquiredConnection> next_connection();
void connection_closed(const std::shared_ptr<Connection>& /* connection */);
std::mutex connections_lock;
std::condition_variable connections_condition;
std::deque<std::shared_ptr<Connection>> connections;
std::mutex connections_lock;
std::condition_variable connections_condition;
std::deque<std::shared_ptr<Connection>> connections;
bool disconnecting = false;
};
}
bool disconnecting = false;
};
}