void PrivilegeDb::GetPrivilegesMappings(const std::string &version_from,
const std::string &version_to,
const std::vector<std::string> &privileges,
std::vector<std::string> &mappings)
{
try_catch<void>([&] {
auto deleteCmd = getStatement(StmtType::EDeletePrivilegesToMap);
deleteCmd->Step();
auto insertCmd = getStatement(StmtType::EInsertPrivilegeToMap);
for (auto &privilege : privileges) {
if (privilege.empty())
continue;
insertCmd->BindString(1, privilege);
insertCmd->Step();
insertCmd->Reset();
}
insertCmd->BindNull(1);
insertCmd->Step();
auto queryCmd = getStatement(StmtType::EGetPrivilegesMappings);
queryCmd->BindString(1, version_from);
queryCmd->BindString(2, version_to);
mappings.clear();
while (queryCmd->Step()) {
std::string mapping = queryCmd->GetColumnString(0);
LogDebug("Privilege set in version " << version_from
<<" has mapping " << mapping << " in version " << version_to);
mappings.push_back(mapping);
}
});
}
/*
===============
UnbindAll
===============
*/
void idImageManager::UnbindAll() {
int oldTMU = backEnd.glState.currenttmu;
for ( int i = 0; i < MAX_PROG_TEXTURE_PARMS; ++i ) {
backEnd.glState.currenttmu = i;
BindNull();
}
backEnd.glState.currenttmu = oldTMU;
}
bool CQueueStorage::Impl::SaveFile(wxLongLong server, const CFileItem& file)
{
if (file.m_edit != CEditHandler::none)
return true;
Bind(insertFileQuery_, file_table_column_names::source_file, file.GetSourceFile());
auto const& targetFile = file.GetTargetFile();
if (targetFile)
Bind(insertFileQuery_, file_table_column_names::target_file, *targetFile);
else
BindNull(insertFileQuery_, file_table_column_names::target_file);
int64_t localPathId = SaveLocalPath(file.GetLocalPath());
int64_t remotePathId = SaveRemotePath(file.GetRemotePath());
if (localPathId == -1 || remotePathId == -1)
return false;
Bind(insertFileQuery_, file_table_column_names::local_path, localPathId);
Bind(insertFileQuery_, file_table_column_names::remote_path, remotePathId);
Bind(insertFileQuery_, file_table_column_names::download, file.Download() ? 1 : 0);
if (file.GetSize() != -1)
Bind(insertFileQuery_, file_table_column_names::size, file.GetSize());
else
BindNull(insertFileQuery_, file_table_column_names::size);
if (file.m_errorCount)
Bind(insertFileQuery_, file_table_column_names::error_count, file.m_errorCount);
else
BindNull(insertFileQuery_, file_table_column_names::error_count);
Bind(insertFileQuery_, file_table_column_names::priority, static_cast<int>(file.GetPriority()));
Bind(insertFileQuery_, file_table_column_names::ascii_file, file.Ascii() ? 1 : 0);
if (file.m_defaultFileExistsAction != CFileExistsNotification::unknown)
Bind(insertFileQuery_, file_table_column_names::default_exists_action, file.m_defaultFileExistsAction);
else
BindNull(insertFileQuery_, file_table_column_names::default_exists_action);
int res;
do {
res = sqlite3_step(insertFileQuery_);
} while (res == SQLITE_BUSY);
sqlite3_reset(insertFileQuery_);
return res == SQLITE_DONE;
}
void SqlConnection::DataCommand::BindString(
SqlConnection::ArgumentIndex position,
const Optional<String> &value)
{
if (!!value)
BindString(position, ToUTF8String(*value).c_str());
else
BindNull(position);
}
void SqlConnection::DataCommand::BindDouble(
SqlConnection::ArgumentIndex position,
const Optional<double> &value)
{
if (value.IsNull())
BindNull(position);
else
BindDouble(position, *value);
}
void SqlConnection::DataCommand::BindInt64(
SqlConnection::ArgumentIndex position,
const Optional<int64_t> &value)
{
if (value.IsNull())
BindNull(position);
else
BindInt64(position, *value);
}
void SqlConnection::DataCommand::BindString(
SqlConnection::ArgumentIndex position,
const char *value)
{
if (!value)
{
BindNull(position);
return;
}
// Assume that text may disappear
CheckBindResult(sqlite3_bind_text(m_stmt, position,
value, strlen(value),
SQLITE_TRANSIENT));
LogPedantic("SQL data command bind string: ["
<< position << "] -> " << value);
}
void Framebuffer::Init()
{
cmdSystem->AddCommand( "listFramebuffers", R_ListFramebuffers_f, CMD_FL_RENDERER, "lists framebuffers" );
backEnd.glState.currentFramebuffer = NULL;
int width, height;
width = height = r_shadowMapImageSize.GetInteger();
for( int i = 0; i < MAX_SHADOWMAP_RESOLUTIONS; i++ )
{
width = height = shadowMapResolutions[i];
globalFramebuffers.shadowFBO[i] = new Framebuffer( "_shadowMap" , width, height );
globalFramebuffers.shadowFBO[i]->Bind();
glDrawBuffers( 0, NULL );
}
// globalFramebuffers.shadowFBO->AddColorBuffer( GL_RGBA8, 0 );
// globalFramebuffers.shadowFBO->AddDepthBuffer( GL_DEPTH_COMPONENT24 );
// globalFramebuffers.shadowFBO->Check();
BindNull();
}
bool CQueueStorage::Impl::SaveDirectory(wxLongLong server, const CFolderItem& directory)
{
if (directory.Download())
BindNull(insertFileQuery_, file_table_column_names::source_file);
else
Bind(insertFileQuery_, file_table_column_names::source_file, directory.GetSourceFile());
BindNull(insertFileQuery_, file_table_column_names::target_file);
int64_t localPathId = directory.Download() ? SaveLocalPath(directory.GetLocalPath()) : -1;
int64_t remotePathId = directory.Download() ? -1 : SaveRemotePath(directory.GetRemotePath());
if (localPathId == -1 && remotePathId == -1)
return false;
Bind(insertFileQuery_, file_table_column_names::local_path, localPathId);
Bind(insertFileQuery_, file_table_column_names::remote_path, remotePathId);
Bind(insertFileQuery_, file_table_column_names::download, directory.Download() ? 1 : 0);
BindNull(insertFileQuery_, file_table_column_names::size);
if (directory.m_errorCount)
Bind(insertFileQuery_, file_table_column_names::error_count, directory.m_errorCount);
else
BindNull(insertFileQuery_, file_table_column_names::error_count);
Bind(insertFileQuery_, file_table_column_names::priority, static_cast<int>(directory.GetPriority()));
BindNull(insertFileQuery_, file_table_column_names::ascii_file);
BindNull(insertFileQuery_, file_table_column_names::default_exists_action);
int res;
do {
res = sqlite3_step(insertFileQuery_);
} while (res == SQLITE_BUSY);
sqlite3_reset(insertFileQuery_);
return res == SQLITE_DONE;
}
bool CQueueStorage::Impl::SaveServer(const CServerItem& item)
{
bool kiosk_mode = COptions::Get()->GetOptionVal(OPTION_DEFAULT_KIOSKMODE) != 0;
const CServer& server = item.GetServer();
Bind(insertServerQuery_, server_table_column_names::host, server.GetHost());
Bind(insertServerQuery_, server_table_column_names::port, static_cast<int>(server.GetPort()));
Bind(insertServerQuery_, server_table_column_names::protocol, static_cast<int>(server.GetProtocol()));
Bind(insertServerQuery_, server_table_column_names::type, static_cast<int>(server.GetType()));
enum LogonType logonType = server.GetLogonType();
if (server.GetLogonType() != ANONYMOUS) {
Bind(insertServerQuery_, server_table_column_names::user, server.GetUser());
if (server.GetLogonType() == NORMAL || server.GetLogonType() == ACCOUNT) {
if (kiosk_mode) {
logonType = ASK;
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
else {
Bind(insertServerQuery_, server_table_column_names::password, server.GetPass());
if (server.GetLogonType() == ACCOUNT)
Bind(insertServerQuery_, server_table_column_names::account, server.GetAccount());
else
BindNull(insertServerQuery_, server_table_column_names::account);
}
}
else {
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
}
else {
BindNull(insertServerQuery_, server_table_column_names::user);
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
Bind(insertServerQuery_, server_table_column_names::logontype, static_cast<int>(logonType));
Bind(insertServerQuery_, server_table_column_names::timezone_offset, server.GetTimezoneOffset());
switch (server.GetPasvMode())
{
case MODE_PASSIVE:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("passive"));
break;
case MODE_ACTIVE:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("active"));
break;
default:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("default"));
break;
}
Bind(insertServerQuery_, server_table_column_names::max_connections, server.MaximumMultipleConnections());
switch (server.GetEncodingType())
{
default:
case ENCODING_AUTO:
Bind(insertServerQuery_, server_table_column_names::encoding, _T("Auto"));
break;
case ENCODING_UTF8:
Bind(insertServerQuery_, server_table_column_names::encoding, _T("UTF-8"));
break;
case ENCODING_CUSTOM:
Bind(insertServerQuery_, server_table_column_names::encoding, server.GetCustomEncoding());
break;
}
if (CServer::SupportsPostLoginCommands(server.GetProtocol())) {
const std::vector<wxString>& postLoginCommands = server.GetPostLoginCommands();
if (!postLoginCommands.empty()) {
wxString commands;
for (std::vector<wxString>::const_iterator iter = postLoginCommands.begin(); iter != postLoginCommands.end(); ++iter) {
if (!commands.empty())
commands += _T("\n");
commands += *iter;
}
Bind(insertServerQuery_, server_table_column_names::post_login_commands, commands);
}
else
BindNull(insertServerQuery_, server_table_column_names::post_login_commands);
}
else
BindNull(insertServerQuery_, server_table_column_names::post_login_commands);
Bind(insertServerQuery_, server_table_column_names::bypass_proxy, server.GetBypassProxy() ? 1 : 0);
if (!server.GetName().empty())
Bind(insertServerQuery_, server_table_column_names::name, server.GetName());
else
BindNull(insertServerQuery_, server_table_column_names::name);
int res;
do {
res = sqlite3_step(insertServerQuery_);
} while (res == SQLITE_BUSY);
sqlite3_reset(insertServerQuery_);
bool ret = res == SQLITE_DONE;
if (ret) {
sqlite3_int64 serverId = sqlite3_last_insert_rowid(db_);
Bind(insertFileQuery_, file_table_column_names::server, static_cast<int64_t>(serverId));
const std::vector<CQueueItem*>& children = item.GetChildren();
for (std::vector<CQueueItem*>::const_iterator it = children.begin() + item.GetRemovedAtFront(); it != children.end(); ++it) {
CQueueItem & childItem = **it;
if (childItem.GetType() == QueueItemType::File)
ret &= SaveFile(serverId, static_cast<CFileItem&>(childItem));
else if (childItem.GetType() == QueueItemType::Folder)
ret &= SaveDirectory(serverId, static_cast<CFolderItem&>(childItem));
}
}
return ret;
}
