mirror of
https://github.com/kasmtech/KasmVNC.git
synced 2024-11-07 16:54:13 +01:00
507 lines
12 KiB
C++
507 lines
12 KiB
C++
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
|
|
* Copyright 2004-2005 Cendio AB.
|
|
* Copyright 2017 Peter Astrand <astrand@cendio.se> for Cendio AB
|
|
*
|
|
* This is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This software is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
// -=- Configuration.cxx
|
|
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <strings.h>
|
|
|
|
#include <os/Mutex.h>
|
|
|
|
#include <rfb/util.h>
|
|
#include <rfb/Configuration.h>
|
|
#include <rfb/LogWriter.h>
|
|
#include <rfb/Exception.h>
|
|
|
|
#define LOCK_CONFIG os::AutoMutex a(mutex)
|
|
|
|
#include <rdr/HexOutStream.h>
|
|
#include <rdr/HexInStream.h>
|
|
|
|
using namespace rfb;
|
|
|
|
static LogWriter vlog("Config");
|
|
|
|
|
|
// -=- The Global/server/viewer Configuration objects
|
|
Configuration* Configuration::global_ = 0;
|
|
Configuration* Configuration::server_ = 0;
|
|
Configuration* Configuration::viewer_ = 0;
|
|
|
|
Configuration* Configuration::global() {
|
|
if (!global_)
|
|
global_ = new Configuration("Global");
|
|
return global_;
|
|
}
|
|
|
|
Configuration* Configuration::server() {
|
|
if (!server_)
|
|
server_ = new Configuration("Server");
|
|
return server_;
|
|
}
|
|
|
|
Configuration* Configuration::viewer() {
|
|
if (!viewer_)
|
|
viewer_ = new Configuration("Viewer");
|
|
return viewer_;
|
|
}
|
|
|
|
// -=- Configuration implementation
|
|
|
|
bool Configuration::set(const char* n, const char* v, bool immutable) {
|
|
return set(n, strlen(n), v, immutable);
|
|
}
|
|
|
|
bool Configuration::set(const char* name, int len,
|
|
const char* val, bool immutable)
|
|
{
|
|
VoidParameter* current = head;
|
|
while (current) {
|
|
if ((int)strlen(current->getName()) == len &&
|
|
strncasecmp(current->getName(), name, len) == 0)
|
|
{
|
|
bool b = current->setParam(val);
|
|
if (b && immutable)
|
|
current->setImmutable();
|
|
return b;
|
|
}
|
|
current = current->_next;
|
|
}
|
|
return _next ? _next->set(name, len, val, immutable) : false;
|
|
}
|
|
|
|
bool Configuration::set(const char* config, bool immutable) {
|
|
bool hyphen = false;
|
|
if (config[0] == '-') {
|
|
hyphen = true;
|
|
config++;
|
|
if (config[0] == '-') config++; // allow gnu-style --<option>
|
|
}
|
|
const char* equal = strchr(config, '=');
|
|
if (equal) {
|
|
return set(config, equal-config, equal+1, immutable);
|
|
} else if (hyphen) {
|
|
VoidParameter* current = head;
|
|
while (current) {
|
|
if (strcasecmp(current->getName(), config) == 0) {
|
|
bool b = current->setParam();
|
|
if (b && immutable)
|
|
current->setImmutable();
|
|
return b;
|
|
}
|
|
current = current->_next;
|
|
}
|
|
}
|
|
return _next ? _next->set(config, immutable) : false;
|
|
}
|
|
|
|
VoidParameter* Configuration::get(const char* param)
|
|
{
|
|
VoidParameter* current = head;
|
|
while (current) {
|
|
if (strcasecmp(current->getName(), param) == 0)
|
|
return current;
|
|
current = current->_next;
|
|
}
|
|
return _next ? _next->get(param) : 0;
|
|
}
|
|
|
|
void Configuration::list(int width, int nameWidth) {
|
|
VoidParameter* current = head;
|
|
|
|
fprintf(stderr, "%s Parameters:\n", name.buf);
|
|
while (current) {
|
|
char* def_str = current->getDefaultStr();
|
|
const char* desc = current->getDescription();
|
|
fprintf(stderr," %-*s -", nameWidth, current->getName());
|
|
int column = strlen(current->getName());
|
|
if (column < nameWidth) column = nameWidth;
|
|
column += 4;
|
|
while (true) {
|
|
const char* s = strchr(desc, ' ');
|
|
int wordLen;
|
|
if (s) wordLen = s-desc;
|
|
else wordLen = strlen(desc);
|
|
|
|
if (column + wordLen + 1 > width) {
|
|
fprintf(stderr,"\n%*s",nameWidth+4,"");
|
|
column = nameWidth+4;
|
|
}
|
|
fprintf(stderr," %.*s",wordLen,desc);
|
|
column += wordLen + 1;
|
|
desc += wordLen + 1;
|
|
if (!s) break;
|
|
}
|
|
|
|
if (def_str) {
|
|
if (column + (int)strlen(def_str) + 11 > width)
|
|
fprintf(stderr,"\n%*s",nameWidth+4,"");
|
|
fprintf(stderr," (default=%s)\n",def_str);
|
|
strFree(def_str);
|
|
} else {
|
|
fprintf(stderr,"\n");
|
|
}
|
|
current = current->_next;
|
|
}
|
|
|
|
if (_next)
|
|
_next->list(width, nameWidth);
|
|
}
|
|
|
|
|
|
bool Configuration::remove(const char* param) {
|
|
VoidParameter *current = head;
|
|
VoidParameter **prevnext = &head;
|
|
|
|
while (current) {
|
|
if (strcasecmp(current->getName(), param) == 0) {
|
|
*prevnext = current->_next;
|
|
return true;
|
|
}
|
|
prevnext = ¤t->_next;
|
|
current = current->_next;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// -=- VoidParameter
|
|
|
|
VoidParameter::VoidParameter(const char* name_, const char* desc_,
|
|
ConfigurationObject co)
|
|
: immutable(false), name(name_), description(desc_)
|
|
{
|
|
Configuration *conf = NULL;
|
|
|
|
switch (co) {
|
|
case ConfGlobal: conf = Configuration::global();
|
|
break;
|
|
case ConfServer: conf = Configuration::server();
|
|
break;
|
|
case ConfViewer: conf = Configuration::viewer();
|
|
break;
|
|
}
|
|
|
|
_next = conf->head;
|
|
conf->head = this;
|
|
|
|
mutex = new os::Mutex();
|
|
}
|
|
|
|
VoidParameter::~VoidParameter() {
|
|
delete mutex;
|
|
}
|
|
|
|
const char*
|
|
VoidParameter::getName() const {
|
|
return name;
|
|
}
|
|
|
|
const char*
|
|
VoidParameter::getDescription() const {
|
|
return description;
|
|
}
|
|
|
|
bool VoidParameter::setParam() {
|
|
return false;
|
|
}
|
|
|
|
bool VoidParameter::isBool() const {
|
|
return false;
|
|
}
|
|
|
|
void
|
|
VoidParameter::setImmutable() {
|
|
vlog.debug("set immutable %s", getName());
|
|
immutable = true;
|
|
}
|
|
|
|
// -=- AliasParameter
|
|
|
|
AliasParameter::AliasParameter(const char* name_, const char* desc_,
|
|
VoidParameter* param_, ConfigurationObject co)
|
|
: VoidParameter(name_, desc_, co), param(param_) {
|
|
}
|
|
|
|
bool
|
|
AliasParameter::setParam(const char* v) {
|
|
return param->setParam(v);
|
|
}
|
|
|
|
bool AliasParameter::setParam() {
|
|
return param->setParam();
|
|
}
|
|
|
|
char*
|
|
AliasParameter::getDefaultStr() const {
|
|
return 0;
|
|
}
|
|
|
|
char* AliasParameter::getValueStr() const {
|
|
return param->getValueStr();
|
|
}
|
|
|
|
bool AliasParameter::isBool() const {
|
|
return param->isBool();
|
|
}
|
|
|
|
void
|
|
AliasParameter::setImmutable() {
|
|
vlog.debug("set immutable %s (Alias)", getName());
|
|
param->setImmutable();
|
|
}
|
|
|
|
|
|
// -=- BoolParameter
|
|
|
|
BoolParameter::BoolParameter(const char* name_, const char* desc_, bool v,
|
|
ConfigurationObject co)
|
|
: VoidParameter(name_, desc_, co), value(v), def_value(v) {
|
|
}
|
|
|
|
bool
|
|
BoolParameter::setParam(const char* v) {
|
|
if (immutable) return true;
|
|
|
|
if (*v == 0 || strcasecmp(v, "1") == 0 || strcasecmp(v, "on") == 0
|
|
|| strcasecmp(v, "true") == 0 || strcasecmp(v, "yes") == 0)
|
|
value = 1;
|
|
else if (strcasecmp(v, "0") == 0 || strcasecmp(v, "off") == 0
|
|
|| strcasecmp(v, "false") == 0 || strcasecmp(v, "no") == 0)
|
|
value = 0;
|
|
else {
|
|
vlog.error("Bool parameter %s: invalid value '%s'", getName(), v);
|
|
return false;
|
|
}
|
|
|
|
vlog.debug("set %s(Bool) to %s(%d)", getName(), v, value);
|
|
return true;
|
|
}
|
|
|
|
bool BoolParameter::setParam() {
|
|
setParam(true);
|
|
return true;
|
|
}
|
|
|
|
void BoolParameter::setParam(bool b) {
|
|
if (immutable) return;
|
|
value = b;
|
|
vlog.debug("set %s(Bool) to %d", getName(), value);
|
|
}
|
|
|
|
char*
|
|
BoolParameter::getDefaultStr() const {
|
|
return strDup(def_value ? "1" : "0");
|
|
}
|
|
|
|
char* BoolParameter::getValueStr() const {
|
|
return strDup(value ? "1" : "0");
|
|
}
|
|
|
|
bool BoolParameter::isBool() const {
|
|
return true;
|
|
}
|
|
|
|
BoolParameter::operator bool() const {
|
|
return value;
|
|
}
|
|
|
|
// -=- PresetParameter
|
|
|
|
PresetParameter::PresetParameter(const char* name_, const char* desc_, bool v,
|
|
void (*onSet)(void),
|
|
ConfigurationObject co)
|
|
: BoolParameter(name_, desc_, v, co), onSetCB(onSet) {
|
|
}
|
|
|
|
bool PresetParameter::setParam(const char* value_) {
|
|
const bool ret = BoolParameter::setParam(value_);
|
|
|
|
if (ret && onSetCB && value)
|
|
onSetCB();
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool PresetParameter::setParam() {
|
|
const bool ret = BoolParameter::setParam();
|
|
|
|
if (ret && onSetCB && value)
|
|
onSetCB();
|
|
|
|
return ret;
|
|
}
|
|
|
|
void PresetParameter::setParam(bool b) {
|
|
BoolParameter::setParam(b);
|
|
|
|
if (onSetCB && value)
|
|
onSetCB();
|
|
}
|
|
|
|
// -=- IntParameter
|
|
|
|
IntParameter::IntParameter(const char* name_, const char* desc_, int v,
|
|
int minValue_, int maxValue_, ConfigurationObject co)
|
|
: VoidParameter(name_, desc_, co), value(v), def_value(v),
|
|
minValue(minValue_), maxValue(maxValue_)
|
|
{
|
|
}
|
|
|
|
bool
|
|
IntParameter::setParam(const char* v) {
|
|
if (immutable) return true;
|
|
vlog.debug("set %s(Int) to %s", getName(), v);
|
|
int i = strtol(v, NULL, 0);
|
|
if (i < minValue || i > maxValue)
|
|
return false;
|
|
value = i;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
IntParameter::setParam(int v) {
|
|
if (immutable) return true;
|
|
vlog.debug("set %s(Int) to %d", getName(), v);
|
|
if (v < minValue || v > maxValue)
|
|
return false;
|
|
value = v;
|
|
return true;
|
|
}
|
|
|
|
char*
|
|
IntParameter::getDefaultStr() const {
|
|
char* result = new char[16];
|
|
sprintf(result, "%d", def_value);
|
|
return result;
|
|
}
|
|
|
|
char* IntParameter::getValueStr() const {
|
|
char* result = new char[16];
|
|
sprintf(result, "%d", value);
|
|
return result;
|
|
}
|
|
|
|
IntParameter::operator int() const {
|
|
return value;
|
|
}
|
|
|
|
// -=- StringParameter
|
|
|
|
StringParameter::StringParameter(const char* name_, const char* desc_,
|
|
const char* v, ConfigurationObject co)
|
|
: VoidParameter(name_, desc_, co), value(strDup(v)), def_value(v)
|
|
{
|
|
if (!v) {
|
|
fprintf(stderr,"Default value <null> for %s not allowed\n",name_);
|
|
throw rfb::Exception("Default value <null> not allowed");
|
|
}
|
|
}
|
|
|
|
StringParameter::~StringParameter() {
|
|
strFree(value);
|
|
}
|
|
|
|
void StringParameter::setDefaultStr(const char* v) {
|
|
def_value = v;
|
|
strFree(value);
|
|
value = strDup(v);
|
|
}
|
|
|
|
bool StringParameter::setParam(const char* v) {
|
|
LOCK_CONFIG;
|
|
if (immutable) return true;
|
|
if (!v)
|
|
throw rfb::Exception("setParam(<null>) not allowed");
|
|
vlog.debug("set %s(String) to %s", getName(), v);
|
|
CharArray oldValue(value);
|
|
value = strDup(v);
|
|
return value != 0;
|
|
}
|
|
|
|
char* StringParameter::getDefaultStr() const {
|
|
return strDup(def_value);
|
|
}
|
|
|
|
char* StringParameter::getValueStr() const {
|
|
LOCK_CONFIG;
|
|
return strDup(value);
|
|
}
|
|
|
|
StringParameter::operator const char *() const {
|
|
return value;
|
|
}
|
|
|
|
// -=- BinaryParameter
|
|
|
|
BinaryParameter::BinaryParameter(const char* name_, const char* desc_,
|
|
const void* v, size_t l, ConfigurationObject co)
|
|
: VoidParameter(name_, desc_, co), value(0), length(0), def_value((char*)v), def_length(l) {
|
|
if (l) {
|
|
value = new char[l];
|
|
length = l;
|
|
memcpy(value, v, l);
|
|
}
|
|
}
|
|
BinaryParameter::~BinaryParameter() {
|
|
if (value)
|
|
delete [] value;
|
|
}
|
|
|
|
bool BinaryParameter::setParam(const char* v) {
|
|
LOCK_CONFIG;
|
|
if (immutable) return true;
|
|
vlog.debug("set %s(Binary) to %s", getName(), v);
|
|
return rdr::HexInStream::hexStrToBin(v, &value, &length);
|
|
}
|
|
|
|
void BinaryParameter::setParam(const void* v, size_t len) {
|
|
LOCK_CONFIG;
|
|
if (immutable) return;
|
|
vlog.debug("set %s(Binary)", getName());
|
|
delete [] value; value = 0;
|
|
if (len) {
|
|
value = new char[len];
|
|
length = len;
|
|
memcpy(value, v, len);
|
|
}
|
|
}
|
|
|
|
char* BinaryParameter::getDefaultStr() const {
|
|
return rdr::HexOutStream::binToHexStr(def_value, def_length);
|
|
}
|
|
|
|
char* BinaryParameter::getValueStr() const {
|
|
LOCK_CONFIG;
|
|
return rdr::HexOutStream::binToHexStr(value, length);
|
|
}
|
|
|
|
void BinaryParameter::getData(void** data_, size_t* length_) const {
|
|
LOCK_CONFIG;
|
|
if (length_) *length_ = length;
|
|
if (data_) {
|
|
*data_ = new char[length];
|
|
memcpy(*data_, value, length);
|
|
}
|
|
}
|