2196 lines
101 KiB
C++
2196 lines
101 KiB
C++
#include <memory>
|
|
|
|
#include "../../InstanceHandler.h"
|
|
#include "../../PermissionCalculator.h"
|
|
#include "../../manager/ActionLogger.h"
|
|
#include "../../manager/ConversationManager.h"
|
|
#include "../../manager/PermissionNameMapper.h"
|
|
#include "../../server/QueryServer.h"
|
|
#include "../../server/VoiceServer.h"
|
|
#include "../../groups/GroupManager.h"
|
|
#include "../ConnectedClient.h"
|
|
#include "../InternalClient.h"
|
|
#include "../music/MusicClient.h"
|
|
#include "../query/QueryClient.h"
|
|
#include "../voice/VoiceClient.h"
|
|
#include "PermissionManager.h"
|
|
#include <algorithm>
|
|
#include <bitset>
|
|
#include <cstdint>
|
|
|
|
#include "./bulk_parsers.h"
|
|
|
|
#include <Properties.h>
|
|
#include <bbcode/bbcodes.h>
|
|
#include <log/LogUtils.h>
|
|
#include <misc/base64.h>
|
|
#include <misc/digest.h>
|
|
#include <misc/utf8.h>
|
|
|
|
using namespace std::chrono;
|
|
using namespace std;
|
|
using namespace ts;
|
|
using namespace ts::server;
|
|
|
|
command_result ConnectedClient::handleCommandChannelGetDescription(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(0);
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<BasicChannel>(l_channel->entry);
|
|
assert(channel);
|
|
|
|
std::shared_lock channel_lock{this->channel_tree_mutex};
|
|
if(!this->channel_tree->channel_visible(channel)) {
|
|
return ts::command_result{error::channel_invalid_id};
|
|
}
|
|
|
|
ClientPermissionCalculator permission_calculator{this, channel};
|
|
if(!permission_calculator.permission_granted(permission::b_channel_ignore_description_view_power, 1)) {
|
|
auto required_view_power = channel->permissions()->permission_value_flagged(permission::i_channel_needed_description_view_power);
|
|
required_view_power.clear_flag_on_zero();
|
|
|
|
if(!permission_calculator.permission_granted(permission::i_channel_description_view_power, required_view_power)) {
|
|
return command_result{permission::i_channel_description_view_power};
|
|
}
|
|
}
|
|
|
|
auto channel_description = channel->properties()[property::CHANNEL_DESCRIPTION].value();
|
|
auto channel_description_limit = this->getType() == CLIENT_TEAMSPEAK ? 8192 : 131130;
|
|
|
|
if(channel_description.length() > channel_description_limit) {
|
|
channel_description = channel_description.substr(0, channel_description_limit - 3);
|
|
channel_description.append("...");
|
|
}
|
|
|
|
ts::command_builder notify{this->notify_response_command("notifychanneledited")};
|
|
notify.put_unchecked(0, "cid", channel->channelId());
|
|
notify.put_unchecked(0, "reasonid", "9");
|
|
notify.put_unchecked(0, "channel_description", channel_description);
|
|
this->sendCommand(notify);
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelSubscribe(Command &cmd) {
|
|
CMD_REF_SERVER(ref_server);
|
|
CMD_RESET_IDLE;
|
|
|
|
bool flood_points{false};
|
|
std::deque<std::shared_ptr<BasicChannel>> target_channels{};
|
|
//target_channels.reserve(cmd.bulkCount());
|
|
|
|
ts::command_result_bulk result{};
|
|
result.emplace_result_n(cmd.bulkCount(), error::ok);
|
|
|
|
{
|
|
std::shared_lock server_channel_lock{this->server->channel_tree_mutex};
|
|
std::lock_guard client_channel_lock{this->channel_tree_mutex};
|
|
|
|
for (int index{0}; index < cmd.bulkCount(); index++) {
|
|
auto target_channel_id = cmd[index]["cid"].as<ChannelId>();
|
|
auto local_channel = this->channel_view()->find_channel(target_channel_id);
|
|
if (!local_channel) {
|
|
result.set_result(index, ts::command_result{error::channel_invalid_id});
|
|
continue;
|
|
}
|
|
|
|
auto channel = this->server->channelTree->findChannel(target_channel_id);
|
|
if (!channel) {
|
|
result.set_result(index, ts::command_result{error::channel_invalid_id});
|
|
continue;
|
|
}
|
|
|
|
target_channels.push_back(channel);
|
|
if (!flood_points && std::chrono::system_clock::now() - local_channel->view_timestamp > seconds(5)) {
|
|
flood_points = true;
|
|
|
|
this->increaseFloodPoints(15);
|
|
if(this->shouldFloodBlock()) {
|
|
result.set_result(index, ts::command_result{error::ban_flooding});
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!target_channels.empty()) {
|
|
this->subscribeChannel(target_channels, false, false);
|
|
}
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelSubscribeAll(Command &cmd) {
|
|
CMD_REQ_SERVER;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(20);
|
|
|
|
{
|
|
std::shared_lock server_channel_lock{this->server->channel_tree_mutex};
|
|
std::lock_guard client_channel_lock{this->channel_tree_mutex};
|
|
this->subscribeChannel(this->server->channelTree->channels(), false, false);
|
|
this->subscribeToAll = true;
|
|
}
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelUnsubscribe(Command &cmd) {
|
|
CMD_REQ_SERVER;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
ts::command_result_bulk result{};
|
|
result.emplace_result_n(cmd.bulkCount(), error::ok);
|
|
|
|
{
|
|
std::shared_lock server_channel_lock{this->server->channel_tree_mutex};
|
|
std::lock_guard client_channel_lock{this->channel_tree_mutex};
|
|
|
|
std::deque<shared_ptr<BasicChannel>> channels{};
|
|
for (int index = 0; index < cmd.bulkCount(); index++) {
|
|
auto channel = this->server->channelTree->findChannel(cmd["cid"].as<ChannelId>());
|
|
if (!channel) {
|
|
result.set_result(index, ts::command_result{error::channel_invalid_id});
|
|
continue;
|
|
}
|
|
|
|
channels.push_front(channel);
|
|
}
|
|
|
|
this->unsubscribeChannel(channels, false);
|
|
}
|
|
|
|
return command_result{std::move(result)};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelUnsubscribeAll(Command &cmd) {
|
|
CMD_REQ_SERVER;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(25);
|
|
|
|
{
|
|
std::shared_lock server_channel_lock{this->server->channel_tree_mutex};
|
|
std::lock_guard client_channel_lock{this->channel_tree_mutex};
|
|
this->unsubscribeChannel(this->server->channelTree->channels(), false);
|
|
this->subscribeToAll = false;
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupAdd(Command &cmd) {
|
|
return this->handleCommandGroupAdd(cmd, GroupTarget::GROUPTARGET_CHANNEL);
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupCopy(Command &cmd) {
|
|
return this->handleCommandGroupCopy(cmd, GroupTarget::GROUPTARGET_CHANNEL);
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupRename(Command &cmd) {
|
|
return this->handleCommandGroupRename(cmd, GroupTarget::GROUPTARGET_CHANNEL);
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupDel(Command &cmd) {
|
|
return this->handleCommandGroupDel(cmd, GroupTarget::GROUPTARGET_CHANNEL);
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupList(Command &) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_channelgroup_list, 1);
|
|
|
|
std::optional<ts::command_builder> notify{};
|
|
this->notifyChannelGroupList(notify, this->getType() != ClientType::CLIENT_QUERY);
|
|
|
|
this->command_times.servergrouplist = system_clock::now();
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupClientList(Command &cmd) {
|
|
CMD_REQ_SERVER;
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
auto target_channel_id = cmd[0].has("cid") ? cmd["cid"].as<ChannelId>() : 0;
|
|
auto target_client_database_id = cmd[0].has("cldbid") ? cmd["cldbid"].as<ClientDbId>() : 0;
|
|
auto target_group_id = cmd[0].has("cgid") ? cmd["cgid"].as<GroupId>() : 0;
|
|
|
|
ACTION_REQUIRES_PERMISSION(permission::b_virtualserver_channelgroup_client_list, 1, target_channel_id);
|
|
|
|
auto result = this->server->group_manager()->assignments().channel_group_list(target_group_id, target_channel_id, target_client_database_id);
|
|
if(result.empty()) {
|
|
return ts::command_result{error::database_empty_result};
|
|
}
|
|
|
|
|
|
size_t index{0};
|
|
ts::command_builder notify{this->notify_response_command("notifychannelgroupclientlist"), 64, result.size()};
|
|
for(const auto& entry : result) {
|
|
auto bulk = notify.bulk(index++);
|
|
bulk.put_unchecked("cgid", std::get<0>(entry));
|
|
bulk.put_unchecked("cid", std::get<1>(entry));
|
|
bulk.put_unchecked("cldbid", std::get<2>(entry));
|
|
}
|
|
this->sendCommand(notify);
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupPermList(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_channelgroup_permission_list, 1);
|
|
|
|
auto group_manager = this->server ? this->server->group_manager() : serverInstance->group_manager();
|
|
auto channelGroup = group_manager->channel_groups()->find_group(groups::GroupCalculateMode::GLOBAL, cmd["cgid"].as<GroupId>());
|
|
if (!channelGroup) {
|
|
return command_result{error::group_invalid_id};
|
|
}
|
|
|
|
if (!this->notifyGroupPermList(channelGroup, cmd.hasParm("permsid"))) {
|
|
return command_result{error::database_empty_result};
|
|
}
|
|
|
|
if (this->getType() == ClientType::CLIENT_TEAMSPEAK && this->command_times.last_notify + this->command_times.notify_timeout < system_clock::now()) {
|
|
this->sendTSPermEditorWarning();
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupAddPerm(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
auto group_id = cmd["cgid"].as<GroupId>();
|
|
|
|
std::shared_ptr<groups::ChannelGroupManager> owning_manager{};
|
|
auto group_manager = this->server ? this->server->group_manager() : serverInstance->group_manager();
|
|
auto group = group_manager->channel_groups()->find_group_ext(owning_manager, groups::GroupCalculateMode::GLOBAL, group_id);
|
|
|
|
if(!group) {
|
|
return ts::command_result{error::group_invalid_id};
|
|
}
|
|
|
|
ACTION_REQUIRES_GROUP_PERMISSION(group, permission::i_channel_group_needed_modify_power, permission::i_channel_group_modify_power, true);
|
|
|
|
auto target_server = group_manager->channel_groups() == owning_manager ? this->server : nullptr;
|
|
return this->executeGroupPermissionEdit(cmd, { group }, target_server, permission::v2::PermissionUpdateType::set_value);
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelGroupDelPerm(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
auto group_id = cmd["cgid"].as<GroupId>();
|
|
|
|
std::shared_ptr<groups::ChannelGroupManager> owning_manager{};
|
|
auto group_manager = this->server ? this->server->group_manager() : serverInstance->group_manager();
|
|
auto group = group_manager->channel_groups()->find_group_ext(owning_manager, groups::GroupCalculateMode::GLOBAL, group_id);
|
|
|
|
if(!group) {
|
|
return ts::command_result{error::group_invalid_id};
|
|
}
|
|
|
|
ACTION_REQUIRES_GROUP_PERMISSION(group, permission::i_channel_group_needed_modify_power, permission::i_channel_group_modify_power, true);
|
|
|
|
auto target_server = group_manager->channel_groups() == owning_manager ? this->server : nullptr;
|
|
return this->executeGroupPermissionEdit(cmd, { group }, target_server, permission::v2::PermissionUpdateType::delete_value);
|
|
}
|
|
|
|
//TODO: Test if parent or previous is deleted!
|
|
command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(25);
|
|
CMD_CHK_PARM_COUNT(1);
|
|
|
|
auto target_tree = this->server ? this->server->channelTree : &*serverInstance->getChannelTree();
|
|
std::shared_lock channel_tree_read_lock{this->server ? this->server->channel_tree_mutex : serverInstance->getChannelTreeLock()};
|
|
ChannelId parent_channel_id = cmd[0].has("cpid") ? cmd["cpid"].as<ChannelId>() : 0;
|
|
|
|
#define test_permission(required, permission_type) \
|
|
do { \
|
|
if (!permission::v2::permission_granted(required, this->calculate_permission(permission_type, parent_channel_id, false))) \
|
|
return command_result{permission_type}; \
|
|
} while (0)
|
|
|
|
std::shared_ptr<TreeView::LinkedTreeEntry> parent;
|
|
std::map<property::ChannelProperties, std::string> new_values{};
|
|
for (const auto &key : cmd[0].keys()) {
|
|
if (key == "return_code") {
|
|
continue;
|
|
}
|
|
|
|
if (key == "cpid") {
|
|
if(cmd[key].string().empty()) {
|
|
continue;
|
|
}
|
|
|
|
auto value = cmd["cpid"].as<ChannelId>();
|
|
if(value > 0) {
|
|
parent = target_tree->findLinkedChannel(value);
|
|
if(!parent) {
|
|
return ts::command_result{error::channel_invalid_id};
|
|
}
|
|
test_permission(1, permission::b_channel_create_child);
|
|
}
|
|
|
|
new_values[property::CHANNEL_PID] = cmd[key].string();
|
|
continue;
|
|
}
|
|
|
|
const auto &property = property::find<property::ChannelProperties>(key);
|
|
if (property == property::CHANNEL_UNDEFINED) {
|
|
logError(this->getServerId(), R"({} Tried to create a channel with a non property channel property "{}" to "{}")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if ((property.flags & property::FLAG_USER_EDITABLE) == 0) {
|
|
logError(this->getServerId(), "{} Tried to create a channel with a property which is not changeable. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if (!property.validate_input(cmd[key].as<string>())) {
|
|
logError(this->getServerId(), "{} Tried to create a channel with a property with an invalid value. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if (key == "channel_icon_id") {
|
|
/* the creator has the motify permission by default */
|
|
} else if (key == "channel_order") {
|
|
if(cmd[key].string().empty()) {
|
|
continue;
|
|
}
|
|
|
|
test_permission(true, permission::b_channel_create_with_sortorder);
|
|
} else if (key == "channel_flag_default") {
|
|
if(cmd["channel_flag_default"].as<bool>()) {
|
|
test_permission(true, permission::b_channel_create_with_default);
|
|
}
|
|
} else if (key == "channel_name" ||key == "channel_name_phonetic") {
|
|
/* channel create requires a name */
|
|
} else if (key == "channel_topic") {
|
|
if(!cmd[key].string().empty()) {
|
|
test_permission(true, permission::b_channel_create_with_topic);
|
|
}
|
|
} else if (key == "channel_description") {
|
|
auto value = cmd[key].string();
|
|
if(!value.empty()) {
|
|
test_permission(true, permission::b_channel_create_with_description);
|
|
|
|
if (!permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_any, parent_channel_id))) {
|
|
auto bbcode_image = bbcode::sloppy::has_image(value);
|
|
auto bbcode_url = bbcode::sloppy::has_url(value);
|
|
debugMessage(this->getServerId(), "Channel description contains bb codes: Image: {} URL: {}", bbcode_image, bbcode_url);
|
|
if (bbcode_image && !permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_image, parent_channel_id))) {
|
|
return command_result{permission::b_client_use_bbcode_image};
|
|
}
|
|
|
|
if (bbcode_url && !permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_url, parent_channel_id))) {
|
|
return command_result{permission::b_client_use_bbcode_url};
|
|
}
|
|
}
|
|
}
|
|
} else if (key == "channel_codec") {
|
|
/* TODO: Test for the codec itself! */
|
|
} else if (key == "channel_codec_quality") {
|
|
/* TODO: Test for the value itself! */
|
|
} else if (key == "channel_codec_is_unencrypted") {
|
|
if (cmd["channel_codec_is_unencrypted"].as<bool>()) {
|
|
test_permission(true, permission::b_channel_modify_make_codec_encrypted);
|
|
}
|
|
} else if (key == "channel_needed_talk_power") {
|
|
test_permission(true, permission::b_channel_create_with_needed_talk_power);
|
|
} else if (key == "channel_maxclients" || key == "channel_flag_maxclients_unlimited") {
|
|
test_permission(true, permission::b_channel_create_with_maxclients);
|
|
} else if (key == "channel_maxfamilyclients" || key == "channel_flag_maxfamilyclients_unlimited" || key == "channel_flag_maxfamilyclients_inherited") {
|
|
test_permission(true, permission::b_channel_create_with_maxfamilyclients);
|
|
} else if (key == "channel_flag_permanent" || key == "channel_flag_semi_permanent") {
|
|
if (cmd[0].has("channel_flag_permanent") && cmd["channel_flag_permanent"].as<bool>()) {
|
|
test_permission(true, permission::b_channel_create_permanent);
|
|
} else if (cmd[0].has("channel_flag_semi_permanent") && cmd["channel_flag_semi_permanent"].as<bool>()) {
|
|
test_permission(true, permission::b_channel_create_semi_permanent);
|
|
} else {
|
|
test_permission(true, permission::b_channel_create_temporary);
|
|
}
|
|
} else if (key == "channel_delete_delay") {
|
|
ACTION_REQUIRES_PERMISSION(permission::i_channel_create_modify_with_temp_delete_delay, cmd["channel_delete_delay"].as<permission::PermissionValue>(), parent_channel_id);
|
|
} else if (key == "channel_password" || key == "channel_flag_password") {
|
|
/* no need to test right now */
|
|
} else if (key == "channel_conversation_history_length") {
|
|
auto value = cmd["channel_conversation_history_length"].as<int64_t>();
|
|
if (value == 0) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_history_unlimited, 1, parent_channel_id);
|
|
} else {
|
|
ACTION_REQUIRES_PERMISSION(permission::i_channel_create_modify_conversation_history_length, 1, parent_channel_id);
|
|
}
|
|
} else if (key == "channel_flag_conversation_private") {
|
|
auto value = cmd["channel_flag_conversation_private"].as<bool>();
|
|
if (value) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_private, 1, parent_channel_id);
|
|
new_values[property::CHANNEL_CONVERSATION_MODE] = std::to_string(CHANNELCONVERSATIONMODE_PRIVATE);
|
|
} else {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_public, 1, parent_channel_id);
|
|
new_values[property::CHANNEL_CONVERSATION_MODE] = std::to_string(CHANNELCONVERSATIONMODE_PUBLIC);
|
|
}
|
|
continue;
|
|
} else if (key == "channel_conversation_mode") {
|
|
auto value = cmd["channel_conversation_mode"].as<ChannelConversationMode>();
|
|
switch (value) {
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_private, 1, parent_channel_id);
|
|
break;
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PUBLIC:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_public, 1, parent_channel_id);
|
|
break;
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_none, 1, parent_channel_id);
|
|
break;
|
|
default:
|
|
return command_result{error::parameter_invalid, "channel_conversation_mode"};
|
|
}
|
|
} else {
|
|
logCritical(
|
|
this->getServerId(),
|
|
"{} Tried to change a editable channel property but we haven't found a permission. Please report this error. (Channel property: {})",
|
|
CLIENT_STR_LOG_PREFIX,
|
|
key
|
|
);
|
|
continue;
|
|
}
|
|
|
|
new_values.emplace((property::ChannelProperties) property.property_index, cmd[key].string());
|
|
}
|
|
|
|
/* Fix since the default value of channel_flag_permanent is 1 which should be zero... */
|
|
if(!new_values.contains(property::CHANNEL_FLAG_PERMANENT)) {
|
|
new_values[property::CHANNEL_FLAG_PERMANENT] = std::to_string(false);
|
|
}
|
|
|
|
if (!cmd[0]["channel_flag_permanent"].as<bool>() && !this->server) {
|
|
return command_result{error::parameter_invalid, "You can only create a permanent channel"};
|
|
}
|
|
|
|
if (cmd[0].has("channel_flag_password") && cmd[0]["channel_flag_password"].as<bool>()) {
|
|
test_permission(1, permission::b_channel_create_with_password);
|
|
} else if (permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_create_modify_with_force_password, parent_channel_id, false))) {
|
|
return command_result{permission::b_channel_create_modify_with_force_password};
|
|
}
|
|
|
|
auto delete_delay = cmd[0].has("channel_delete_delay") ? cmd["channel_delete_delay"].as<permission::PermissionValue>() : 0UL;
|
|
if (delete_delay == 0) {
|
|
if (this->server) {
|
|
new_values[property::CHANNEL_DELETE_DELAY] = this->server->properties()[property::VIRTUALSERVER_CHANNEL_TEMP_DELETE_DELAY_DEFAULT].value();
|
|
} else {
|
|
new_values[property::CHANNEL_DELETE_DELAY] = "60";
|
|
}
|
|
} else {
|
|
test_permission(cmd["channel_delete_delay"].as<permission::PermissionValue>(), permission::i_channel_create_modify_with_temp_delete_delay);
|
|
}
|
|
|
|
|
|
{
|
|
size_t created_total = 0, created_tmp = 0, created_semi = 0, created_perm = 0;
|
|
auto own_cldbid = this->getClientDatabaseId();
|
|
for (const auto &channel : target_tree->channels()) {
|
|
created_total++;
|
|
if (channel->properties()[property::CHANNEL_CREATED_BY] == own_cldbid) {
|
|
if (channel->properties()[property::CHANNEL_FLAG_PERMANENT].as_or<bool>(false)) {
|
|
created_perm++;
|
|
} else if (channel->properties()[property::CHANNEL_FLAG_SEMI_PERMANENT].as_or<bool>(false)) {
|
|
created_semi++;
|
|
} else {
|
|
created_tmp++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this->server && created_total >=
|
|
this->server->properties()[property::VIRTUALSERVER_MAX_CHANNELS].as_or<uint64_t>(0))
|
|
return command_result{error::channel_limit_reached};
|
|
|
|
auto max_channels = this->calculate_permission(permission::i_client_max_channels, parent_channel_id, false);
|
|
if (max_channels.has_value) {
|
|
if (!permission::v2::permission_granted(created_perm + created_semi + created_tmp + 1, max_channels)) {
|
|
return command_result{permission::i_client_max_channels};
|
|
}
|
|
}
|
|
|
|
if (cmd[0]["channel_flag_permanent"].as<bool>()) {
|
|
max_channels = this->calculate_permission(permission::i_client_max_permanent_channels, parent_channel_id, false);
|
|
|
|
if (max_channels.has_value) {
|
|
if (!permission::v2::permission_granted(created_perm + 1, max_channels)) {
|
|
return command_result{permission::i_client_max_permanent_channels};
|
|
}
|
|
}
|
|
} else if (cmd[0]["channel_flag_semi_permanent"].as<bool>()) {
|
|
max_channels = this->calculate_permission(permission::i_client_max_semi_channels, parent_channel_id, false);
|
|
|
|
if (max_channels.has_value) {
|
|
if (!permission::v2::permission_granted(created_semi + 1, max_channels)) {
|
|
return command_result{permission::i_client_max_semi_channels};
|
|
}
|
|
}
|
|
} else {
|
|
max_channels = this->calculate_permission(permission::i_client_max_temporary_channels, parent_channel_id, false);
|
|
|
|
if (max_channels.has_value) {
|
|
if (!permission::v2::permission_granted(created_tmp + 1, max_channels)) {
|
|
return command_result{permission::i_client_max_temporary_channels};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
auto min_channel_deep = this->calculate_permission(permission::i_channel_min_depth, parent_channel_id, false);
|
|
auto max_channel_deep = this->calculate_permission(permission::i_channel_max_depth, parent_channel_id, false);
|
|
|
|
if (min_channel_deep.has_value || max_channel_deep.has_value) {
|
|
auto channel_deep = 0;
|
|
auto local_parent = parent;
|
|
while (local_parent) {
|
|
channel_deep++;
|
|
{
|
|
const auto typed_parent = dynamic_pointer_cast<ServerChannel>(local_parent->entry);
|
|
if (typed_parent->deleted) {
|
|
return command_result{error::channel_is_deleted, "One of the parents has been deleted"};
|
|
}
|
|
}
|
|
local_parent = local_parent->parent.lock();
|
|
}
|
|
|
|
if (min_channel_deep.has_value && (channel_deep < min_channel_deep.value && !min_channel_deep.has_infinite_power())) return command_result{permission::i_channel_min_depth};
|
|
if (max_channel_deep.has_value && !permission::v2::permission_granted(channel_deep, max_channel_deep)) return command_result{permission::i_channel_max_depth};
|
|
}
|
|
}
|
|
|
|
if (!new_values.contains(property::CHANNEL_ORDER)) {
|
|
auto last = parent ? parent->child_head : target_tree->tree_head();
|
|
while (last && last->next) {
|
|
last = last->next;
|
|
}
|
|
|
|
if (last) {
|
|
new_values[property::CHANNEL_ORDER] = std::to_string(last->entry->channelId());
|
|
} else {
|
|
new_values[property::CHANNEL_ORDER] = "0";
|
|
}
|
|
}
|
|
|
|
channel_tree_read_lock.unlock();
|
|
|
|
ChannelId channel_id;
|
|
auto result = this->execute_channel_edit(channel_id, new_values, true);
|
|
if(result.has_error()) {
|
|
return result;
|
|
}
|
|
|
|
channel_tree_read_lock.lock();
|
|
auto created_channel = target_tree->findChannel(channel_id);
|
|
if(!created_channel) {
|
|
return ts::command_result{error::vs_critical, "failed to find created channel"};
|
|
}
|
|
|
|
created_channel->properties()[property::CHANNEL_CREATED_BY] = this->getClientDatabaseId();
|
|
created_channel->properties()[property::CHANNEL_CREATED_AT] =
|
|
std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
|
|
|
|
{
|
|
auto default_modify_power = this->calculate_permission(permission::i_channel_modify_power, parent_channel_id, false);
|
|
auto default_delete_power = this->calculate_permission(permission::i_channel_delete_power, parent_channel_id, false);
|
|
|
|
auto permission_manager = created_channel->permissions();
|
|
permission_manager->set_permission(
|
|
permission::i_channel_needed_modify_power,
|
|
{default_modify_power.has_value ? default_modify_power.value : 0, 0},
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
permission::v2::PermissionUpdateType::do_nothing);
|
|
|
|
permission_manager->set_permission(
|
|
permission::i_channel_needed_delete_power,
|
|
{default_delete_power.has_value ? default_delete_power.value : 0, 0},
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
permission::v2::PermissionUpdateType::do_nothing);
|
|
}
|
|
|
|
/* log channel create */
|
|
{
|
|
log::ChannelType log_channel_type;
|
|
switch (created_channel->channelType()) {
|
|
case ChannelType::permanent:
|
|
log_channel_type = log::ChannelType::PERMANENT;
|
|
break;
|
|
|
|
case ChannelType::semipermanent:
|
|
log_channel_type = log::ChannelType::SEMI_PERMANENT;
|
|
break;
|
|
|
|
case ChannelType::temporary:
|
|
log_channel_type = log::ChannelType::TEMPORARY;
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
return ts::command_result{error::vs_critical};
|
|
}
|
|
|
|
serverInstance->action_logger()->channel_logger.log_channel_create(this->getServerId(), this->ref(), created_channel->channelId(), log_channel_type);
|
|
}
|
|
|
|
if (this->server) {
|
|
const auto self_lock = this->ref();
|
|
|
|
auto admin_group_id = this->server->properties()[property::VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP].as_or<GroupId>(0);
|
|
auto admin_group = this->server->group_manager()->channel_groups()->find_group(groups::GroupCalculateMode::GLOBAL, admin_group_id);
|
|
if(!admin_group) {
|
|
logError(this->getServerId(), "Missing servers default channel admin group {}.", admin_group_id);
|
|
}
|
|
|
|
/* admin_group might still be null since default_channel_group() could return nullptr */
|
|
if(admin_group) {
|
|
this->server->group_manager()->assignments().set_channel_group(this->getClientDatabaseId(), admin_group->group_id(), created_channel->channelId(), false);
|
|
serverInstance->action_logger()->group_assignment_logger.log_group_assignment_remove(
|
|
this->getServerId(), this->server->getServerRoot(),
|
|
log::GroupTarget::CHANNEL,
|
|
admin_group->group_id(), admin_group->display_name(),
|
|
this->getClientDatabaseId(), this->getDisplayName()
|
|
);
|
|
}
|
|
|
|
if (created_channel->channelType() == ChannelType::temporary && (this->getType() == ClientType::CLIENT_TEAMSPEAK || this->getType() == ClientType::CLIENT_WEB || this->getType() == ClientType::CLIENT_TEASPEAK)) {
|
|
channel_tree_read_lock.unlock();
|
|
|
|
std::unique_lock channel_tree_write_lock{this->server->channel_tree_mutex};
|
|
this->server->client_move(
|
|
this->ref(),
|
|
created_channel,
|
|
nullptr,
|
|
"channel created",
|
|
ViewReasonId::VREASON_USER_ACTION,
|
|
true,
|
|
channel_tree_write_lock);
|
|
}
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelDelete(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(25);
|
|
|
|
RESOLVE_CHANNEL_W(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
assert(channel);
|
|
if (channel->deleted) /* channel gets already removed */
|
|
return command_result{error::ok};
|
|
|
|
ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_delete_power, permission::i_channel_delete_power, true);
|
|
for (const auto &ch : channel_tree->channels(channel)) {
|
|
if (ch->defaultChannel())
|
|
return command_result{error::channel_can_not_delete_default};
|
|
}
|
|
|
|
if (this->server) {
|
|
auto clients = this->server->getClientsByChannelRoot(channel, false);
|
|
if (!clients.empty())
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_delete_flag_force, 1, channel->channelId());
|
|
|
|
this->server->delete_channel(channel, this->ref(), "channel deleted", channel_tree_write_lock, false);
|
|
} else {
|
|
auto deleted_channel_ids = channel_tree->deleteChannelRoot(channel);
|
|
for (const auto &channelId : deleted_channel_ids) {
|
|
serverInstance->action_logger()->channel_logger.log_channel_delete(0, this->ref(), channelId, channel->channelId() == channelId ? log::ChannelDeleteReason::USER_ACTION : log::ChannelDeleteReason::PARENT_DELETED);
|
|
}
|
|
this->notifyChannelDeleted(deleted_channel_ids, this->ref());
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(25);
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
assert(channel);
|
|
|
|
ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_modify_power, permission::i_channel_modify_power, true);
|
|
|
|
std::map<property::ChannelProperties, std::string> new_values{};
|
|
for (const auto &key : cmd[0].keys()) {
|
|
if (key == "cid") {
|
|
continue;
|
|
}
|
|
|
|
if (key == "return_code") {
|
|
continue;
|
|
}
|
|
|
|
const auto &property = property::find<property::ChannelProperties>(key);
|
|
if (property == property::CHANNEL_UNDEFINED) {
|
|
logError(this->getServerId(), R"({} Tried to edit a not existing channel property "{}" to "{}")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if ((property.flags & property::FLAG_USER_EDITABLE) == 0) {
|
|
logError(this->getServerId(), "{} Tried to change a channel property which is not changeable. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if (!property.validate_input(cmd[key].as<string>())) {
|
|
logError(this->getServerId(), "{} Tried to change a channel property to an invalid value. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
|
|
continue;
|
|
}
|
|
|
|
if (channel->properties()[property].as<string>() == cmd[key].as<string>()) {
|
|
continue; /* we dont need to update stuff which is the same */
|
|
}
|
|
|
|
if (key == "channel_icon_id") {
|
|
ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_permission_modify_power, permission::i_channel_permission_modify_power, true);
|
|
} else if (key == "channel_order") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_sortorder, 1, channel_id);
|
|
} else if (key == "channel_flag_default") {
|
|
if(cmd["channel_flag_default"].as<bool>()) {
|
|
ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_channel_modify_make_default, 1);
|
|
}
|
|
} else if (key == "channel_name") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_name, 1, channel_id);
|
|
} else if (key == "channel_name_phonetic") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_name, 1, channel_id);
|
|
} else if (key == "channel_topic") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_topic, 1, channel_id);
|
|
} else if (key == "channel_description") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_description, 1, channel_id);
|
|
if (!permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_any, channel_id))) {
|
|
auto bbcode_image = bbcode::sloppy::has_image(cmd[key]);
|
|
auto bbcode_url = bbcode::sloppy::has_url(cmd[key]);
|
|
debugMessage(this->getServerId(), "Channel description contains bb codes: Image: {} URL: {}", bbcode_image, bbcode_url);
|
|
if (bbcode_image && !permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_image, channel_id))) {
|
|
return command_result{permission::b_client_use_bbcode_image};
|
|
}
|
|
|
|
if (bbcode_url && !permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_use_bbcode_url, channel_id))) {
|
|
return command_result{permission::b_client_use_bbcode_url};
|
|
}
|
|
}
|
|
} else if (key == "channel_codec") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_codec, 1, channel_id);
|
|
} else if (key == "channel_codec_quality") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_codec_quality, 1, channel_id);
|
|
} else if (key == "channel_codec_is_unencrypted") {
|
|
if (cmd["channel_codec_is_unencrypted"].as<bool>()) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_make_codec_encrypted, 1, channel_id);
|
|
}
|
|
} else if (key == "channel_needed_talk_power") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_needed_talk_power, 1, channel_id);
|
|
} else if (key == "channel_maxclients" || key == "channel_flag_maxclients_unlimited") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_maxclients, 1, channel_id);
|
|
} else if (key == "channel_maxfamilyclients" || key == "channel_flag_maxfamilyclients_unlimited" || key == "channel_flag_maxfamilyclients_inherited") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_maxfamilyclients, 1, channel_id);
|
|
} else if (key == "channel_flag_permanent" || key == "channel_flag_semi_permanent") {
|
|
if (cmd[0].has("channel_flag_permanent") && cmd["channel_flag_permanent"].as<bool>()) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_make_permanent, 1, channel_id);
|
|
} else if (cmd[0].has("channel_flag_semi_permanent") && cmd["channel_flag_semi_permanent"].as<bool>()) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_make_semi_permanent, 1, channel_id);
|
|
} else {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_make_temporary, 1, channel_id);
|
|
}
|
|
} else if (key == "channel_delete_delay") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_temp_delete_delay, 1, channel_id);
|
|
ACTION_REQUIRES_PERMISSION(permission::i_channel_create_modify_with_temp_delete_delay, cmd["channel_delete_delay"].as<permission::PermissionValue>(), channel_id);
|
|
} else if (key == "channel_password" || key == "channel_flag_password") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_password, 1, channel_id);
|
|
} else if (key == "channel_conversation_history_length") {
|
|
auto value = cmd["channel_conversation_history_length"].as<int64_t>();
|
|
if (value == 0) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_history_unlimited, 1, channel_id);
|
|
} else {
|
|
ACTION_REQUIRES_PERMISSION(permission::i_channel_create_modify_conversation_history_length, 1, channel_id);
|
|
}
|
|
} else if (key == "channel_flag_conversation_private") {
|
|
auto value = cmd["channel_flag_conversation_private"].as<bool>();
|
|
if (value) {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_private, 1, channel_id);
|
|
cmd[property::name(property::CHANNEL_CONVERSATION_MODE)] = CHANNELCONVERSATIONMODE_PRIVATE;
|
|
} else {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_public, 1, channel_id);
|
|
cmd[property::name(property::CHANNEL_CONVERSATION_MODE)] = CHANNELCONVERSATIONMODE_PUBLIC;
|
|
}
|
|
continue;
|
|
} else if (key == "channel_conversation_mode") {
|
|
auto value = cmd["channel_conversation_mode"].as<ChannelConversationMode>();
|
|
switch (value) {
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_private, 1, channel_id);
|
|
break;
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PUBLIC:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_public, 1, channel_id);
|
|
break;
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE:
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_conversation_mode_none, 1, channel_id);
|
|
break;
|
|
default:
|
|
return command_result{error::parameter_invalid, "channel_conversation_mode"};
|
|
}
|
|
} else if(key == "channel_sidebar_mode") {
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_create_modify_sidebar_mode, 1, channel_id);
|
|
} else {
|
|
logCritical(
|
|
this->getServerId(),
|
|
"{} Tried to change a editable channel property but we haven't found a permission. Please report this error. (Channel property: {})",
|
|
CLIENT_STR_LOG_PREFIX,
|
|
key
|
|
);
|
|
continue;
|
|
}
|
|
|
|
new_values.emplace((property::ChannelProperties) property.property_index, cmd[key].string());
|
|
}
|
|
|
|
channel_tree_read_lock.unlock();
|
|
return this->execute_channel_edit(channel_id, new_values, false);
|
|
}
|
|
|
|
/*
|
|
* 1. Basic value validation.
|
|
* 2. Lock the server channel tree in write mode and collect changes
|
|
* 2.1. Apply changes
|
|
* 3. Test if any other channels have been affected and change them (e. g. default channel)
|
|
* 4. notify everyone
|
|
*/
|
|
ts::command_result ConnectedClient::execute_channel_edit(ChannelId& channel_id, const std::map<property::ChannelProperties, std::string>& values, bool is_channel_create) {
|
|
auto server = this->getServer();
|
|
|
|
/*
|
|
* Flags which categories are getting changed.
|
|
* These flags will be set in 2.1.
|
|
*/
|
|
bool updating_name{false};
|
|
bool updating_default{false};
|
|
bool updating_password{false};
|
|
bool updating_max_clients{false};
|
|
bool updating_max_family_clients{false};
|
|
bool updating_talk_power{false};
|
|
bool updating_type{false};
|
|
bool updating_sort_order{false};
|
|
|
|
/* Step 1: Parse all values which are possible and validate them without any context. */
|
|
for(const auto& [ property, value ] : values) {
|
|
try {
|
|
switch(property) {
|
|
case property::CHANNEL_ID:
|
|
continue;
|
|
|
|
case property::CHANNEL_PID:
|
|
case property::CHANNEL_ORDER: {
|
|
converter<ChannelId>::from_string_view(value);
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_NAME:
|
|
case property::CHANNEL_NAME_PHONETIC: {
|
|
auto length = utf8::count_characters(value);
|
|
if(length < 0 || length > 40) {
|
|
/* max channel name length is 40 */
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
|
|
if(length == 0 && property == property::CHANNEL_NAME) {
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_TOPIC:
|
|
if(value.length() > 255) {
|
|
/* max channel name length is 255 bytes, everythign else will disconnect the client */
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
|
|
case property::CHANNEL_DESCRIPTION:
|
|
if(value.length() > 8192) {
|
|
/* max channel name length is 8192 bytes, everythign else will disconnect the client */
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
|
|
case property::CHANNEL_PASSWORD:
|
|
updating_password = true;
|
|
break;
|
|
|
|
case property::CHANNEL_CODEC: {
|
|
auto codec_value = converter<uint32_t>::from_string_view(value);
|
|
if (!(codec_value >= 4 && codec_value <= 5)) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_CODEC_QUALITY: {
|
|
auto codec_value = converter<uint32_t>::from_string_view(value);
|
|
if (codec_value > 10) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_MAXCLIENTS:
|
|
case property::CHANNEL_MAXFAMILYCLIENTS: {
|
|
auto max_clients = converter<int>::from_string_view(value);
|
|
if(max_clients < -1) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_FLAG_PERMANENT:
|
|
case property::CHANNEL_FLAG_SEMI_PERMANENT:
|
|
case property::CHANNEL_CODEC_IS_UNENCRYPTED:
|
|
case property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED:
|
|
case property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED:
|
|
case property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED: {
|
|
/* validate value */
|
|
converter<bool>::from_string_view(value);
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_FLAG_PASSWORD: {
|
|
converter<bool>::from_string_view(value);
|
|
updating_password = true;
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_FLAG_DEFAULT: {
|
|
if(!converter<bool>::from_string_view(value)) {
|
|
/* The default channel flag can only be enabled. "Disabling" will be done by enabling the default flag somewhere else. */
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_DELETE_DELAY: {
|
|
converter<uint32_t>::from_string_view(value);
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_ICON_ID: {
|
|
converter<uint32_t>::from_string_view(value);
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_CONVERSATION_HISTORY_LENGTH: {
|
|
converter<int64_t>::from_string_view(value);
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_CONVERSATION_MODE: {
|
|
switch(converter<ChannelConversationMode>::from_string_view(value)) {
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE:
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_PUBLIC:
|
|
case ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE:
|
|
break;
|
|
|
|
default:
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case property::CHANNEL_SIDEBAR_MODE: {
|
|
switch (converter<ChannelSidebarMode>::from_string_view(value)) {
|
|
case ChannelSidebarMode::CHANNELSIDEBARMODE_CONVERSATION:
|
|
case ChannelSidebarMode::CHANNELSIDEBARMODE_DESCRIPTION:
|
|
case ChannelSidebarMode::CHANNELSIDEBARMODE_FILE_TRANSFER:
|
|
break;
|
|
|
|
default:
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* non editable properties */
|
|
case property::CHANNEL_FLAG_ARE_SUBSCRIBED:
|
|
case property::CHANNEL_FORCED_SILENCE:
|
|
case property::CHANNEL_UNDEFINED:
|
|
case property::CHANNEL_CODEC_LATENCY_FACTOR:
|
|
case property::CHANNEL_SECURITY_SALT:
|
|
case property::CHANNEL_FILEPATH:
|
|
case property::CHANNEL_FLAG_PRIVATE:
|
|
case property::CHANNEL_LAST_LEFT:
|
|
case property::CHANNEL_CREATED_AT:
|
|
case property::CHANNEL_CREATED_BY:
|
|
case property::CHANNEL_ENDMARKER:
|
|
break;
|
|
|
|
case property::CHANNEL_NEEDED_TALK_POWER:
|
|
converter<int>::from_string_view(value);
|
|
break;
|
|
|
|
default:
|
|
debugMessage(this->getServerId(), "{} Tried to edit an unknown channel property: {}", (int) property);
|
|
continue;
|
|
}
|
|
} catch(std::exception&) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property).name}};
|
|
}
|
|
}
|
|
|
|
auto target_channel_tree = server ? server->getChannelTree() : &*serverInstance->getChannelTree();
|
|
std::unique_lock channel_tree_lock{server ? server->channel_tree_mutex : serverInstance->getChannelTreeLock()};
|
|
|
|
struct TemporaryCreatedChannel {
|
|
ServerChannelTree* channel_tree;
|
|
std::shared_ptr<ServerChannel> channel;
|
|
|
|
~TemporaryCreatedChannel() {
|
|
if(!this->channel) { return; }
|
|
|
|
channel_tree->deleteChannelRoot(this->channel);
|
|
}
|
|
} temporary_created_channel{target_channel_tree, nullptr};
|
|
|
|
std::shared_ptr<TreeView::LinkedTreeEntry> linked_channel;
|
|
std::shared_ptr<ServerChannel> channel;
|
|
if(is_channel_create) {
|
|
if(!values.contains(property::CHANNEL_NAME)) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property::CHANNEL_NAME).name}};
|
|
}
|
|
|
|
auto parent_id = values.contains(property::CHANNEL_PID) ? converter<ChannelId>::from_string_view(values.at(property::CHANNEL_PID)) : 0;
|
|
auto order_id = values.contains(property::CHANNEL_ORDER) ? converter<ChannelId>::from_string_view(values.at(property::CHANNEL_ORDER)) : 0;
|
|
auto channel_name = values.at(property::CHANNEL_NAME);
|
|
|
|
/* checking if the channel name is unique */
|
|
{
|
|
std::shared_ptr<BasicChannel> parent_channel{};
|
|
if(parent_id > 0) {
|
|
parent_channel = target_channel_tree->findChannel(parent_id);
|
|
if(!parent_channel) {
|
|
return command_result{error::channel_invalid_id};
|
|
}
|
|
}
|
|
|
|
if(target_channel_tree->findChannel(channel_name, parent_channel)) {
|
|
return ts::command_result{error::channel_name_inuse};
|
|
}
|
|
}
|
|
|
|
channel = dynamic_pointer_cast<ServerChannel>(target_channel_tree->createChannel(parent_id, order_id, channel_name));
|
|
if(!channel) {
|
|
return command_result{error::vs_critical, "channel create failed"};
|
|
}
|
|
temporary_created_channel.channel = channel;
|
|
|
|
linked_channel = target_channel_tree->findLinkedChannel(channel->channelId());
|
|
if(!linked_channel) {
|
|
return command_result{error::vs_critical, "missing linked channel"};
|
|
}
|
|
|
|
channel_id = channel->channelId();
|
|
} else {
|
|
linked_channel = target_channel_tree->findLinkedChannel(channel_id);
|
|
channel = dynamic_pointer_cast<ServerChannel>(linked_channel->entry);
|
|
}
|
|
|
|
if(!channel || channel->deleted) {
|
|
/* channel has not been found or deleted */
|
|
return ts::command_result{error::channel_invalid_id};
|
|
}
|
|
|
|
/* Step 2: Remove all not changed properties and test the updates */
|
|
auto channel_properties = channel->properties();
|
|
std::map<property::ChannelProperties, std::string> changed_values{};
|
|
|
|
for(auto& [ key, value ] : values) {
|
|
if(channel_properties[key].value() == value) {
|
|
continue;
|
|
}
|
|
|
|
switch(key) {
|
|
case property::CHANNEL_NAME:
|
|
updating_name = true;
|
|
break;
|
|
|
|
case property::CHANNEL_NAME_PHONETIC:
|
|
/* even though this is a name update, the phonetic name must not be unique */
|
|
case property::CHANNEL_ICON_ID:
|
|
case property::CHANNEL_TOPIC:
|
|
case property::CHANNEL_DESCRIPTION:
|
|
case property::CHANNEL_CODEC:
|
|
case property::CHANNEL_CODEC_QUALITY:
|
|
case property::CHANNEL_CODEC_IS_UNENCRYPTED:
|
|
case property::CHANNEL_DELETE_DELAY:
|
|
case property::CHANNEL_SIDEBAR_MODE:
|
|
break;
|
|
|
|
case property::CHANNEL_PASSWORD:
|
|
case property::CHANNEL_FLAG_PASSWORD:
|
|
updating_password = true;
|
|
break;
|
|
|
|
|
|
case property::CHANNEL_MAXCLIENTS:
|
|
case property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED:
|
|
updating_max_clients = true;
|
|
break;
|
|
|
|
|
|
case property::CHANNEL_MAXFAMILYCLIENTS:
|
|
case property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED:
|
|
case property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED:
|
|
updating_max_family_clients = true;
|
|
break;
|
|
|
|
|
|
case property::CHANNEL_ORDER:
|
|
if(is_channel_create) {
|
|
return ts::command_result{error::vs_critical, "having channel order update but channel has been created"};
|
|
}
|
|
updating_sort_order = true;
|
|
break;
|
|
|
|
case property::CHANNEL_FLAG_PERMANENT:
|
|
case property::CHANNEL_FLAG_SEMI_PERMANENT:
|
|
updating_type = true;
|
|
break;
|
|
|
|
|
|
case property::CHANNEL_FLAG_DEFAULT:
|
|
updating_default = true;
|
|
break;
|
|
|
|
case property::CHANNEL_NEEDED_TALK_POWER:
|
|
updating_talk_power = true;
|
|
break;
|
|
|
|
case property::CHANNEL_CONVERSATION_HISTORY_LENGTH:
|
|
case property::CHANNEL_CONVERSATION_MODE:
|
|
break;
|
|
|
|
/* non updatable properties */
|
|
case property::CHANNEL_FLAG_ARE_SUBSCRIBED:
|
|
case property::CHANNEL_FORCED_SILENCE:
|
|
case property::CHANNEL_UNDEFINED:
|
|
case property::CHANNEL_ID:
|
|
case property::CHANNEL_PID:
|
|
case property::CHANNEL_CODEC_LATENCY_FACTOR:
|
|
case property::CHANNEL_SECURITY_SALT:
|
|
case property::CHANNEL_FILEPATH:
|
|
case property::CHANNEL_FLAG_PRIVATE:
|
|
case property::CHANNEL_LAST_LEFT:
|
|
case property::CHANNEL_CREATED_AT:
|
|
case property::CHANNEL_CREATED_BY:
|
|
case property::CHANNEL_ENDMARKER:
|
|
break;
|
|
|
|
default:
|
|
logCritical(this->getServerId(), "{} Channel property {} reached context validation context but we don't know how to handle it. Please report this bug!", CLIENT_LOG_PREFIX, property::describe(key).name);
|
|
continue;
|
|
}
|
|
|
|
changed_values.emplace(key, std::move(value));
|
|
}
|
|
|
|
if(changed_values.empty() && !is_channel_create) {
|
|
/* nothing to change */
|
|
return ts::command_result{error::database_no_modifications};
|
|
}
|
|
|
|
auto target_channel_property_value = [&](property::ChannelProperties property) {
|
|
return changed_values.contains(property) ? std::string{changed_values.at(property)} : channel_properties[property].value();
|
|
};
|
|
|
|
auto reset_client_limitations = [&]{
|
|
/* Updating the max clients */
|
|
if(!converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED))) {
|
|
updating_max_clients = true;
|
|
changed_values[property::CHANNEL_MAXCLIENTS] = "-1";
|
|
changed_values[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED] = "1";
|
|
}
|
|
|
|
if(!converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED))) {
|
|
updating_max_family_clients = true;
|
|
changed_values[property::CHANNEL_MAXFAMILYCLIENTS] = "-1";
|
|
changed_values[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED] = "0";
|
|
changed_values[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED] = "1";
|
|
}
|
|
};
|
|
|
|
if(updating_name) {
|
|
auto new_name = changed_values[property::CHANNEL_NAME];
|
|
if(target_channel_tree->findChannel(new_name, channel->parent())) {
|
|
return ts::command_result{error::channel_name_inuse};
|
|
}
|
|
}
|
|
|
|
if(updating_password) {
|
|
auto password_provided = changed_values.contains(property::CHANNEL_PASSWORD) && !changed_values[property::CHANNEL_PASSWORD].empty();
|
|
if(values.contains(property::CHANNEL_FLAG_PASSWORD)) {
|
|
auto has_password = converter<bool>::from_string_view(changed_values[property::CHANNEL_FLAG_PASSWORD]);
|
|
if(has_password && !password_provided) {
|
|
return command_result{error::parameter_missing, std::string{property::describe(property::CHANNEL_PASSWORD).name}};
|
|
} else if(!has_password && password_provided) {
|
|
return command_result{error::parameter_invalid, std::string{property::describe(property::CHANNEL_FLAG_PASSWORD).name}};
|
|
}
|
|
} else if(password_provided) {
|
|
/* we've a password but the remote was too lazy to set the password flag */
|
|
changed_values[property::CHANNEL_FLAG_PASSWORD] = "1";
|
|
}
|
|
}
|
|
|
|
/* We need to calculate the type for other checks as well do don't only calculate it when updating the type */
|
|
ChannelType::ChannelType target_channel_type;
|
|
|
|
(void) updating_type;
|
|
{
|
|
auto flag_permanent = converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_PERMANENT));
|
|
auto flag_semi_permanent = converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_SEMI_PERMANENT));
|
|
|
|
if(flag_permanent) {
|
|
if(flag_semi_permanent) {
|
|
/* we can't be permanent and semi permanent */
|
|
|
|
if(changed_values.contains(property::CHANNEL_FLAG_PERMANENT)) {
|
|
return command_result{error::channel_invalid_flags, std::string{property::describe(property::CHANNEL_FLAG_PERMANENT).name}};
|
|
} else {
|
|
return command_result{error::channel_invalid_flags, std::string{property::describe(property::CHANNEL_FLAG_SEMI_PERMANENT).name}};
|
|
}
|
|
}
|
|
|
|
target_channel_type = ChannelType::permanent;
|
|
} else if(flag_semi_permanent) {
|
|
target_channel_type = ChannelType::semipermanent;
|
|
} else {
|
|
target_channel_type = ChannelType::temporary;
|
|
}
|
|
}
|
|
|
|
if(updating_max_clients) {
|
|
if(changed_values.contains(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED)) {
|
|
/* The user explicitly toggled the max clients unlimited flag */
|
|
auto unlimited = converter<bool>::from_string_view(changed_values[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED]);
|
|
if(unlimited) {
|
|
/*
|
|
* Change the max clients if not already done by the user.
|
|
* We may should test if the user really set them to -1 but nvm.
|
|
*
|
|
* Since we must come from a limited channel, else we would not have a change, we can ensure that the previous value isn't -1.
|
|
* This means that we've definitively a change.
|
|
*/
|
|
changed_values[property::CHANNEL_MAXCLIENTS] = "-1";
|
|
} else if(!changed_values.contains(property::CHANNEL_MAXCLIENTS)) {
|
|
/* if the user enabled max clients it should also provide a value */
|
|
return ts::command_result{error::parameter_missing, std::string{property::describe(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED).name}};
|
|
} else {
|
|
auto value = converter<int>::from_string_view(changed_values[property::CHANNEL_MAXCLIENTS]);
|
|
if(value < 0) {
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property::CHANNEL_MAXCLIENTS).name}};
|
|
}
|
|
|
|
/* everything is fine */
|
|
}
|
|
} else if(changed_values.contains(property::CHANNEL_MAXCLIENTS)) {
|
|
/* the user was too lazy to set the flag max clients unlimited property accordingly */
|
|
auto value = converter<int>::from_string_view(changed_values[property::CHANNEL_MAXCLIENTS]);
|
|
if(value >= 0) {
|
|
changed_values[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED] = "0";
|
|
} else {
|
|
changed_values[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED] = "1";
|
|
}
|
|
} else {
|
|
assert(false);
|
|
logCritical(this->getServerId(), "updating_max_clients has been set without a changed max client channel property.");
|
|
}
|
|
}
|
|
|
|
if(updating_max_family_clients) {
|
|
auto unlimited = converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED));
|
|
auto inherited = converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
|
|
|
|
if(changed_values.contains(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED) && unlimited) {
|
|
/* The user explicitly enabled the max family clients unlimited flag */
|
|
|
|
/*
|
|
* Change the max family clients and the inherited flag if not already done by the user.
|
|
* We may should test if the user really set them to -1 but nvm.
|
|
*/
|
|
if(target_channel_property_value(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED) != "0") {
|
|
changed_values[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED] = "0";
|
|
}
|
|
if(target_channel_property_value(property::CHANNEL_MAXFAMILYCLIENTS) != "-1") {
|
|
changed_values[property::CHANNEL_MAXFAMILYCLIENTS] = "-1";
|
|
}
|
|
} else if(changed_values.contains(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED) && inherited) {
|
|
/* The user explicitly enabled the max family clients inherited flag */
|
|
|
|
/*
|
|
* Change the max family clients and the unlimized flag if not already done by the user.
|
|
* We may should test if the user really set them to -1 but nvm.
|
|
*/
|
|
if(target_channel_property_value(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED) != "0") {
|
|
changed_values[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED] = "0";
|
|
}
|
|
|
|
if(target_channel_property_value(property::CHANNEL_MAXFAMILYCLIENTS) != "-1") {
|
|
changed_values[property::CHANNEL_MAXFAMILYCLIENTS] = "-1";
|
|
}
|
|
} else if(changed_values.contains(property::CHANNEL_MAXFAMILYCLIENTS)) {
|
|
/* The user explicitly enabled max channel clients */
|
|
auto value = converter<int>::from_string_view(changed_values[property::CHANNEL_MAXFAMILYCLIENTS]);
|
|
if(value < 0) {
|
|
return ts::command_result{error::parameter_invalid, std::string{property::describe(property::CHANNEL_MAXFAMILYCLIENTS).name}};
|
|
}
|
|
|
|
/* everythign is fine */
|
|
} else {
|
|
/* If enabling a channel family client limit the user must supply the amount of max clients */
|
|
return ts::command_result{error::parameter_missing, "channel_maxfamilyclients"};
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Validating the target channel type.
|
|
* This check required that the max (family) clients have been validated and the flags have been set correctly.
|
|
* Attention: Sub channels will not be checked. If their type does not match they will be updated automatically.
|
|
*/
|
|
switch(target_channel_type) {
|
|
case ChannelType::permanent: {
|
|
auto parent = channel->parent();
|
|
if(parent && parent->channelType() != ChannelType::permanent) {
|
|
return ts::command_result{error::channel_parent_not_permanent};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ChannelType::semipermanent: {
|
|
auto parent = channel->parent();
|
|
if(parent && parent->channelType() > ChannelType::semipermanent) {
|
|
return ts::command_result{error::channel_parent_not_permanent};
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ChannelType::temporary: {
|
|
/* max (family) client should not be set */
|
|
reset_client_limitations();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Validating the default channel change.
|
|
* This check required that the channel type and max (family) clients have been validated and the flags have been set correctly.
|
|
*/
|
|
if(updating_default) {
|
|
if(target_channel_type != ChannelType::permanent) {
|
|
return command_result{error::channel_default_require_permanent};
|
|
}
|
|
|
|
/* validate tree visibility */
|
|
std::shared_ptr<BasicChannel> current_channel{channel};
|
|
while(current_channel) {
|
|
auto permission = current_channel->permissions()->permission_value_flagged(permission::i_channel_needed_view_power);
|
|
if(permission.has_value) {
|
|
return ts::command_result{error::channel_family_not_visible};
|
|
}
|
|
|
|
current_channel = current_channel->parent();
|
|
}
|
|
|
|
/*
|
|
* Note: all changes of the channel flags happen after the validation.
|
|
* This implies all changes made must ensure that the overall channel flags are valid!
|
|
*/
|
|
|
|
/* Remove the password if there is any */
|
|
if(converter<bool>::from_string_view(target_channel_property_value(property::CHANNEL_FLAG_PASSWORD))) {
|
|
updating_password = true;
|
|
changed_values[property::CHANNEL_FLAG_PASSWORD] = "0";
|
|
changed_values[property::CHANNEL_PASSWORD] = "";
|
|
}
|
|
|
|
/* Remove all client restrictions */
|
|
reset_client_limitations();
|
|
}
|
|
|
|
ChannelId previous_channel_id{0};
|
|
if(updating_sort_order) {
|
|
previous_channel_id = converter<ChannelId>::from_string_view(changed_values[property::CHANNEL_ORDER]);
|
|
auto previous_channel = target_channel_tree->findChannel(previous_channel_id);
|
|
if(!previous_channel && previous_channel_id != 0) {
|
|
return command_result{error::channel_invalid_id};
|
|
}
|
|
|
|
if(!target_channel_tree->move_channel(channel, channel->parent(), previous_channel)) {
|
|
return ts::command_result{error::vs_critical, "failed to move channel"};
|
|
}
|
|
}
|
|
|
|
std::deque<std::tuple<std::shared_ptr<BasicChannel>, std::vector<property::ChannelProperties>>> child_channel_type_updates{};
|
|
|
|
/* updating all child channels */
|
|
{
|
|
std::deque<std::shared_ptr<BasicChannel>> children_left{channel};
|
|
|
|
while (!children_left.empty()) {
|
|
auto current_channel = children_left.front();
|
|
children_left.pop_front();
|
|
|
|
for (const auto &child : target_channel_tree->channels(current_channel, 1)) {
|
|
if (child == current_channel) {
|
|
continue;
|
|
}
|
|
|
|
if (child->channelType() < target_channel_type) {
|
|
std::vector<property::ChannelProperties> channel_property_updates{};
|
|
channel_property_updates.reserve(16);
|
|
|
|
child->updateChannelType(channel_property_updates, target_channel_type);
|
|
if(target_channel_type == ChannelType::temporary) {
|
|
if(child->properties()[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED].update_value(true)) {
|
|
channel_property_updates.push_back(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED);
|
|
}
|
|
|
|
if(child->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED].update_value(false)) {
|
|
channel_property_updates.push_back(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED);
|
|
}
|
|
|
|
if(child->properties()[property::CHANNEL_MAXCLIENTS].update_value(-1)) {
|
|
channel_property_updates.push_back(property::CHANNEL_MAXCLIENTS);
|
|
}
|
|
|
|
if(child->properties()[property::CHANNEL_MAXFAMILYCLIENTS].update_value(-1)) {
|
|
channel_property_updates.push_back(property::CHANNEL_MAXFAMILYCLIENTS);
|
|
}
|
|
|
|
if(child->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED].update_value(true)) {
|
|
channel_property_updates.push_back(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED);
|
|
}
|
|
}
|
|
|
|
children_left.push_back(child);
|
|
child_channel_type_updates.push_back(std::make_tuple(child, channel_property_updates));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* reverse the order so the tree is at any state valid */
|
|
std::reverse(child_channel_type_updates.begin(), child_channel_type_updates.end());
|
|
}
|
|
|
|
std::shared_ptr<BasicChannel> old_default_channel{};
|
|
if(updating_default) {
|
|
old_default_channel = target_channel_tree->getDefaultChannel();
|
|
if(old_default_channel) {
|
|
old_default_channel->properties()[property::CHANNEL_FLAG_DEFAULT] = false;
|
|
}
|
|
}
|
|
|
|
auto self_ref = this->ref();
|
|
for(const auto& [ key, value ] : changed_values) {
|
|
if(key == property::CHANNEL_ICON_ID) {
|
|
/* we've to change the permission as well */
|
|
|
|
auto icon_id = converter<uint32_t>::from_string_view(value);
|
|
channel->permissions()->set_permission(permission::i_icon_id,
|
|
{ (permission::PermissionValue) icon_id, (permission::PermissionValue) icon_id },
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
permission::v2::PermissionUpdateType::do_nothing,
|
|
false,
|
|
false);
|
|
} else if(key == property::CHANNEL_NEEDED_TALK_POWER) {
|
|
/* we've to change the permission as well */
|
|
|
|
auto talk_power = converter<permission::PermissionValue>::from_string_view(value);
|
|
channel->permissions()->set_permission(permission::i_client_needed_talk_power,
|
|
{ talk_power, talk_power },
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
permission::v2::PermissionUpdateType::do_nothing,
|
|
false,
|
|
false);
|
|
} else if(key == property::CHANNEL_CONVERSATION_HISTORY_LENGTH) {
|
|
if(server) {
|
|
auto conversation_manager = server->conversation_manager();
|
|
if (conversation_manager) {
|
|
auto conversation = conversation_manager->get(channel->channelId());
|
|
if (conversation) {
|
|
conversation->set_history_length(converter<int64_t>::from_string_view(value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto old_value = channel_properties[key].value();
|
|
channel_properties[key] = value;
|
|
serverInstance->action_logger()->channel_logger.log_channel_edit(this->getServerId(), self_ref, channel_id, property::describe(key), old_value, value);
|
|
}
|
|
|
|
std::vector<std::shared_ptr<ConnectedClient>> clients{};
|
|
if(server) {
|
|
clients = server->getClients();
|
|
} else {
|
|
clients.push_back(this->ref());
|
|
}
|
|
|
|
std::shared_ptr<TreeView::LinkedTreeEntry> linked_parent_channel{};
|
|
std::shared_ptr<TreeView::LinkedTreeEntry> linked_previous_channel{};
|
|
if(updating_sort_order) {
|
|
auto parent = channel->parent();
|
|
|
|
linked_parent_channel = parent ? target_channel_tree->findLinkedChannel(parent->channelId()) : nullptr;
|
|
linked_previous_channel = target_channel_tree->findLinkedChannel(channel->previousChannelId());
|
|
|
|
assert(!parent || linked_parent_channel);
|
|
assert(linked_previous_channel || channel->previousChannelId() == 0);
|
|
}
|
|
|
|
std::vector<property::ChannelProperties> default_channel_property_updates{
|
|
property::CHANNEL_FLAG_DEFAULT,
|
|
};
|
|
|
|
std::vector<property::ChannelProperties> changed_properties{};
|
|
changed_properties.reserve(changed_values.size());
|
|
for(const auto& [ key, _ ] : changed_values) {
|
|
changed_properties.push_back(key);
|
|
}
|
|
|
|
for(const auto& client : clients) {
|
|
std::shared_lock disconnect_lock{client->finalDisconnectLock, std::try_to_lock};
|
|
if(!disconnect_lock.owns_lock()) {
|
|
/* client is already disconnecting */
|
|
continue;
|
|
}
|
|
|
|
if(client->state != ConnectionState::CONNECTED || client->getType() == ClientType::CLIENT_INTERNAL) {
|
|
/* these clients have no need to receive any updates */
|
|
continue;
|
|
}
|
|
|
|
std::unique_lock client_tree_lock{client->channel_tree_mutex};
|
|
for(const auto& [ child_channel, updates ] : child_channel_type_updates) {
|
|
client->notifyChannelEdited(child_channel, updates, self_ref, false);
|
|
}
|
|
|
|
if(is_channel_create) {
|
|
auto client_view_channel = client->channel_view()->add_channel(linked_channel);
|
|
if(client_view_channel) {
|
|
client->notifyChannelCreate(channel, client_view_channel->previousChannelId(), self_ref);
|
|
} else {
|
|
/* channel will not be visible for the target client */
|
|
continue;
|
|
}
|
|
} else {
|
|
if(updating_sort_order) {
|
|
auto actions = client->channel_view()->change_order(linked_channel, linked_parent_channel, linked_previous_channel);
|
|
std::deque<ChannelId> deletions{};
|
|
|
|
for (const auto &action : actions) {
|
|
switch (action.first) {
|
|
case ClientChannelView::NOTHING:
|
|
continue;
|
|
|
|
case ClientChannelView::ENTER_VIEW:
|
|
client->notifyChannelShow(action.second->channel(), action.second->previous_channel);
|
|
break;
|
|
|
|
case ClientChannelView::DELETE_VIEW:
|
|
deletions.push_back(action.second->channelId());
|
|
break;
|
|
|
|
case ClientChannelView::MOVE:
|
|
client->notifyChannelMoved(action.second->channel(), action.second->previous_channel, this->ref());
|
|
break;
|
|
|
|
case ClientChannelView::REORDER:
|
|
client->notifyChannelEdited(action.second->channel(), {property::CHANNEL_ORDER}, self_ref, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!deletions.empty()) {
|
|
/*
|
|
* This should not happen since in worst case we're just moving the channel.
|
|
* This should not have an effect on the channel visibility itself.
|
|
*/
|
|
client->notifyChannelHide(deletions, false);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
client->notifyChannelEdited(channel, changed_properties, self_ref, false);
|
|
}
|
|
|
|
if(old_default_channel) {
|
|
client->notifyChannelEdited(old_default_channel, default_channel_property_updates, self_ref, false);
|
|
}
|
|
|
|
if(updating_talk_power) {
|
|
client->task_update_channel_client_properties.enqueue();
|
|
}
|
|
}
|
|
|
|
/* Channel create was successful. Release delete struct. */
|
|
temporary_created_channel.channel = nullptr;
|
|
return command_result{error::ok};
|
|
};
|
|
|
|
command_result ConnectedClient::handleCommandChannelMove(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(25);
|
|
RESOLVE_CHANNEL_W(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
assert(channel);
|
|
if (channel->deleted)
|
|
return command_result{error::channel_is_deleted};
|
|
|
|
if (!cmd[0].has("order"))
|
|
cmd["order"] = 0;
|
|
|
|
auto l_parent = channel_tree->findLinkedChannel(cmd["cpid"]);
|
|
shared_ptr<TreeView::LinkedTreeEntry> l_order;
|
|
if (cmd[0].has("order")) {
|
|
l_order = channel_tree->findLinkedChannel(cmd["order"]);
|
|
if (!l_order && cmd["order"].as<ChannelId>() != 0) return command_result{error::channel_invalid_id};
|
|
} else {
|
|
l_order = l_parent ? l_parent->child_head : (this->server ? this->server->getChannelTree() : serverInstance->getChannelTree().get())->tree_head();
|
|
while (l_order && l_order->next)
|
|
l_order = l_order->next;
|
|
}
|
|
|
|
auto parent = l_parent ? dynamic_pointer_cast<ServerChannel>(l_parent->entry) : nullptr;
|
|
auto order = l_order ? dynamic_pointer_cast<ServerChannel>(l_order->entry) : nullptr;
|
|
|
|
if ((parent && parent->deleted) || (order && order->deleted))
|
|
return command_result{error::channel_is_deleted, "parent channel order previous channel has been deleted"};
|
|
|
|
if (channel->parent() == parent && channel->channelOrder() == (order ? order->channelId() : 0))
|
|
return command_result{error::ok};
|
|
|
|
auto old_parent_channel_id = channel->parent() ? channel->parent()->channelId() : 0;
|
|
auto old_channel_order = channel->channelOrder();
|
|
|
|
bool change_parent{channel->parent() != parent};
|
|
bool change_order{(order ? order->channelId() : 0) != channel->channelOrder()};
|
|
|
|
if (change_parent)
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_parent, 1, channel_id);
|
|
|
|
if (change_order)
|
|
ACTION_REQUIRES_PERMISSION(permission::b_channel_modify_sortorder, 1, channel_id);
|
|
|
|
{
|
|
auto min_channel_deep = this->calculate_permission(permission::i_channel_min_depth, 0, false);
|
|
auto max_channel_deep = this->calculate_permission(permission::i_channel_max_depth, 0, false);
|
|
|
|
if (min_channel_deep.has_value || max_channel_deep.has_value) {
|
|
auto channel_deep = 0;
|
|
auto local_parent = l_parent;
|
|
while (local_parent) {
|
|
channel_deep++;
|
|
local_parent = local_parent->parent.lock();
|
|
}
|
|
|
|
if (min_channel_deep.has_value && (channel_deep < min_channel_deep.value && !min_channel_deep.has_infinite_power())) return command_result{permission::i_channel_min_depth};
|
|
if (max_channel_deep.has_value && !permission::v2::permission_granted(channel_deep, max_channel_deep)) return command_result{permission::i_channel_max_depth};
|
|
}
|
|
}
|
|
{
|
|
auto name = channel_tree->findChannel(channel->name(), parent);
|
|
if (name && name != channel) return command_result{error::channel_name_inuse};
|
|
}
|
|
debugMessage(this->getServerId(), "Moving channel {} from old [{} | {}] to [{} | {}]", channel->name(), channel->channelOrder(), channel->parent() ? channel->parent()->channelId() : 0, order ? order->channelId() : 0, parent ? parent->channelId() : 0);
|
|
|
|
if (!channel_tree->move_channel(channel, parent, order)) return command_result{error::channel_invalid_order, "Cant change order id"};
|
|
|
|
deque<shared_ptr<BasicChannel>> channel_type_updates;
|
|
{
|
|
auto flag_default = channel->defaultChannel();
|
|
auto current_channel = channel;
|
|
do {
|
|
if (flag_default) {
|
|
if (current_channel->channelType() != ChannelType::permanent) {
|
|
current_channel->setChannelType(ChannelType::permanent);
|
|
channel_type_updates.push_front(current_channel);
|
|
}
|
|
} else if (current_channel->hasParent()) {
|
|
if (current_channel->channelType() < current_channel->parent()->channelType()) {
|
|
current_channel->setChannelType(current_channel->parent()->channelType());
|
|
channel_type_updates.push_front(current_channel);
|
|
}
|
|
}
|
|
} while ((current_channel = dynamic_pointer_cast<ServerChannel>(current_channel->parent())));
|
|
}
|
|
|
|
/* FIXME: Test if the new channel family isn't visible by default and if we're currently moving the default channel */
|
|
|
|
/* log all the updates */
|
|
serverInstance->action_logger()->channel_logger.log_channel_move(this->getServerId(), this->ref(), channel->channelId(),
|
|
old_parent_channel_id, channel->parent() ? channel->parent()->channelId() : 0,
|
|
old_channel_order, channel->channelOrder());
|
|
|
|
for (const auto &type_update : channel_type_updates) {
|
|
serverInstance->action_logger()->channel_logger.log_channel_edit(this->getServerId(), this->ref(), type_update->channelId(),
|
|
property::describe(property::CHANNEL_FLAG_PERMANENT),
|
|
"",
|
|
type_update->properties()[property::CHANNEL_FLAG_PERMANENT].value());
|
|
serverInstance->action_logger()->channel_logger.log_channel_edit(this->getServerId(), this->ref(), type_update->channelId(),
|
|
property::describe(property::CHANNEL_FLAG_SEMI_PERMANENT),
|
|
"",
|
|
type_update->properties()[property::CHANNEL_FLAG_SEMI_PERMANENT].value());
|
|
}
|
|
|
|
if (this->server) {
|
|
auto self_rev = this->ref();
|
|
this->server->forEachClient([&](const shared_ptr<ConnectedClient> &client) {
|
|
unique_lock channel_lock(client->channel_tree_mutex);
|
|
for (const auto &type_update : channel_type_updates) {
|
|
client->notifyChannelEdited(type_update, {property::CHANNEL_FLAG_PERMANENT, property::CHANNEL_FLAG_SEMI_PERMANENT}, self_rev, false);
|
|
}
|
|
|
|
auto actions = client->channel_tree->change_order(l_channel, l_parent, l_order);
|
|
std::deque<ChannelId> deletions;
|
|
for (const auto &action : actions) {
|
|
switch (action.first) {
|
|
case ClientChannelView::NOTHING:
|
|
continue;
|
|
case ClientChannelView::ENTER_VIEW:
|
|
client->notifyChannelShow(action.second->channel(), action.second->previous_channel);
|
|
break;
|
|
case ClientChannelView::DELETE_VIEW:
|
|
deletions.push_back(action.second->channelId());
|
|
break;
|
|
case ClientChannelView::MOVE:
|
|
client->notifyChannelMoved(action.second->channel(), action.second->previous_channel, this->ref());
|
|
break;
|
|
case ClientChannelView::REORDER:
|
|
client->notifyChannelEdited(action.second->channel(), {property::CHANNEL_ORDER}, self_rev, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!deletions.empty()) {
|
|
client->notifyChannelHide(deletions, false);
|
|
}
|
|
});
|
|
}
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelPermList(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<BasicChannel>(l_channel->entry);
|
|
assert(channel);
|
|
|
|
ACTION_REQUIRES_PERMISSION(permission::b_virtualserver_channel_permission_list, 1, channel->channelId());
|
|
|
|
if (this->getType() == ClientType::CLIENT_TEAMSPEAK && this->command_times.last_notify + this->command_times.notify_timeout < system_clock::now()) {
|
|
this->sendTSPermEditorWarning();
|
|
}
|
|
|
|
auto sids = cmd.hasParm("permsid");
|
|
|
|
Command result(this->notify_response_command("notifychannelpermlist"));
|
|
int index = 0;
|
|
result["cid"] = channel->channelId();
|
|
|
|
auto permission_mapper = serverInstance->getPermissionMapper();
|
|
auto type = this->getType();
|
|
auto permission_manager = channel->permissions();
|
|
for (const auto &permission_data : permission_manager->permissions()) {
|
|
auto &permission = std::get<1>(permission_data);
|
|
if (permission.flags.value_set) {
|
|
if (sids) {
|
|
result[index]["permsid"] = permission_mapper->permission_name(type, std::get<0>(permission_data));
|
|
} else {
|
|
result[index]["permid"] = std::get<0>(permission_data);
|
|
}
|
|
|
|
result[index]["permvalue"] = permission.values.value;
|
|
result[index]["permnegated"] = permission.flags.negate;
|
|
result[index]["permskip"] = permission.flags.skip;
|
|
index++;
|
|
}
|
|
if (permission.flags.grant_set) {
|
|
if (sids) {
|
|
result[index]["permsid"] = permission_mapper->permission_name_grant(type, std::get<0>(permission_data));
|
|
} else {
|
|
result[index]["permid"] = (uint16_t)(std::get<0>(permission_data) | PERM_ID_GRANT);
|
|
}
|
|
result[index]["permvalue"] = permission.values.grant;
|
|
result[index]["permnegated"] = 0;
|
|
result[index]["permskip"] = 0;
|
|
index++;
|
|
}
|
|
}
|
|
if (index == 0)
|
|
return command_result{error::database_empty_result};
|
|
|
|
this->sendCommand(result);
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
//
|
|
//channel_icon_id=18446744073297259750
|
|
//channel_name
|
|
//channel_topic
|
|
//Desctiption has no extra parm
|
|
command_result ConnectedClient::handleCommandChannelAddPerm(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<BasicChannel>(l_channel->entry);
|
|
assert(channel);
|
|
|
|
ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_permission_modify_power, permission::i_channel_permission_modify_power, true);
|
|
|
|
ts::command::bulk_parser::PermissionBulksParser pparser{cmd, true};
|
|
if (!pparser.validate(this->ref(), channel->channelId())) {
|
|
return pparser.build_command_result();
|
|
}
|
|
|
|
/* test if we've the default channel */
|
|
bool family_contains_default_channel{false};
|
|
if(channel->properties()[property::CHANNEL_FLAG_DEFAULT].as_or<bool>(false)) {
|
|
family_contains_default_channel = true;
|
|
} else {
|
|
for(const auto& child_channel : channel_tree->channels(channel)) {
|
|
if(child_channel->properties()[property::CHANNEL_FLAG_DEFAULT].as_or<bool>(false)) {
|
|
family_contains_default_channel = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(family_contains_default_channel) {
|
|
for (const auto &ppermission : pparser.iterate_valid_permissions()) {
|
|
if(ppermission.is_grant_permission()) {
|
|
continue;
|
|
}
|
|
|
|
if(!ppermission.has_value()) {
|
|
continue;
|
|
}
|
|
|
|
if(ppermission.permission()->type == permission::i_channel_needed_view_power) {
|
|
return ts::command_result{error::channel_default_require_visible};
|
|
}
|
|
}
|
|
}
|
|
|
|
auto permission_manager = channel->permissions();
|
|
auto updateClients = false, update_join_permissions = false, update_channel_properties = false;
|
|
auto channelId = channel->channelId();
|
|
for (const auto &ppermission : pparser.iterate_valid_permissions()) {
|
|
ppermission.apply_to(permission_manager, permission::v2::PermissionUpdateType::set_value);
|
|
ppermission.log_update(serverInstance->action_logger()->permission_logger,
|
|
this->getServerId(),
|
|
this->ref(),
|
|
log::PermissionTarget::CHANNEL,
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
channelId, channel->name(),
|
|
0, "");
|
|
|
|
updateClients |= ppermission.is_client_view_property();
|
|
update_join_permissions = ppermission.permission_type() == permission::i_channel_needed_join_power;
|
|
update_channel_properties |= channel->permission_require_property_update(ppermission.permission_type());
|
|
}
|
|
|
|
if (update_channel_properties && this->server)
|
|
this->server->update_channel_from_permissions(channel, this->ref());
|
|
|
|
if ((updateClients || update_join_permissions) && this->server) {
|
|
this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
|
|
if (updateClients && cl->currentChannel == channel) {
|
|
cl->task_update_channel_client_properties.enqueue();
|
|
}
|
|
|
|
if (update_join_permissions) {
|
|
cl->join_state_id++;
|
|
}
|
|
});
|
|
}
|
|
|
|
return pparser.build_command_result();
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelDelPerm(Command &cmd) {
|
|
CMD_RESET_IDLE;
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true)
|
|
auto channel = dynamic_pointer_cast<BasicChannel>(l_channel->entry);
|
|
assert(channel);
|
|
|
|
ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_permission_modify_power, permission::i_channel_permission_modify_power, true);
|
|
|
|
ts::command::bulk_parser::PermissionBulksParser pparser{cmd, false};
|
|
if (!pparser.validate(this->ref(), channel->channelId()))
|
|
return pparser.build_command_result();
|
|
|
|
auto permission_manager = channel->permissions();
|
|
auto updateClients = false, update_join_permissions = false, update_channel_properties = false;
|
|
auto channelId = channel->channelId();
|
|
for (const auto &ppermission : pparser.iterate_valid_permissions()) {
|
|
ppermission.apply_to(permission_manager, permission::v2::PermissionUpdateType::delete_value);
|
|
ppermission.log_update(serverInstance->action_logger()->permission_logger,
|
|
this->getServerId(),
|
|
this->ref(),
|
|
log::PermissionTarget::CHANNEL,
|
|
permission::v2::PermissionUpdateType::delete_value,
|
|
channelId, channel->name(),
|
|
0, "");
|
|
|
|
updateClients |= ppermission.is_client_view_property();
|
|
update_join_permissions = ppermission.permission_type() == permission::i_channel_needed_join_power;
|
|
update_channel_properties |= channel->permission_require_property_update(ppermission.permission_type());
|
|
}
|
|
|
|
if (update_channel_properties && this->server)
|
|
this->server->update_channel_from_permissions(channel, this->ref());
|
|
|
|
if ((updateClients || update_join_permissions) && this->server) {
|
|
this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
|
|
if (updateClients && cl->currentChannel == channel)
|
|
cl->task_update_channel_client_properties.enqueue();
|
|
if (update_join_permissions)
|
|
cl->join_state_id++;
|
|
});
|
|
}
|
|
|
|
return pparser.build_command_result();
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelClientPermList(Command &cmd) {
|
|
CMD_REQ_SERVER;
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
if (!channel) return command_result{error::vs_critical};
|
|
ACTION_REQUIRES_PERMISSION(permission::b_virtualserver_channelclient_permission_list, 1, channel_id);
|
|
|
|
if (!serverInstance->databaseHelper()->validClientDatabaseId(this->server, cmd["cldbid"])) return command_result{error::client_invalid_id};
|
|
auto mgr = serverInstance->databaseHelper()->loadClientPermissionManager(this->getServerId(), cmd["cldbid"].as<ClientDbId>());
|
|
|
|
Command res(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifychannelclientpermlist" : "");
|
|
|
|
auto permissions = mgr->channel_permissions(channel->channelId());
|
|
if (permissions.empty())
|
|
return command_result{error::database_empty_result};
|
|
|
|
int index = 0;
|
|
res[index]["cid"] = channel->channelId();
|
|
res[index]["cldbid"] = cmd["cldbid"].as<ClientDbId>();
|
|
|
|
auto sids = cmd.hasParm("permsid");
|
|
auto permission_mapper = serverInstance->getPermissionMapper();
|
|
auto type = this->getType();
|
|
|
|
for (const auto &permission_data : permissions) {
|
|
auto &permission = std::get<1>(permission_data);
|
|
if (permission.flags.value_set) {
|
|
if (sids)
|
|
res[index]["permsid"] = permission_mapper->permission_name(type, get<0>(permission_data));
|
|
else
|
|
res[index]["permid"] = get<0>(permission_data);
|
|
res[index]["permvalue"] = permission.values.value;
|
|
|
|
res[index]["permnegated"] = permission.flags.negate;
|
|
res[index]["permskip"] = permission.flags.skip;
|
|
index++;
|
|
}
|
|
|
|
|
|
if (permission.flags.grant_set) {
|
|
if (sids)
|
|
res[index]["permsid"] = permission_mapper->permission_name_grant(type, get<0>(permission_data));
|
|
else
|
|
res[index]["permid"] = (get<0>(permission_data) | PERM_ID_GRANT);
|
|
res[index]["permvalue"] = permission.values.grant;
|
|
res[index]["permnegated"] = 0;
|
|
res[index]["permskip"] = 0;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
this->sendCommand(res);
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelClientDelPerm(Command &cmd) {
|
|
CMD_REF_SERVER(server_ref);
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
if (!channel) return command_result{error::vs_critical};
|
|
|
|
auto target_client_database_id = cmd["cldbid"].as<ClientDbId>();
|
|
ClientPermissionCalculator target_client_permission_calculator{this->server, target_client_database_id, ClientType::CLIENT_TEAMSPEAK, channel_id};
|
|
ACTION_REQUIRES_PERMISSION(permission::i_client_permission_modify_power, target_client_permission_calculator.calculate_permission(permission::i_client_needed_permission_modify_power), channel_id);
|
|
|
|
auto target_permission_manager = serverInstance->databaseHelper()->loadClientPermissionManager(this->getServerId(), target_client_database_id);
|
|
|
|
ts::command::bulk_parser::PermissionBulksParser pparser{cmd, false};
|
|
if (!pparser.validate(this->ref(), channel->channelId()))
|
|
return pparser.build_command_result();
|
|
|
|
bool update_view{false};
|
|
for (const auto &ppermission : pparser.iterate_valid_permissions()) {
|
|
ppermission.apply_to_channel(target_permission_manager, permission::v2::PermissionUpdateType::delete_value, channel->channelId());
|
|
ppermission.log_update(serverInstance->action_logger()->permission_logger,
|
|
this->getServerId(),
|
|
this->ref(),
|
|
log::PermissionTarget::CLIENT_CHANNEL,
|
|
permission::v2::PermissionUpdateType::delete_value,
|
|
target_client_database_id, "",
|
|
channel->channelId(), channel->name());
|
|
update_view |= ppermission.is_client_view_property();
|
|
}
|
|
|
|
serverInstance->databaseHelper()->saveClientPermissions(this->server, target_client_database_id, target_permission_manager);
|
|
|
|
auto onlineClients = this->server->findClientsByCldbId(target_client_database_id);
|
|
if (!onlineClients.empty()) {
|
|
for (const auto &elm : onlineClients) {
|
|
elm->task_update_needed_permissions.enqueue();
|
|
|
|
if (elm->currentChannel == channel) {
|
|
elm->task_update_channel_client_properties.enqueue();
|
|
} else if (update_view) {
|
|
unique_lock client_channel_lock(this->channel_tree_mutex);
|
|
|
|
auto elm_channel = elm->currentChannel;
|
|
if (elm_channel) {
|
|
deque<ChannelId> deleted;
|
|
for (const auto &update_entry : elm->channel_tree->update_channel_path(l_channel, this->server->channelTree->findLinkedChannel(elm->currentChannel->channelId()))) {
|
|
if (update_entry.first)
|
|
elm->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
|
|
else
|
|
deleted.push_back(update_entry.second->channelId());
|
|
}
|
|
if (!deleted.empty())
|
|
elm->notifyChannelHide(deleted, false); /* we've locked the tree before */
|
|
}
|
|
}
|
|
|
|
elm->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
|
|
}
|
|
}
|
|
|
|
return pparser.build_command_result();
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelClientAddPerm(Command &cmd) {
|
|
CMD_REF_SERVER(server_ref);
|
|
CMD_RESET_IDLE;
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
|
|
RESOLVE_CHANNEL_R(cmd["cid"], true);
|
|
auto channel = dynamic_pointer_cast<ServerChannel>(l_channel->entry);
|
|
if (!channel) return command_result{error::vs_critical};
|
|
|
|
auto target_client_database_id = cmd["cldbid"].as<ClientDbId>();
|
|
ClientPermissionCalculator target_client_permission_calculator{this->server, cmd["cldbid"], ClientType::CLIENT_TEAMSPEAK, channel_id};
|
|
ACTION_REQUIRES_PERMISSION(permission::i_client_permission_modify_power, target_client_permission_calculator.calculate_permission(permission::i_client_needed_permission_modify_power), channel_id);
|
|
|
|
auto target_permissions = serverInstance->databaseHelper()->loadClientPermissionManager(this->getServerId(), target_client_database_id);
|
|
|
|
ts::command::bulk_parser::PermissionBulksParser pparser{cmd, true};
|
|
if (!pparser.validate(this->ref(), channel->channelId()))
|
|
return pparser.build_command_result();
|
|
|
|
bool update_view{false};
|
|
for (const auto &ppermission : pparser.iterate_valid_permissions()) {
|
|
ppermission.apply_to_channel(target_permissions, permission::v2::PermissionUpdateType::set_value, channel->channelId());
|
|
ppermission.log_update(serverInstance->action_logger()->permission_logger,
|
|
this->getServerId(),
|
|
this->ref(),
|
|
log::PermissionTarget::CLIENT_CHANNEL,
|
|
permission::v2::PermissionUpdateType::set_value,
|
|
target_client_database_id, "",
|
|
channel->channelId(), channel->name());
|
|
update_view |= ppermission.is_client_view_property();
|
|
}
|
|
|
|
serverInstance->databaseHelper()->saveClientPermissions(this->server, target_client_database_id, target_permissions);
|
|
|
|
|
|
auto onlineClients = this->server->findClientsByCldbId(target_client_database_id);
|
|
if (!onlineClients.empty())
|
|
for (const auto &elm : onlineClients) {
|
|
elm->task_update_needed_permissions.enqueue();
|
|
|
|
if (elm->currentChannel == channel) {
|
|
elm->task_update_channel_client_properties.enqueue();
|
|
} else if (update_view) {
|
|
unique_lock client_channel_lock(this->channel_tree_mutex);
|
|
|
|
auto elm_channel = elm->currentChannel;
|
|
if (elm_channel) {
|
|
deque<ChannelId> deleted;
|
|
for (const auto &update_entry : elm->channel_tree->update_channel_path(l_channel, this->server->channelTree->findLinkedChannel(elm->currentChannel->channelId()))) {
|
|
if (update_entry.first)
|
|
elm->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
|
|
else
|
|
deleted.push_back(update_entry.second->channelId());
|
|
}
|
|
if (!deleted.empty())
|
|
elm->notifyChannelHide(deleted, false); /* we've locked the tree before */
|
|
}
|
|
}
|
|
elm->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
|
|
}
|
|
|
|
return pparser.build_command_result();
|
|
}
|
|
|
|
|
|
command_result ConnectedClient::handleCommandChannelFind(Command &cmd) {
|
|
CMD_CHK_AND_INC_FLOOD_POINTS(5);
|
|
|
|
string pattern = cmd["pattern"];
|
|
std::transform(pattern.begin(), pattern.end(), pattern.begin(), ::tolower);
|
|
|
|
Command res("");
|
|
int index = 0;
|
|
for (const auto &cl : (this->server ? this->server->channelTree : serverInstance->getChannelTree().get())->channels()) {
|
|
string name = cl->name();
|
|
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
|
|
if (name.find(pattern) != std::string::npos) {
|
|
res[index]["cid"] = cl->channelId();
|
|
res[index]["channel_name"] = cl->name();
|
|
index++;
|
|
}
|
|
}
|
|
if (index == 0) return command_result{error::database_empty_result};
|
|
this->sendCommand(res);
|
|
|
|
return command_result{error::ok};
|
|
}
|
|
|
|
command_result ConnectedClient::handleCommandChannelInfo(Command &cmd) {
|
|
std::shared_ptr<BasicChannel> channel = (this->server ? this->server->channelTree : serverInstance->getChannelTree().get())->findChannel(cmd["cid"].as<ChannelId>());
|
|
if (!channel) return command_result{error::channel_invalid_id, "Cant resolve channel"};
|
|
|
|
Command res("");
|
|
|
|
for (const auto &prop : channel->properties()->list_properties(property::FLAG_CHANNEL_VIEW | property::FLAG_CHANNEL_VARIABLE, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0))
|
|
res[prop.type().name] = prop.value();
|
|
|
|
res["seconds_empty"] = channel->empty_seconds();
|
|
res["pid"] = res["cpid"].string();
|
|
this->sendCommand(res);
|
|
|
|
return command_result{error::ok};
|
|
}
|