TeaSpeak/Teaspeak-Server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Minor bug fixes

Browse Source
This commit is contained in:
WolverinDEV 2020-04-29 10:34:22 +02:00
parent dfd33eb674
commit cd8e2974f2
6 changed files with 146 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
server/CMakeLists.txt
View File

@ -82,6 +82,7 @@ set(SERVER_SOURCE_FILES
src/client/query/QueryClientCommands.cpp
src/client/query/QueryClientNotify.cpp
src/file/FileServer.cpp
src/manager/IpListManager.cpp

3
server/src/client/ConnectedClient.cpp
View File

@ -182,6 +182,8 @@ void ConnectedClient::updateChannelClientProperties(bool lock_channel_tree, bool
client_channel_lock.lock();
}
/* might have been changed since we locked the tree */
if(this->currentChannel) {
deque<ChannelId> deleted;
for(const auto& update_entry : this->channels->update_channel_path(server_ref->channelTree->tree_head(), server_ref->channelTree->find_linked_entry(this->currentChannel->channelId()))) {
if(update_entry.first)
@ -192,6 +194,7 @@ void ConnectedClient::updateChannelClientProperties(bool lock_channel_tree, bool
this->notifyChannelHide(deleted, false); /* we've locked the tree before */
}
}
}
void ConnectedClient::updateTalkRights(permission::PermissionValue talk_power) {
bool flag = false;

6
server/src/client/command_handler/client.cpp
View File

@ -203,14 +203,14 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
}
}
clients.emplace_back(std::move(target_client));
result.emplace_result(permission::ok);
result.emplace_result(error::ok);
}
if (!channel->properties()[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED].as<bool>() || !channel->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED].as<bool>()) {
if(!permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_join_ignore_maxclients, channel->channelId()))) {
if(!channel->properties()[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED].as<bool>()) {
auto maxClients = channel->properties()[property::CHANNEL_MAXCLIENTS].as<int32_t>();
if (maxClients >= 0 && maxClients <= this->server->getClientsByChannel(channel).size() + clients.size())
if (maxClients >= 0 && maxClients < this->server->getClientsByChannel(channel).size() + clients.size())
return command_result{error::channel_maxclients_reached};
}
if(!channel->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED].as<bool>()) {
@ -227,7 +227,7 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
for(const auto& entry : this->server->getClientsByChannelRoot(channel, false))
if(entry.get() != this) client_count++; //Dont count the client itself
if (maxClients >= 0 && maxClients <= client_count + clients.size())
if (maxClients >= 0 && maxClients < client_count + clients.size())
return command_result{error::channel_maxfamily_reached};
}
}

3
server/src/client/command_handler/server.cpp
View File

@ -754,6 +754,9 @@ command_result ConnectedClient::handleCommandServerGroupDelClient(Command &cmd)
for(const auto& _server : target_server ? std::deque<shared_ptr<VirtualServer>>{target_server} : serverInstance->getVoiceServerManager()->serverInstances()) {
for (const auto &targetClient : _server->findClientsByCldbId(target_cldbid)) {
ConnectedLockedClient clock{targetClient};
if(!clock) continue;
if (_server->notifyClientPropertyUpdates(targetClient, _server->groups->update_server_group_property(targetClient, true, targetClient->getChannel()))) {
for (const auto &client : _server->getClients()) {
if(client->isClientVisible(targetClient, true) || client == targetClient)

5
server/src/file/FileServer.cpp Normal file
View File

@ -0,0 +1,5 @@
//
// Created by WolverinDEV on 28/04/2020.
//
#include "FileServer.h"

124
server/src/file/FileServer.h Normal file
View File

@ -0,0 +1,124 @@
#pragma once
#include <string>
#include <chrono>
#include <Definitions.h>
#include <condition_variable>
#include <variant>
#include <vector>
namespace ts::server::file {
enum struct ExecuteStatus {
UNKNOWN,
WAITING,
SUCCESS,
ERROR
};
template <typename error_t, typename response_t>
class ExecuteResponse {
public:
ExecuteStatus status{ExecuteStatus::UNKNOWN};
[[nodiscard]] inline const response_t& response() const { return std::get<response_t>(this->response_); }
[[nodiscard]] inline const response_t& error() const { return std::get<error_t>(this->response_); }
inline void wait() const {
std::unique_lock nlock{this->notify_mutex};
this->notify_cv.wait(nlock, [&]{ return this->status != ExecuteStatus::WAITING; });
}
template<typename _Rep, typename _Period>
[[nodiscard]] inline bool wait_for(const std::chrono::duration<_Rep, _Period>& time) const {
std::unique_lock nlock{this->notify_mutex};
return this->notify_cv.wait_for(nlock, time, [&]{ return this->status != ExecuteStatus::WAITING; });
}
private:
std::variant<error_t, response_t> response_{};
std::mutex& notify_mutex;
std::condition_variable& notify_cv;
};
namespace filesystem {
struct DirectoryQueryError {
enum Type {
UNKNOWN,
};
Type type{};
std::string extra_message{};
};
struct DirectoryEntry {
enum Type {
UNKNOWN,
DIRECTORY,
FILE
};
Type type{Type::UNKNOWN};
std::string name{};
std::chrono::system_clock::time_point created_at{};
std::chrono::system_clock::time_point modified_at{};
size_t size{0};
};
struct DirectoryModifyError {
enum Type {
UNKNOWN,
};
Type type{};
std::string extra_message{};
};
struct FileModifyError {
enum Type {
UNKNOWN,
};
Type type{};
std::string extra_message{};
};
class AbstractProvider {
public:
typedef ExecuteResponse<DirectoryQueryError, std::vector<DirectoryEntry>> directory_query_response_t;
/* channels */
[[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_channel_directory(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<DirectoryModifyError, void>> create_channel_directory(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<DirectoryModifyError, void>> delete_channel_directory(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError, void>> delete_channel_file(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError, void>> rename_channel_file(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
/* icons */
[[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_icon_directory(ServerId /* server */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError, void>> delete_icon(ServerId /* server */, const std::string& /* name */);
/* avatars */
[[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_avatar_directory(ServerId /* server */);
[[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError, void>> delete_avatar(ServerId /* server */, const std::string& /* name */);
private:
};
}
namespace transfer {
class AbstractProvider {
public:
enum TransferDirection {
UPLOAD,
DOWNLOAD
};
void initialize_channel_transfer(TransferDirection /* direction */, ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
void initialize_icon_transfer(TransferDirection /* direction */, ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
void initialize_avatar_transfer(TransferDirection /* direction */, ServerId /* server */, ChannelId /* channel */, const std::string& /* path */);
private:
};
}
class AbstractFileServer {
public:
private:
};
}