ConfigMgr::ConfigMgr(void) {
// 读取配置文件
CString& config = GetConfigFile();
if (!config.IsEmpty()) {
// 如果配置文件不存在，创建默认的配置文件
if (0 != _taccess(config, 0)) {
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("配置文件不存存在，创建默认配置文件"));
static char s_default_config[] =
"[system]\r\n"
"access_key_id=\r\n"
"secret_access_key=\r\n"
"host=http://lss.bj.baidubce.com\r\n";
CFile file;
TRY {
if (!file.Open(config, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite)) {
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("创建默认配置文件失败"));
} else {
file.Write(s_default_config, sizeof(s_default_config));
file.Close();
}
}
CATCH_ALL(e) {
DELETE_EXCEPTION(e);
CLogMgr::Instance().AppendLog(LC_LOG_ERROR, _T("创建默认配置文件异常"));
}
END_CATCH_ALL
}
} else {
TInt CSecMgrStore::ReadCounter(TExecutableID& aExecID)
{
HBufC *configFile = HBufC::NewLC(KMaxName);
TPtr ptr(configFile->Des());
TInt ret(GetConfigFile (ptr));
if ( KErrNone==ret)
{
if ( !BaflUtils::FileExists(iFsSession,*configFile))
{
aExecID = (TExecutableID)KCRUIdSecMgr.iUid;
BaflUtils::EnsurePathExistsL (iFsSession, *configFile);
CleanupStack::PopAndDestroy (configFile);
return WriteCounter (aExecID);
}
CFileStore* store = CPermanentFileStore::OpenLC (iFsSession,
*configFile, EFileRead);
RStoreReadStream instream;
instream.OpenLC (*store, store->Root ());
aExecID = instream.ReadInt32L ();
CleanupStack::PopAndDestroy (&instream);
CleanupStack::PopAndDestroy (store);
}
CleanupStack::PopAndDestroy (configFile);
return ret;
}
void SigUIFrame::m_run_freshclamOnButtonClick( wxCommandEvent& WXUNUSED(event) )
{
MyProcessOutput *output = new MyProcessOutput(this);
wxProcess *process = new MyProcess(output);
process->Redirect();
wxString cmd;
cmd << "\"" << GetExecPath() << "freshclam.exe\" -v --config-file=\""
<< GetConfigFile() << "\" --datadir=\"" << GetExecPath() << "\"";
//wxMessageBox(cmd);
long pid = wxExecute(cmd, wxEXEC_ASYNC, process);
if (!pid) {
wxLogError(_("Failed to launch freshclam"));
delete process;
return;
}
process->SetPid(pid);
process->CloseOutput();
wxInputStream *in = process->GetInputStream();
if (!in)
{
wxLogError(_("Failed to connect to child process output"));
return;
}
output->SetProcess(process);
output->ShowModal();
reload();
}
bool UOnlineHotfixManager::HotfixPakIniFile(const FString& FileName)
{
FConfigFile* ConfigFile = GetConfigFile(FileName);
ConfigFile->Combine(FileName);
UE_LOG(LogHotfixManager, Log, TEXT("Hotfix merged INI (%s) found in a PAK file"), *FileName);
FName IniFileName(*FileName, FNAME_Find);
int32 NumObjectsReloaded = 0;
const double StartTime = FPlatformTime::Seconds();
// Now that we have a list of classes to update, we can iterate objects and
// reload if they match the INI file that was changed
for (FObjectIterator It; It; ++It)
{
UClass* Class = It->GetClass();
if (Class->HasAnyClassFlags(CLASS_Config) &&
Class->ClassConfigName == IniFileName)
{
// Force a reload of the config vars
It->ReloadConfig();
NumObjectsReloaded++;
}
}
UE_LOG(LogHotfixManager, Log, TEXT("Updating config from %s took %f seconds reloading %d objects"),
*FileName, FPlatformTime::Seconds() - StartTime, NumObjectsReloaded);
return true;
}
void ArgsManager::ReadConfigFile(const std::string& confPath)
{
fs::ifstream streamConfig(GetConfigFile(confPath));
if (!streamConfig.good())
return; // No bitcoin.conf file is OK
{
LOCK(cs_args);
std::set<std::string> setOptions;
setOptions.insert("*");
for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
{
// Don't overwrite existing settings so command line settings override bitcoin.conf
std::string strKey = std::string("-") + it->string_key;
std::string strValue = it->value[0];
InterpretNegativeSetting(strKey, strValue);
if (mapArgs.count(strKey) == 0)
mapArgs[strKey] = strValue;
mapMultiArgs[strKey].push_back(strValue);
}
}
// If datadir is changed in .conf file:
ClearDatadirCache();
}
void openConfigfile()
{
boost::filesystem::path pathConfig = GetConfigFile();
/* Open dash.conf with the associated application */
if (boost::filesystem::exists(pathConfig))
QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
}
///////////////////
// Load the input from a config file
int CInput::Load(const std::string& name, const std::string& section)
{
std::string string;
if(!ReadString(GetConfigFile(),section,name,string,""))
return false;
return Setup(string);
}
void ColoursAndFontsManager::SaveGlobalSettings()
{
// save the global settings
JSONRoot root(cJSON_Object);
root.toElement().addProperty("m_globalBgColour", m_globalBgColour).addProperty("m_globalFgColour",
m_globalFgColour);
wxFileName fnSettings = GetConfigFile();
root.save(fnSettings.GetFullPath());
wxCommandEvent evtThemeChanged(wxEVT_CL_THEME_CHANGED);
EventNotifier::Get()->AddPendingEvent(evtThemeChanged);
}
void ColoursAndFontsManager::Load()
{
if(m_initialized) return;
m_lexersMap.clear();
m_initialized = true;
m_globalTheme = "Default";
// Load the global settings
if(GetConfigFile().FileExists()) {
JSONRoot root(GetConfigFile());
if(root.isOk()) {
m_globalBgColour = root.toElement().namedObject("m_globalBgColour").toColour(m_globalBgColour);
m_globalFgColour = root.toElement().namedObject("m_globalFgColour").toColour(m_globalFgColour);
m_globalTheme = root.toElement().namedObject("m_globalTheme").toString("Default");
}
}
// Load the lexers
ColoursAndFontsManagerLoaderHelper loader(this);
loader.Load();
}
void SubversionLocalProperties::ReadProperties()
{
m_values.clear();
wxString group;
wxFFile fp(GetConfigFile(), wxT("rb"));
if(fp.IsOpened()) {
wxString content;
fp.ReadAll(&content);
wxArrayString lines = wxStringTokenize(content, wxT("\n"), wxTOKEN_STRTOK);
for(size_t i = 0; i < lines.size(); i++) {
wxString entry = lines[i];
// remove the comment part
entry = entry.BeforeFirst(wxT(';'));
// trim the string
entry.Trim().Trim(false);
if(entry.IsEmpty()) continue;
if(entry.StartsWith(wxT("["))) {
// found new group
entry = entry.AfterFirst(wxT('['));
group = entry.BeforeFirst(wxT(']'));
group.Trim().Trim(false);
continue;
}
wxString key = entry.BeforeFirst(wxT('='));
wxString value = entry.AfterFirst(wxT('='));
key.Trim().Trim(false);
value.Trim().Trim(false);
if(group.IsEmpty()) {
// we dont have group yet - discard this entry
continue;
}
GroupTable::iterator iter = m_values.find(group);
if(iter == m_values.end()) {
// create new table and the value
SimpleTable tb;
tb[key] = value;
m_values[group] = tb;
} else {
m_values[group][key] = value;
}
}
}
}
int SaveSettings(LPSETTINGS pSettings)
{
ConfigDb *cfg = GetConfigFile();
if (!cfg)
return 0;
aud_cfg_db_set_int(cfg,CUBE_CONFIG_TAG,LOOPCOUNT_NAME,pSettings->loopcount);
aud_cfg_db_set_int(cfg,CUBE_CONFIG_TAG,FADESECOND_NAME,pSettings->fadeseconds);
aud_cfg_db_set_int(cfg,CUBE_CONFIG_TAG,FADEDELAYSECOND_NAME,pSettings->fadedelayseconds);
aud_cfg_db_close(cfg);
return 1;
}
bool openMachinecoinConf()
{
boost::filesystem::path pathConfig = GetConfigFile(gArgs.GetArg("-conf", MACHINECOIN_CONF_FILENAME));
/* Create the file */
boost::filesystem::ofstream configFile(pathConfig, std::ios_base::app);
if (!configFile.good())
return false;
configFile.close();
/* Open machinecoin.conf with the associated application */
return QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
}
void SubversionLocalProperties::WriteProperties()
{
wxFFile fp(GetConfigFile(), wxT("wb"));
if(fp.IsOpened()) {
GroupTable::const_iterator iter = m_values.begin();
for(; iter != m_values.end(); iter++) {
SimpleTable tb = iter->second;
wxString sectionName = iter->first;
SimpleTable::const_iterator it = tb.begin();
fp.Write(wxString::Format(wxT("[%s]\n"), sectionName.c_str()));
for(; it != tb.end(); it++) {
fp.Write(wxString::Format(wxT("%s=%s\n"), it->first.c_str(), it->second.c_str()));
}
}
}
}
int
MyApp::OnExit()
{
// Save config file
wxFileName configFile(GetConfigFile());
if (! configFile.DirExists())
configFile.Mkdir(0777, wxPATH_MKDIR_FULL);
wxFileConfig * config = dynamic_cast<wxFileConfig*>(wxFileConfig::Get());
wxASSERT(config != NULL);
wxFileOutputStream fileStream(configFile.GetFullPath());
config->Save(fileStream);
// Clean up printing stuff.
delete g_printData;
delete g_pageSetupData;
return wxApp::OnExit();
}
int LoadSettings(LPSETTINGS pSettings)
{
ConfigDb *cfg = GetConfigFile();
if (!cfg)
{
DefaultSettings(pSettings);
}
else
{
int bRet = (aud_cfg_db_get_int(cfg,CUBE_CONFIG_TAG,LOOPCOUNT_NAME,&pSettings->loopcount) &&
aud_cfg_db_get_int(cfg,CUBE_CONFIG_TAG,FADESECOND_NAME,&pSettings->fadeseconds) &&
aud_cfg_db_get_int(cfg,CUBE_CONFIG_TAG,FADEDELAYSECOND_NAME,&pSettings->fadedelayseconds));
aud_cfg_db_close(cfg);
// check if reading one value failed. If so, then use defaults
if (!bRet)
DefaultSettings(pSettings);
}
return 1;
}
TInt CSecMgrStore::WriteCounter(TExecutableID aExecID)
{
HBufC *configFile = HBufC::NewLC(KMaxName);
TPtr ptr(configFile->Des());
TInt ret(GetConfigFile (ptr));
if ( KErrNone==ret)
{
CFileStore* store = CPermanentFileStore::ReplaceLC (iFsSession,
*configFile, EFileWrite);
// Must say what kind of file store.
store->SetTypeL (KPermanentFileStoreLayoutUid);
// Construct the output stream.
RStoreWriteStream outstream;
TStreamId id = outstream.CreateLC (*store);
outstream.WriteInt32L (aExecID);
// Commit changes to the stream
outstream.CommitL ();
// Cleanup the stream object
CleanupStack::PopAndDestroy (&outstream);
// Set this stream id as the root
store->SetRootL (id);
// Commit changes to the store
store->CommitL ();
CleanupStack::PopAndDestroy (store);
}
CleanupStack::PopAndDestroy (configFile);
return ret;
}
void
MyApp::SetupConfig()
{
wxFileName configFile(GetConfigFile());
wxLogDebug(_T("Config file: %s"), configFile.GetFullPath().c_str());
/*
// Create a blank file it it doesn't exist
if (! configFile.FileExists())
wxFile(configFile.GetFullPath(), wxFile::write);
*/
// Setup wxFileConfig
if (configFile.FileExists())
{
wxFileInputStream fileStream(configFile.GetFullPath());
wxFileConfig::Set( new wxFileConfig(fileStream) );
}
else
{
wxFileConfig::Set( new wxFileConfig() );
}
// Setup our config manager
//-------------------------
m_config.SetConfig(wxFileConfig::Get());
// Window size/position defaults
m_config.SetPath(_T("/Window"));
m_config.AddLong(_T("top"), 20);
m_config.AddLong(_T("left"), 20);
m_config.AddLong(_T("width"), 500);
m_config.AddLong(_T("height"), 500);
m_config.AddBool(_T("maximized"), false);
// Grid style, fonts, and colors
m_config.SetPath(_T("/Grid"));
m_config.AddBool(_T("fit"), false);
m_config.AddLong(_T("style"), DEFAULT_GRID_STYLE);
m_config.AddFont(_T("letterFont"), *wxSWISS_FONT);
m_config.AddFont(_T("numberFont"), *wxSWISS_FONT);
m_config.AddLong(_T("lineThickness"), 1);
m_config.AddColor(_T("focusedLetterColor"), *wxGREEN);
m_config.AddColor(_T("focusedWordColor"), *wxLIGHT_GREY);
m_config.AddColor(_T("whiteSquareColor"), *wxWHITE);
m_config.AddColor(_T("blackSquareColor"), *wxBLACK);
m_config.AddColor(_T("penColor"), *wxBLACK);
m_config.AddColor(_T("pencilColor"), wxColor(200,200,200));
m_config.AddLong(_T("numberScale"), 42);
m_config.AddLong(_T("letterScale"), 75);
// Clue box
m_config.SetPath(_T("/Clue"));
m_config.AddFont(_T("font"),
wxFont(12, wxFONTFAMILY_SWISS,
wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
m_config.AddPoint(_T("spacing"), wxPoint(5, 5));
m_config.AddColor(_T("listForegroundColor"), *wxBLACK);
m_config.AddColor(_T("listBackgroundColor"), *wxWHITE);
m_config.AddColor(_T("selectedForegroundColor"),
wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) );
m_config.AddColor(_T("selectedBackgroundColor"),
wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) );
m_config.AddColor(_T("crossingForegroundColor"),
m_config.GetDefaultColor(_T("selectedBackgroundColor")));
// Using the selected foreground color here can make the list look
// really ugly. If, for example, the default selected text color
// is black, this would make the crossing clue's background color
// to default to black, which draws too much attention to that clue.
m_config.AddColor(_T("crossingBackgroundColor"), *wxWHITE);
m_config.AddFont(_T("headingFont"),
wxFont(14, wxFONTFAMILY_SWISS,
wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
m_config.AddColor(_T("headingForegroundColor"),
wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT ) );
m_config.AddColor(_T("headingBackgroundColor"),
wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE ) );
// Clue prompt
m_config.SetPath(_T("/Clue Prompt"));
m_config.AddFont(_T("font"), *wxSWISS_FONT);
m_config.AddColor(_T("foregroundColor"), *wxBLACK);
m_config.AddColor(_T("backgroundColor"), *wxWHITE);
m_config.AddString(_T("displayFormat"), _T("%N. %T"));
// Printing
m_config.SetPath(_T("/Printing"));
m_config.AddLong(_T("blackSquareBrightness"), 0);
m_config.AddLong(_T("gridAlignment"), wxALIGN_TOP | wxALIGN_RIGHT);
m_config.AddLong(_T("paperID"), wxPAPER_LETTER);
m_config.AddLong(_T("orientation"), wxPORTRAIT);
m_config.SetPath(_T("/Printing/Margins"));
m_config.AddLong(_T("left"), 15);
m_config.AddLong(_T("right"), 15);
m_config.AddLong(_T("top"), 15);
m_config.AddLong(_T("bottom"), 15);
m_config.SetPath(_T("/Printing/Fonts"));
m_config.AddBool(_T("useCustomFonts"), false);
m_config.AddFont(_T("gridLetterFont"), *wxSWISS_FONT);
m_config.AddFont(_T("gridNumberFont"), *wxSWISS_FONT);
m_config.AddFont(_T("clueFont"), *wxSWISS_FONT);
}
UniValue CallRPC(const std::string& strMethod, const UniValue& params)
{
std::string host = GetArg("-rpcconnect", DEFAULT_RPCCONNECT);
int port = GetArg("-rpcport", BaseParams().RPCPort());
// Obtain event base
raii_event_base base = obtain_event_base();
// Synchronously look up hostname
raii_evhttp_connection evcon = obtain_evhttp_connection_base(base.get(), host, port);
evhttp_connection_set_timeout(evcon.get(), GetArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT));
HTTPReply response;
raii_evhttp_request req = obtain_evhttp_request(http_request_done, (void*)&response);
if (req == NULL)
throw std::runtime_error("create http request failed");
#if LIBEVENT_VERSION_NUMBER >= 0x02010300
evhttp_request_set_error_cb(req.get(), http_error_cb);
#endif
// Get credentials
std::string strRPCUserColonPass;
if (GetArg("-rpcpassword", "") == "") {
// Try fall back to cookie-based authentication if no password is provided
if (!GetAuthCookie(&strRPCUserColonPass)) {
throw std::runtime_error(strprintf(
_("Could not locate RPC credentials. No authentication cookie could be found, and no rpcpassword is set in the configuration file (%s)"),
GetConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME)).string().c_str()));
}
} else {
strRPCUserColonPass = GetArg("-rpcuser", "") + ":" + GetArg("-rpcpassword", "");
}
struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
assert(output_headers);
evhttp_add_header(output_headers, "Host", host.c_str());
evhttp_add_header(output_headers, "Connection", "close");
evhttp_add_header(output_headers, "Authorization", (std::string("Basic ") + EncodeBase64(strRPCUserColonPass)).c_str());
// Attach request data
std::string strRequest = JSONRPCRequestObj(strMethod, params, 1).write() + "\n";
struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
assert(output_buffer);
evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, "/");
req.release(); // ownership moved to evcon in above call
if (r != 0) {
throw CConnectionFailed("send http request failed");
}
event_base_dispatch(base.get());
if (response.status == 0)
throw CConnectionFailed(strprintf("couldn't connect to server: %s (code %d)\n(make sure server is running and you are connecting to the correct RPC port)", http_errorstring(response.error), response.error));
else if (response.status == HTTP_UNAUTHORIZED)
throw std::runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
else if (response.status >= 400 && response.status != HTTP_BAD_REQUEST && response.status != HTTP_NOT_FOUND && response.status != HTTP_INTERNAL_SERVER_ERROR)
throw std::runtime_error(strprintf("server returned HTTP error %d", response.status));
else if (response.body.empty())
throw std::runtime_error("no response from server");
// Parse reply
UniValue valReply(UniValue::VSTR);
if (!valReply.read(response.body))
throw std::runtime_error("couldn't parse reply from server");
const UniValue& reply = valReply.get_obj();
if (reply.empty())
throw std::runtime_error("expected reply to have result, error and id properties");
return reply;
}
bool ArgsManager::ReadConfigFiles(std::string& error, bool ignore_invalid_keys)
{
{
LOCK(cs_args);
m_config_args.clear();
}
const std::string confPath = GetArg("-conf", FUJICOIN_CONF_FILENAME);
fs::ifstream stream(GetConfigFile(confPath));
// ok to not have a config file
if (stream.good()) {
if (!ReadConfigStream(stream, error, ignore_invalid_keys)) {
return false;
}
// if there is an -includeconf in the override args, but it is empty, that means the user
// passed '-noincludeconf' on the command line, in which case we should not include anything
if (m_override_args.count("-includeconf") == 0) {
std::string chain_id = GetChainName();
std::vector<std::string> includeconf(GetArgs("-includeconf"));
{
// We haven't set m_network yet (that happens in SelectParams()), so manually check
// for network.includeconf args.
std::vector<std::string> includeconf_net(GetArgs(std::string("-") + chain_id + ".includeconf"));
includeconf.insert(includeconf.end(), includeconf_net.begin(), includeconf_net.end());
}
// Remove -includeconf from configuration, so we can warn about recursion
// later
{
LOCK(cs_args);
m_config_args.erase("-includeconf");
m_config_args.erase(std::string("-") + chain_id + ".includeconf");
}
for (const std::string& to_include : includeconf) {
fs::ifstream include_config(GetConfigFile(to_include));
if (include_config.good()) {
if (!ReadConfigStream(include_config, error, ignore_invalid_keys)) {
return false;
}
LogPrintf("Included configuration file %s\n", to_include.c_str());
} else {
error = "Failed to include configuration file " + to_include;
return false;
}
}
// Warn about recursive -includeconf
includeconf = GetArgs("-includeconf");
{
std::vector<std::string> includeconf_net(GetArgs(std::string("-") + chain_id + ".includeconf"));
includeconf.insert(includeconf.end(), includeconf_net.begin(), includeconf_net.end());
std::string chain_id_final = GetChainName();
if (chain_id_final != chain_id) {
// Also warn about recursive includeconf for the chain that was specified in one of the includeconfs
includeconf_net = GetArgs(std::string("-") + chain_id_final + ".includeconf");
includeconf.insert(includeconf.end(), includeconf_net.begin(), includeconf_net.end());
}
}
for (const std::string& to_include : includeconf) {
fprintf(stderr, "warning: -includeconf cannot be used from included files; ignoring -includeconf=%s\n", to_include.c_str());
}
}
}
// If datadir is changed in .conf file:
ClearDatadirCache();
if (!fs::is_directory(GetDataDir(false))) {
error = strprintf("specified data directory \"%s\" does not exist.", gArgs.GetArg("-datadir", "").c_str());
return false;
}
return true;
}
//
// Store all the settings back to tasks.ini file
//
HRESULT CTasksPropertyPage::Apply()
{
WritePrivateProfileString(TASK_SECTION, SHOW_WORK_TASKS, (BST_CHECKED == IsDlgButtonChecked(IDC_WORKTASKS)) ? L"1" : L"0", (LPCWSTR)GetConfigFile());
WritePrivateProfileString(TASK_SECTION, SHOW_FAMILY_TASKS, (BST_CHECKED == IsDlgButtonChecked(IDC_FAMILYTASKS)) ? L"1" : L"0", (LPCWSTR)GetConfigFile());
return S_OK;
}
json_spirit::Object CallRPC(const std::string& strMethod, const json_spirit::Array& params)
{
if (mapArgs["-rpcuser"] == "" && mapArgs["-rpcpassword"] == "")
throw std::runtime_error(strprintf(
_("You must set rpcpassword=<password> in the configuration file:\n%s\n"
"If the file does not exist, create it with owner-readable-only file permissions."),
GetConfigFile().string().c_str()));
// Connect to localhost
bool fUseSSL = GetBoolArg("-rpcssl", false);
boost::asio::io_service io_service;
boost::asio::ssl::context context(io_service, boost::asio::ssl::context::sslv23);
context.set_options(boost::asio::ssl::context::no_sslv2);
boost::asio::ssl::stream<boost::asio::ip::tcp::socket> sslStream(io_service, context);
SSLIOStreamDevice<boost::asio::ip::tcp> d(sslStream, fUseSSL);
boost::iostreams::stream< SSLIOStreamDevice<boost::asio::ip::tcp> > stream(d);
bool fWait = GetBoolArg("-rpcwait", false); // -rpcwait means try until server has started
do {
bool fConnected = d.connect(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", itostr(Params().RPCPort())));
if (fConnected) break;
if (fWait)
MilliSleep(1000);
else
throw std::runtime_error("couldn't connect to server");
} while (fWait);
// HTTP basic authentication
std::string strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
std::map<std::string, std::string> mapRequestHeaders;
mapRequestHeaders["Authorization"] = std::string("Basic ") + strUserPass64;
// Send request
std::string strRequest = JSONRPCRequest(strMethod, params, 1);
std::string strPost = HTTPPost(strRequest, mapRequestHeaders);
stream << strPost << std::flush;
// Receive HTTP reply status
int nProto = 0;
int nStatus = ReadHTTPStatus(stream, nProto);
// Receive HTTP reply message headers and body
std::map<std::string, std::string> mapHeaders;
std::string strReply;
ReadHTTPMessage(stream, mapHeaders, strReply, nProto);
if (nStatus == HTTP_UNAUTHORIZED)
throw std::runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
else if (nStatus >= 400 && nStatus != HTTP_BAD_REQUEST && nStatus != HTTP_NOT_FOUND && nStatus != HTTP_INTERNAL_SERVER_ERROR)
throw std::runtime_error(strprintf("server returned HTTP error %d", nStatus));
else if (strReply.empty())
throw std::runtime_error("no response from server");
// Parse reply
json_spirit::Value valReply;
if (!read_string(strReply, valReply))
throw std::runtime_error("couldn't parse reply from server");
const json_spirit::Object& reply = valReply.get_obj();
if (reply.empty())
throw std::runtime_error("expected reply to have result, error and id properties");
return reply;
}
void CSettings::SaveSettings()
{
CApplication* app = CApplication::GetInstancePointer();
CRobotMain* main = CRobotMain::GetInstancePointer();
Gfx::CEngine* engine = Gfx::CEngine::GetInstancePointer();
Gfx::CCamera* camera = main->GetCamera();
CSoundInterface* sound = app->GetSound();
GetConfigFile().SetBoolProperty("Setup", "Tooltips", m_tooltips);
GetConfigFile().SetBoolProperty("Setup", "InterfaceGlint", m_interfaceGlint);
GetConfigFile().SetBoolProperty("Setup", "InterfaceRain", m_interfaceRain);
GetConfigFile().SetBoolProperty("Setup", "Soluce4", m_soluce4);
GetConfigFile().SetBoolProperty("Setup", "Movies", m_movies);
GetConfigFile().SetBoolProperty("Setup", "FocusLostPause", m_focusLostPause);
GetConfigFile().SetBoolProperty("Setup", "OldCameraScroll", camera->GetOldCameraScroll());
GetConfigFile().SetBoolProperty("Setup", "CameraInvertX", camera->GetCameraInvertX());
GetConfigFile().SetBoolProperty("Setup", "CameraInvertY", camera->GetCameraInvertY());
GetConfigFile().SetBoolProperty("Setup", "InterfaceEffect", camera->GetEffect());
GetConfigFile().SetBoolProperty("Setup", "Blood", camera->GetBlood());
GetConfigFile().SetBoolProperty("Setup", "Autosave", main->GetAutosave());
GetConfigFile().SetIntProperty("Setup", "AutosaveInterval", main->GetAutosaveInterval());
GetConfigFile().SetIntProperty("Setup", "AutosaveSlots", main->GetAutosaveSlots());
GetConfigFile().SetBoolProperty("Setup", "ObjectDirty", engine->GetDirty());
GetConfigFile().SetBoolProperty("Setup", "FogMode", engine->GetFog());
GetConfigFile().SetBoolProperty("Setup", "LightMode", engine->GetLightMode());
GetConfigFile().SetIntProperty("Setup", "JoystickIndex", app->GetJoystickEnabled() ? app->GetJoystick().index : -1);
GetConfigFile().SetFloatProperty("Setup", "ParticleDensity", engine->GetParticleDensity());
GetConfigFile().SetFloatProperty("Setup", "ClippingDistance", engine->GetClippingDistance());
GetConfigFile().SetIntProperty("Setup", "AudioVolume", sound->GetAudioVolume());
GetConfigFile().SetIntProperty("Setup", "MusicVolume", sound->GetMusicVolume());
GetConfigFile().SetBoolProperty("Setup", "EditIndentMode", engine->GetEditIndentMode());
GetConfigFile().SetIntProperty("Setup", "EditIndentValue", engine->GetEditIndentValue());
GetConfigFile().SetIntProperty("Setup", "MipmapLevel", engine->GetTextureMipmapLevel());
GetConfigFile().SetIntProperty("Setup", "Anisotropy", engine->GetTextureAnisotropyLevel());
GetConfigFile().SetFloatProperty("Setup", "ShadowColor", engine->GetShadowColor());
GetConfigFile().SetFloatProperty("Setup", "ShadowRange", engine->GetShadowRange());
GetConfigFile().SetIntProperty("Setup", "MSAA", engine->GetMultiSample());
GetConfigFile().SetIntProperty("Setup", "FilterMode", engine->GetTextureFilterMode());
GetConfigFile().SetBoolProperty("Setup", "ShadowMapping", engine->GetShadowMapping());
GetConfigFile().SetBoolProperty("Setup", "ShadowMappingQuality", engine->GetShadowMappingQuality());
GetConfigFile().SetIntProperty("Setup", "ShadowMappingResolution",
engine->GetShadowMappingOffscreen() ? engine->GetShadowMappingOffscreenResolution() : 0);
// Experimental settings
GetConfigFile().SetBoolProperty("Experimental", "TerrainShadows", engine->GetTerrainShadows());
CInput::GetInstancePointer()->SaveKeyBindings();
GetConfigFile().SetFloatProperty("Edit", "FontSize", m_fontSize);
GetConfigFile().SetFloatProperty("Edit", "WindowPosX", m_windowPos.x);
GetConfigFile().SetFloatProperty("Edit", "WindowPosY", m_windowPos.y);
GetConfigFile().SetFloatProperty("Edit", "WindowDimX", m_windowDim.x);
GetConfigFile().SetFloatProperty("Edit", "WindowDimY", m_windowDim.y);
GetConfigFile().SetBoolProperty("Edit", "IOPublic", m_IOPublic);
GetConfigFile().SetFloatProperty("Edit", "IOPosX", m_IOPos.x);
GetConfigFile().SetFloatProperty("Edit", "IOPosY", m_IOPos.y);
GetConfigFile().SetFloatProperty("Edit", "IODimX", m_IODim.x);
GetConfigFile().SetFloatProperty("Edit", "IODimY", m_IODim.y);
std::string lang = "";
LanguageToString(m_language, lang);
GetConfigFile().SetStringProperty("Language", "Lang", lang);
GetConfigFile().Save();
}
bool UOnlineHotfixManager::HotfixIniFile(const FString& FileName, const FString& IniData)
{
FConfigFile* ConfigFile = GetConfigFile(FileName);
// Merge the string into the config file
ConfigFile->CombineFromBuffer(IniData);
TArray<UClass*> Classes;
TArray<UObject*> PerObjectConfigObjects;
int32 StartIndex = 0;
int32 EndIndex = 0;
// Find the set of object classes that were affected
while (StartIndex >= 0 && StartIndex < IniData.Len() && EndIndex >= StartIndex)
{
// Find the next section header
StartIndex = IniData.Find(TEXT("["), ESearchCase::IgnoreCase, ESearchDir::FromStart, StartIndex);
if (StartIndex > -1)
{
// Find the ending section identifier
EndIndex = IniData.Find(TEXT("]"), ESearchCase::IgnoreCase, ESearchDir::FromStart, StartIndex);
if (EndIndex > StartIndex)
{
int32 PerObjectNameIndex = IniData.Find(TEXT(" "), ESearchCase::IgnoreCase, ESearchDir::FromStart, StartIndex);
// Per object config entries will have a space in the name, but classes won't
if (PerObjectNameIndex == -1 || PerObjectNameIndex > EndIndex)
{
if (IniData.StartsWith(TEXT("[/Script/"), ESearchCase::IgnoreCase))
{
const int32 ScriptSectionTag = 9;
// Snip the text out and try to find the class for that
const FString PackageClassName = IniData.Mid(StartIndex + ScriptSectionTag, EndIndex - StartIndex - ScriptSectionTag);
// Find the class for this so we know what to update
UClass* Class = FindObject<UClass>(nullptr, *PackageClassName, true);
if (Class)
{
// Add this to the list to check against
Classes.Add(Class);
}
}
}
// Handle the per object config case by finding the object for reload
else
{
const int32 Count = PerObjectNameIndex - StartIndex - 1;
const FString PerObjectName = IniData.Mid(StartIndex + 1, Count);
// Explicitly search the transient package (won't update non-transient objects)
UObject* PerObject = FindObject<UObject>(ANY_PACKAGE, *PerObjectName, false);
if (PerObject != nullptr)
{
PerObjectConfigObjects.Add(PerObject);
}
}
StartIndex = EndIndex;
}
}
}
int32 NumObjectsReloaded = 0;
const double StartTime = FPlatformTime::Seconds();
if (Classes.Num())
{
// Now that we have a list of classes to update, we can iterate objects and reload
for (FObjectIterator It; It; ++It)
{
UClass* Class = It->GetClass();
if (Class->HasAnyClassFlags(CLASS_Config))
{
// Check to see if this class is in our list (yes, potentially n^2, but not in practice)
for (int32 ClassIndex = 0; ClassIndex < Classes.Num(); ClassIndex++)
{
if (It->IsA(Classes[ClassIndex]))
{
// Force a reload of the config vars
It->ReloadConfig();
NumObjectsReloaded++;
break;
}
}
}
}
}
// Reload any PerObjectConfig objects that were affected
for (auto ReloadObject : PerObjectConfigObjects)
{
ReloadObject->ReloadConfig();
NumObjectsReloaded++;
}
UE_LOG(LogHotfixManager, Log, TEXT("Updating config from %s took %f seconds and reloaded %d objects"),
*FileName, FPlatformTime::Seconds() - StartTime, NumObjectsReloaded);
return true;
}
void CSettings::LoadSettings()
{
CApplication* app = CApplication::GetInstancePointer();
CRobotMain* main = CRobotMain::GetInstancePointer();
Gfx::CEngine* engine = Gfx::CEngine::GetInstancePointer();
Gfx::CCamera* camera = main->GetCamera();
CSoundInterface* sound = app->GetSound();
int iValue = 0;
float fValue = 0.0f;
bool bValue = false;
std::string sValue = "";
GetConfigFile().GetBoolProperty("Setup", "Tooltips", m_tooltips);
GetConfigFile().GetBoolProperty("Setup", "InterfaceGlint", m_interfaceGlint);
GetConfigFile().GetBoolProperty("Setup", "InterfaceRain", m_interfaceRain);
GetConfigFile().GetBoolProperty("Setup", "Soluce4", m_soluce4);
GetConfigFile().GetBoolProperty("Setup", "Movies", m_movies);
GetConfigFile().GetBoolProperty("Setup", "FocusLostPause", m_focusLostPause);
if (GetConfigFile().GetBoolProperty("Setup", "OldCameraScroll", bValue))
camera->SetOldCameraScroll(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "CameraInvertX", bValue))
camera->SetCameraInvertX(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "CameraInvertY", bValue))
camera->SetCameraInvertY(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "InterfaceEffect", bValue))
camera->SetEffect(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "Blood", bValue))
camera->SetBlood(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "Autosave", bValue))
main->SetAutosave(bValue);
if (GetConfigFile().GetIntProperty("Setup", "AutosaveInterval", iValue))
main->SetAutosaveInterval(iValue);
if (GetConfigFile().GetIntProperty("Setup", "AutosaveSlots", iValue))
main->SetAutosaveSlots(iValue);
if (GetConfigFile().GetBoolProperty("Setup", "ObjectDirty", bValue))
engine->SetDirty(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "FogMode", bValue))
{
engine->SetFog(bValue);
camera->SetOverBaseColor(Gfx::Color(0.0f, 0.0f, 0.0f, 0.0f)); // TODO: color ok?
}
if (GetConfigFile().GetBoolProperty("Setup", "LightMode", bValue))
engine->SetLightMode(bValue);
if (GetConfigFile().GetIntProperty("Setup", "JoystickIndex", iValue))
{
if (iValue >= 0)
{
auto joysticks = app->GetJoystickList();
for(const auto& joystick : joysticks)
{
if (joystick.index == iValue)
{
app->ChangeJoystick(joystick);
app->SetJoystickEnabled(true);
}
}
}
else
{
app->SetJoystickEnabled(false);
}
}
if (GetConfigFile().GetFloatProperty("Setup", "ParticleDensity", fValue))
engine->SetParticleDensity(fValue);
if (GetConfigFile().GetFloatProperty("Setup", "ClippingDistance", fValue))
engine->SetClippingDistance(fValue);
if (GetConfigFile().GetIntProperty("Setup", "AudioVolume", iValue))
sound->SetAudioVolume(iValue);
if (GetConfigFile().GetIntProperty("Setup", "MusicVolume", iValue))
sound->SetMusicVolume(iValue);
if (GetConfigFile().GetBoolProperty("Setup", "EditIndentMode", bValue))
engine->SetEditIndentMode(bValue);
if (GetConfigFile().GetIntProperty("Setup", "EditIndentValue", iValue))
engine->SetEditIndentValue(iValue);
if (GetConfigFile().GetIntProperty("Setup", "MipmapLevel", iValue))
engine->SetTextureMipmapLevel(iValue);
if (GetConfigFile().GetIntProperty("Setup", "Anisotropy", iValue))
engine->SetTextureAnisotropyLevel(iValue);
if (GetConfigFile().GetFloatProperty("Setup", "ShadowColor", fValue))
engine->SetShadowColor(fValue);
if (GetConfigFile().GetFloatProperty("Setup", "ShadowRange", fValue))
engine->SetShadowRange(fValue);
if (GetConfigFile().GetIntProperty("Setup", "MSAA", iValue))
engine->SetMultiSample(iValue);
if (GetConfigFile().GetIntProperty("Setup", "FilterMode", iValue))
engine->SetTextureFilterMode(static_cast<Gfx::TexFilter>(iValue));
if (GetConfigFile().GetBoolProperty("Setup", "ShadowMapping", bValue))
engine->SetShadowMapping(bValue);
if (GetConfigFile().GetBoolProperty("Setup", "ShadowMappingQuality", bValue))
engine->SetShadowMappingQuality(bValue);
if (GetConfigFile().GetIntProperty("Setup", "ShadowMappingResolution", iValue))
{
if (iValue == 0)
{
engine->SetShadowMappingOffscreen(false);
}
else
{
engine->SetShadowMappingOffscreen(true);
engine->SetShadowMappingOffscreenResolution(iValue);
}
}
if (GetConfigFile().GetBoolProperty("Experimental", "TerrainShadows", bValue))
engine->SetTerrainShadows(bValue);
CInput::GetInstancePointer()->LoadKeyBindings();
GetConfigFile().GetFloatProperty("Edit", "FontSize", m_fontSize);
GetConfigFile().GetFloatProperty("Edit", "WindowPosX", m_windowPos.x);
GetConfigFile().GetFloatProperty("Edit", "WindowPosY", m_windowPos.y);
GetConfigFile().GetFloatProperty("Edit", "WindowDimX", m_windowDim.x);
GetConfigFile().GetFloatProperty("Edit", "WindowDimY", m_windowDim.y);
GetConfigFile().GetBoolProperty ("Edit", "IOPublic", m_IOPublic);
GetConfigFile().GetFloatProperty("Edit", "IOPosX", m_IOPos.x);
GetConfigFile().GetFloatProperty("Edit", "IOPosY", m_IOPos.y);
GetConfigFile().GetFloatProperty("Edit", "IODimX", m_IODim.x);
GetConfigFile().GetFloatProperty("Edit", "IODimY", m_IODim.y);
m_language = LANGUAGE_ENV;
if (GetConfigFile().GetStringProperty("Language", "Lang", sValue))
{
if (!sValue.empty() && !ParseLanguage(sValue, m_language))
{
GetLogger()->Error("Failed to parse language '%s' from config file. Default language will be used.\n",
sValue.c_str());
}
}
app->SetLanguage(m_language);
}
//
// Initial rendering of the property dialog
//
HRESULT CTasksPropertyPage::Show(UINT nCmdShow)
{
WCHAR wszEnabled[2] = {0};
GetPrivateProfileString(TASK_SECTION, SHOW_WORK_TASKS, L"0", wszEnabled, 2, (LPCWSTR)GetConfigFile());
CheckDlgButton(IDC_WORKTASKS, (0 == wcscmp(wszEnabled, L"0")) ? BST_UNCHECKED : BST_CHECKED);
GetPrivateProfileString(TASK_SECTION, SHOW_FAMILY_TASKS, L"0", wszEnabled, 2, (LPCWSTR)GetConfigFile());
CheckDlgButton(IDC_FAMILYTASKS, (0 == wcscmp(wszEnabled, L"0")) ? BST_UNCHECKED : BST_CHECKED);
ShowWindow(nCmdShow);
InvalidateRect(NULL,TRUE);
return NOERROR;
}
static UniValue CallRPC(BaseRequestHandler *rh, const std::string& strMethod, const std::vector<std::string>& args)
{
std::string host;
// In preference order, we choose the following for the port:
// 1. -rpcport
// 2. port in -rpcconnect (ie following : in ipv4 or ]: in ipv6)
// 3. default port for chain
int port = BaseParams().RPCPort();
SplitHostPort(gArgs.GetArg("-rpcconnect", DEFAULT_RPCCONNECT), port, host);
port = gArgs.GetArg("-rpcport", port);
// Obtain event base
raii_event_base base = obtain_event_base();
// Synchronously look up hostname
raii_evhttp_connection evcon = obtain_evhttp_connection_base(base.get(), host, port);
evhttp_connection_set_timeout(evcon.get(), gArgs.GetArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT));
HTTPReply response;
raii_evhttp_request req = obtain_evhttp_request(http_request_done, (void*)&response);
if (req == nullptr)
throw std::runtime_error("create http request failed");
#if LIBEVENT_VERSION_NUMBER >= 0x02010300
evhttp_request_set_error_cb(req.get(), http_error_cb);
#endif
// Get credentials
std::string strRPCUserColonPass;
bool failedToGetAuthCookie = false;
if (gArgs.GetArg("-rpcpassword", "") == "") {
// Try fall back to cookie-based authentication if no password is provided
if (!GetAuthCookie(&strRPCUserColonPass)) {
failedToGetAuthCookie = true;
}
} else {
strRPCUserColonPass = gArgs.GetArg("-rpcuser", "") + ":" + gArgs.GetArg("-rpcpassword", "");
}
struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
assert(output_headers);
evhttp_add_header(output_headers, "Host", host.c_str());
evhttp_add_header(output_headers, "Connection", "close");
evhttp_add_header(output_headers, "Authorization", (std::string("Basic ") + EncodeBase64(strRPCUserColonPass)).c_str());
// Attach request data
std::string strRequest = rh->PrepareRequest(strMethod, args).write() + "\n";
struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
assert(output_buffer);
evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
// check if we should use a special wallet endpoint
std::string endpoint = "/";
if (!gArgs.GetArgs("-rpcwallet").empty()) {
std::string walletName = gArgs.GetArg("-rpcwallet", "");
char *encodedURI = evhttp_uriencode(walletName.c_str(), walletName.size(), false);
if (encodedURI) {
endpoint = "/wallet/"+ std::string(encodedURI);
free(encodedURI);
}
else {
throw CConnectionFailed("uri-encode failed");
}
}
int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, endpoint.c_str());
req.release(); // ownership moved to evcon in above call
if (r != 0) {
throw CConnectionFailed("send http request failed");
}
event_base_dispatch(base.get());
if (response.status == 0) {
std::string responseErrorMessage;
if (response.error != -1) {
responseErrorMessage = strprintf(" (error code %d - \"%s\")", response.error, http_errorstring(response.error));
}
throw CConnectionFailed(strprintf("Could not connect to the server %s:%d%s\n\nMake sure the bitcoind server is running and that you are connecting to the correct RPC port.", host, port, responseErrorMessage));
} else if (response.status == HTTP_UNAUTHORIZED) {
if (failedToGetAuthCookie) {
throw std::runtime_error(strprintf(
"Could not locate RPC credentials. No authentication cookie could be found, and RPC password is not set. See -rpcpassword and -stdinrpcpass. Configuration file: (%s)",
GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME)).string().c_str()));
} else {
throw std::runtime_error("Authorization failed: Incorrect rpcuser or rpcpassword");
}
} else if (response.status >= 400 && response.status != HTTP_BAD_REQUEST && response.status != HTTP_NOT_FOUND && response.status != HTTP_INTERNAL_SERVER_ERROR)
throw std::runtime_error(strprintf("server returned HTTP error %d", response.status));
else if (response.body.empty())
throw std::runtime_error("no response from server");
// Parse reply
UniValue valReply(UniValue::VSTR);
if (!valReply.read(response.body))
throw std::runtime_error("couldn't parse reply from server");
const UniValue reply = rh->ProcessReply(valReply);
if (reply.empty())
throw std::runtime_error("expected reply to have result, error and id properties");
return reply;
}
void CSettings::SetFontSize(float size)
{
m_fontSize = size;
GetConfigFile().SetFloatProperty("Edit", "FontSize", m_fontSize);
GetConfigFile().Save();
}
/** Set up things in deep and shallow options that aren't directly specified
on the command line.
@param deepOpts: the condor_submit_dag deep options
@param shallowOpts: the condor_submit_dag shallow options
@return 0 if successful, 1 if failed
*/
int
setUpOptions( SubmitDagDeepOptions &deepOpts,
SubmitDagShallowOptions &shallowOpts )
{
shallowOpts.strLibOut = shallowOpts.primaryDagFile + ".lib.out";
shallowOpts.strLibErr = shallowOpts.primaryDagFile + ".lib.err";
if ( deepOpts.strOutfileDir != "" ) {
shallowOpts.strDebugLog = deepOpts.strOutfileDir + DIR_DELIM_STRING +
condor_basename( shallowOpts.primaryDagFile.Value() );
} else {
shallowOpts.strDebugLog = shallowOpts.primaryDagFile;
}
shallowOpts.strDebugLog += ".dagman.out";
shallowOpts.strSchedLog = shallowOpts.primaryDagFile + ".dagman.log";
shallowOpts.strSubFile = shallowOpts.primaryDagFile + DAG_SUBMIT_FILE_SUFFIX;
MyString rescueDagBase;
// If we're running each DAG in its own directory, write any rescue
// DAG to the current directory, to avoid confusion (since the
// rescue DAG must be run from the current directory).
if ( deepOpts.useDagDir ) {
if ( !condor_getcwd( rescueDagBase ) ) {
fprintf( stderr, "ERROR: unable to get cwd: %d, %s\n",
errno, strerror(errno) );
return 1;
}
rescueDagBase += DIR_DELIM_STRING;
rescueDagBase += condor_basename(shallowOpts.primaryDagFile.Value());
} else {
rescueDagBase = shallowOpts.primaryDagFile;
}
// If we're running multiple DAGs, put "_multi" in the rescue
// DAG name to indicate that the rescue DAG is for *all* of
// the DAGs we're running.
if ( shallowOpts.dagFiles.number() > 1 ) {
rescueDagBase += "_multi";
}
shallowOpts.strRescueFile = rescueDagBase + ".rescue";
shallowOpts.strLockFile = shallowOpts.primaryDagFile + ".lock";
if (deepOpts.strDagmanPath == "" ) {
deepOpts.strDagmanPath = which( dagman_exe );
}
if (deepOpts.strDagmanPath == "")
{
fprintf( stderr, "ERROR: can't find %s in PATH, aborting.\n",
dagman_exe );
return 1;
}
MyString msg;
if ( !GetConfigFile( shallowOpts.dagFiles, deepOpts.useDagDir,
shallowOpts.strConfigFile, msg) ) {
fprintf( stderr, "ERROR: %s\n", msg.Value() );
return 1;
}
return 0;
}
void CSettings::SetIOPublic(bool mode)
{
m_IOPublic = mode;
GetConfigFile().SetBoolProperty("Edit", "IOPublic", m_IOPublic);
GetConfigFile().Save();
}
SigUIFrame::SigUIFrame(wxFrame *frame)
: GUIFrame(frame), val_bytecode(true), watcher(0)
{
#ifdef _WIN32
SetIcon(wxIcon(wxT("aaaa")));
#endif
icon = new wxTaskBarIcon();
icon->Connect(wxEVT_TASKBAR_BALLOON_TIMEOUT, wxTaskBarIconEventHandler(SigUIFrame::OnBalloon), NULL, this);
icon->Connect(wxEVT_TASKBAR_BALLOON_CLICK, wxTaskBarIconEventHandler(SigUIFrame::OnBalloon), NULL, this);
this->Connect(wxEVT_FSWATCHER, wxFileSystemWatcherEventHandler(SigUIFrame::OnChange));
this->Connect(wxEVT_END_PROCESS, wxProcessEventHandler(SigUIFrame::OnTerminateInstall));
this->SetStatusBar(statusBar);
statusBar->SetStatusText(REPO_VERSION, 1);
// m_sig_files->SetDropTarget(new DropFiles(m_sig_files));
// m_urls->SetDropTarget(new DropURLs(m_urls));
editor = new ConfigEditor(GetConfigFile());
editor->RegisterText("HTTPProxyServer", &val_proxy_server, m_proxy_server, "hostname or IP address");
editor->RegisterInt("HTTPProxyPort", &val_proxy_port, m_proxy_port);
editor->RegisterText("HTTPProxyUsername", &val_proxy_username, m_proxy_user);
editor->RegisterText("HTTPProxyPassword", &val_proxy_password, m_proxy_password);
editor->RegisterText("DatabaseMirror", &val_mirror, m_mirror, "db.COUNTRYCODE.clamav.net");
editor->RegisterStatic("DatabaseMirror", "db.local.win.clamav.net");
editor->RegisterBool("Bytecode", &val_bytecode, m_bytecode);
editor->RegisterList("DatabaseCustomURL", m_urls);
HostnameValidator mirrorValidator(&val_mirror);
m_mirror->SetValidator(mirrorValidator);
HostnameValidator proxyValidator(&val_proxy_server);
m_proxy_server->SetValidator(proxyValidator);
editor->Load();
if (!val_proxy_port)
val_proxy_port = 8080;//default
TransferDataToWindow();
if (!val_proxy_server.empty()) {
m_proxy->SetValue(true);
if (!val_proxy_username.empty() && !val_proxy_password.empty())
m_proxyauth->SetValue(true);
}
// update enabled status
wxCommandEvent event;
m_proxyOnCheckBox(event);
if (!m_urls->IsEmpty())
m_custom_remove->Enable();
m_proxy->SetFocus();
// keyboard shortcuts
wxAcceleratorEntry entries[1];
entries[0].Set(wxACCEL_CTRL, (int)'S', wxID_SAVE);
wxAcceleratorTable accel(sizeof(entries)/sizeof(entries[0]), entries);
this->SetAcceleratorTable(accel);
//prevent window from being resizing below minimum
this->GetSizer()->SetSizeHints(this);
show_db(true);
}