PurpleI2P/i2pd-qt
1
0
Fork 0
mirror of https://github.com/PurpleI2P/i2pd-qt.git synced 2025-01-24 21:34:15 +00:00
Code Issues Releases Wiki Activity

Revert "Fix for #42, #26"

Browse Source
This commit is contained in:
nonlin-lin-chaos-order-etc-etal 2023-04-06 14:31:38 +08:00 committed by GitHub
parent 37c1d53406
commit c0931a9e4b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 172 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
i2pd_qt.pro
View File

@ -29,7 +29,6 @@ CONFIG(debug, debug|release) {
DEFINES += I2PD_QT_DEBUG
I2PDMAKE += DEBUG=yes
QMAKE_CXXFLAGS_DEBUG += "-O0"
}
CONFIG(release, debug|release) {
message(Release build)
@ -38,9 +37,7 @@ CONFIG(release, debug|release) {
}
SOURCES += \
src/launcher/i2pd_qt_launcher.cpp \
src/controller/i2pd_daemon_controller.cpp \
src/MutexWrapperLock.cpp \
src/DaemonQT.cpp \
src/mainwindow.cpp \
src/ClientTunnelPane.cpp \
src/MainWindowItems.cpp \
@ -67,10 +64,7 @@ SOURCES += \
src/I2pdQtUtil.cpp
HEADERS += \
src/ConcurrentHolder.h \
src/launcher/i2pd_qt_launcher.h \
src/controller/i2pd_daemon_controller.h \
src/MutexWrapperLock.h \
src/DaemonQT.h \
src/mainwindow.h \
src/ClientTunnelPane.h \
src/MainWindowItems.h \

33
src/ConcurrentHolder.h
View File

@ -1,33 +0,0 @@
#ifndef ConcurrentHolder_H
#define ConcurrentHolder_H
#include <QRecursiveMutex>
#include "MutexWrapperLock.h"
#include <assert.h>
template <class HeldDataType>
class ConcurrentHolder
{
public:
ConcurrentHolder(HeldDataType _data) {
data = _data;
mutex = new QRecursiveMutex();
assert(mutex!=nullptr);
}
~ConcurrentHolder() {
assert(mutex!=nullptr);
delete mutex;
}
QRecursiveMutex* getMutex() {
assert(mutex!=nullptr);
return mutex;
}
HeldDataType& getData() {
return data;
}
private:
HeldDataType data;
QRecursiveMutex* mutex;
};
#endif // ConcurrentHolder_H

54
src/controller/i2pd_daemon_controller.cpp → src/DaemonQT.cpp
View File

@ -1,6 +1,6 @@
#include <memory>
#include "controller/i2pd_daemon_controller.h"
#include "DaemonQT.h"
#include "Daemon.h"
#include "mainwindow.h"
@ -11,8 +11,12 @@
#include <QMutexLocker>
#include <QThread>
namespace i2p {
namespace qt {
//#define DEBUG_WITH_DEFAULT_LOGGING (1)
namespace i2p
{
namespace qt
{
Worker::Worker (DaemonQTImpl& daemon):
m_Daemon (daemon)
{
@ -142,6 +146,50 @@ namespace qt {
m_RunningChangedCallback();
}
}
int RunQT (int argc, char* argv[])
{
QApplication app(argc, argv);
int result;
{
std::shared_ptr<std::iostream> logstreamptr=
#ifdef DEBUG_WITH_DEFAULT_LOGGING
nullptr
#else
std::make_shared<std::stringstream>()
#endif
;
//TODO move daemon init deinit to a bg thread
DaemonQTImpl daemon;
if(logstreamptr) (*logstreamptr) << "Initialising the daemon..." << std::endl;
bool daemonInitSuccess = daemon.init(argc, argv, logstreamptr);
if(!daemonInitSuccess)
{
QMessageBox::critical(0, "Error", "Daemon init failed");
return 1;
}
LogPrint(eLogDebug, "Initialised, creating the main window...");
MainWindow w(logstreamptr);
LogPrint(eLogDebug, "Before main window.show()...");
w.show ();
{
i2p::qt::Controller daemonQtController(daemon);
w.setI2PController(&daemonQtController);
LogPrint(eLogDebug, "Starting the daemon...");
emit daemonQtController.startDaemon();
//daemon.start ();
LogPrint(eLogDebug, "Starting GUI event loop...");
result = app.exec();
//daemon.stop ();
}
}
//QMessageBox::information(&w, "Debug", "demon stopped");
LogPrint(eLogDebug, "Exiting the application");
return result;
}
}
}

6
src/controller/i2pd_daemon_controller.h → src/DaemonQT.h
View File

@ -1,5 +1,5 @@
#ifndef I2PD_DAEMON_CONTROLLER_H
#define I2PD_DAEMON_CONTROLLER_H
#ifndef DAEMONQT_H
#define DAEMONQT_H
#include <memory>
#include <QObject>
@ -85,4 +85,4 @@ namespace qt
}
}
#endif // I2PD_DAEMON_CONTROLLER_H
#endif // DAEMONQT_H

5
src/DelayedSaveManagerImpl.cpp
View File

@ -51,11 +51,6 @@ bool DelayedSaveManagerImpl::appExiting() {
return true;
}
void DelayedSaveManagerImpl::saveNow() {
assert(isSaverValid());
saver->save(isReloadAfterSave(), FocusEnum::noFocus);
}
DelayedSaveThread::DelayedSaveThread(DelayedSaveManagerImpl* delayedSaveManagerImpl_):
delayedSaveManagerImpl(delayedSaveManagerImpl_),
mutex(new QMutex()),

1
src/DelayedSaveManagerImpl.h
View File

@ -53,7 +53,6 @@ public:
virtual void setSaver(Saver* saver);
virtual void start();
virtual void delayedSave(bool reloadAfterSave, DATA_SERIAL_TYPE dataSerial, FocusEnum focusOn, std::string tunnelNameToFocus, QWidget* widgetToFocus);
void saveNow();
virtual bool appExiting();
typedef DelayedSaveThread::TIMESTAMP_TYPE TIMESTAMP_TYPE;

10
src/MutexWrapperLock.cpp
View File

@ -1,10 +0,0 @@
#include "MutexWrapperLock.h"
MutexWrapperLock::MutexWrapperLock(QRecursiveMutex* _mutex) {
mutex = _mutex;
_mutex->lock();
}
MutexWrapperLock::~MutexWrapperLock() {
mutex->unlock();
}

15
src/MutexWrapperLock.h
View File

@ -1,15 +0,0 @@
#ifndef MUTEXWRAPPERLOCK_H
#define MUTEXWRAPPERLOCK_H
#include <QRecursiveMutex>
class MutexWrapperLock
{
public:
MutexWrapperLock(QRecursiveMutex* _mutex);
~MutexWrapperLock();
private:
QRecursiveMutex* mutex;
};
#endif // MUTEXWRAPPERLOCK_H

13
src/SaverImpl.cpp
View File

@ -9,8 +9,8 @@
#include "mainwindow.h"
SaverImpl::SaverImpl(MainWindow *mainWindowPtr_) :
confpath(), tunconfpath(), mainWindowPtr(mainWindowPtr_)
SaverImpl::SaverImpl(MainWindow *mainWindowPtr_, QList<MainWindowItem*>* configItems_, std::map<std::string,TunnelConfig*>* tunnelConfigs_) :
configItems(configItems_), tunnelConfigs(tunnelConfigs_), confpath(), tunconfpath(), mainWindowPtr(mainWindowPtr_)
{
QObject::connect(this, SIGNAL(showPreventedSaveTunnelsConfMessage()), mainWindowPtr, SLOT(showTunnelsPagePreventedMessage()));
}
@ -18,13 +18,10 @@ SaverImpl::SaverImpl(MainWindow *mainWindowPtr_) :
SaverImpl::~SaverImpl() {}
bool SaverImpl::save(bool reloadAfterSave, const FocusEnum focusOn, const std::string& tunnelNameToFocus, QWidget* widgetToFocus) {
MutexWrapperLock lock(mainWindowPtr->volatileDataHolder->getMutex());
MainWindow::VolatileData* vdata = mainWindowPtr->volatileDataHolder->getData();
//save main config
{
std::stringstream out;
for(QList<MainWindowItem*>::iterator it = vdata->configItems.begin(); it!= vdata->configItems.end(); ++it) {
for(QList<MainWindowItem*>::iterator it = configItems->begin(); it!= configItems->end(); ++it) {
MainWindowItem* item = *it;
item->saveToStringStream(out);
}
@ -47,9 +44,9 @@ bool SaverImpl::save(bool reloadAfterSave, const FocusEnum focusOn, const std::s
}else{
std::stringstream out;
for (const auto& it : vdata->tunnelConfigs) {
for (std::map<std::string,TunnelConfig*>::iterator it=tunnelConfigs->begin(); it!=tunnelConfigs->end(); ++it) {
//const std::string& name = it->first;
TunnelConfig* tunconf = it.second;
TunnelConfig* tunconf = it->second;
tunconf->saveHeaderToStringStream(out);
tunconf->saveToStringStream(out);
tunconf->saveI2CPParametersToStringStream(out);

4
src/SaverImpl.h
View File

@ -16,12 +16,14 @@ class TunnelConfig;
class SaverImpl : public Saver {
public:
SaverImpl(MainWindow *mainWindowPtr_);
SaverImpl(MainWindow *mainWindowPtr_, QList<MainWindowItem*>* configItems_, std::map<std::string,TunnelConfig*>* tunnelConfigs_);
virtual ~SaverImpl();
virtual bool save(bool reloadAfterSave, const FocusEnum focusOn, const std::string& tunnelNameToFocus, QWidget* widgetToFocus);
void setConfPath(QString& confpath_);
void setTunnelsConfPath(QString& tunconfpath_);
private:
QList<MainWindowItem*>* configItems;
std::map<std::string,TunnelConfig*>* tunnelConfigs;
QString confpath;
QString tunconfpath;
MainWindow* mainWindowPtr;

14
src/TunnelConfig.h
View File

@ -81,15 +81,13 @@ class TunnelConfig {
*/
QString type;
std::string name;
int _tunnelId;
TunnelPane* tunnelPane;
int cryptoType;
public:
TunnelConfig(int tunnelId, std::string name_, QString& type_, I2CPParameters& i2cpParameters_, int cryptoType_):
type(type_), name(name_), _tunnelId(tunnelId), cryptoType(cryptoType_), i2cpParameters(i2cpParameters_) {}
TunnelConfig(std::string name_, QString& type_, I2CPParameters& i2cpParameters_, int cryptoType_):
type(type_), name(name_), cryptoType(cryptoType_), i2cpParameters(i2cpParameters_) {}
virtual ~TunnelConfig(){}
const QString& getType(){return type;}
int get_TunnelId(){return _tunnelId;}
const std::string& getName(){return name;}
int getcryptoType(){return cryptoType;}
void setType(const QString& type_){type=type_;}
@ -137,14 +135,14 @@ class ClientTunnelConfig : public TunnelConfig {
int destinationPort;
i2p::data::SigningKeyType sigType;
public:
ClientTunnelConfig(int tunnelId, std::string name_, QString type_, I2CPParameters& i2cpParameters_,
ClientTunnelConfig(std::string name_, QString type_, I2CPParameters& i2cpParameters_,
std::string dest_,
int port_,
std::string keys_,
std::string address_,
int destinationPort_,
i2p::data::SigningKeyType sigType_,
int cryptoType_): TunnelConfig(tunnelId, name_, type_, i2cpParameters_, cryptoType_),
int cryptoType_): TunnelConfig(name_, type_, i2cpParameters_, cryptoType_),
dest(dest_),
port(port_),
keys(keys_),
@ -207,7 +205,7 @@ class ServerTunnelConfig : public TunnelConfig {
std::string address;
bool isUniqueLocal;
public:
ServerTunnelConfig(int tunnelId, std::string name_, QString type_, I2CPParameters& i2cpParameters_,
ServerTunnelConfig(std::string name_, QString type_, I2CPParameters& i2cpParameters_,
std::string host_,
int port_,
std::string keys_,
@ -219,7 +217,7 @@ public:
i2p::data::SigningKeyType sigType_,
std::string address_,
bool isUniqueLocal_,
int cryptoType_): TunnelConfig(tunnelId, name_, type_, i2cpParameters_, cryptoType_),
int cryptoType_): TunnelConfig(name_, type_, i2cpParameters_, cryptoType_),
host(host_),
port(port_),
keys(keys_),

65
src/launcher/i2pd_qt_launcher.cpp
View File

@ -1,65 +0,0 @@
#include <memory>
#include "launcher/i2pd_qt_launcher.h"
#include "controller/i2pd_daemon_controller.h"
#include "Daemon.h"
#include "mainwindow.h"
#include "Log.h"
#include <QMessageBox>
#include <QApplication>
#include <QMutexLocker>
#include <QThread>
//#define DEBUG_WITH_DEFAULT_LOGGING (1)
namespace i2p {
namespace qt {
//TODO rework for clean MVC
int RunQT (int argc, char* argv[]) {
QApplication app(argc, argv);
int result;
{
std::shared_ptr<std::iostream> logstreamptr =
#ifdef DEBUG_WITH_DEFAULT_LOGGING
nullptr
#else
std::make_shared<std::stringstream>()
#endif
;
//TODO move daemon init deinit to a bg thread
DaemonQTImpl daemon;
if (logstreamptr) (*logstreamptr) << "Initialising the daemon..." << std::endl;
bool daemonInitSuccess = daemon.init(argc, argv, logstreamptr);
if (!daemonInitSuccess) {
QMessageBox::critical(0, "Error", "Daemon init failed");
return 1;
}
LogPrint(eLogDebug, "Initialised, creating the main window...");
MainWindow w(logstreamptr);
LogPrint(eLogDebug, "Before main window.show()...");
w.show ();
{
i2p::qt::Controller daemonQtController(daemon);
w.setI2PController(&daemonQtController);
LogPrint(eLogDebug, "Starting the daemon...");
emit daemonQtController.startDaemon();
//daemon.start ();
LogPrint(eLogDebug, "Starting GUI event loop...");
result = app.exec();
//daemon.stop ();
}
}
//QMessageBox::information(&w, "Debug", "demon stopped");
LogPrint(eLogDebug, "Exiting the application");
return result;
}
}
}

10
src/launcher/i2pd_qt_launcher.h
View File

@ -1,10 +0,0 @@
#ifndef I2PD_QT_LAUNCHER_H
#define I2PD_QT_LAUNCHER_H
namespace i2p {
namespace qt {
int RunQT (int argc, char* argv[]);
}
}
#endif // I2PD_QT_LAUNCHER_H

192
src/mainwindow.cpp
View File

@ -33,8 +33,7 @@
# include <QtDebug>
#endif
#include "controller/i2pd_daemon_controller.h"
#include "DaemonQT.h"
#include "SignatureTypeComboboxFactory.h"
#include "logviewermanager.h"
@ -64,24 +63,22 @@ MainWindow::MainWindow(std::shared_ptr<std::iostream> logStream_, QWidget *paren
,routerCommandsParent(new QWidget(this))
,widgetlocks()
,i2pController(nullptr)
,configItems()
,datadir()
,confpath()
,tunconfpath()
,ignoreUpdatesOnAppendForms(false)
,volatileDataHolder(new ConcurrentHolder<VolatileData*>(new VolatileData()))
,tunnelConfigs()
,tunnelsPageUpdateListener(this)
,preventSaveTunnelsBool(false)
,saverPtr(nullptr)
,saverPtr(
new SaverImpl(this,
&configItems,
&tunnelConfigs))
{
assert(delayedSaveManagerPtr!=nullptr);
assert(volatileDataHolder!=nullptr);
assert(volatileDataHolder->getData()!=nullptr);
saverPtr=new SaverImpl(this);
assert(saverPtr!=nullptr);
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
ui->setupUi(this);
statusButtonsUI->setupUi(ui->statusButtonsPane);
routerCommandsUI->setupUi(routerCommandsParent);
@ -211,8 +208,8 @@ MainWindow::MainWindow(std::shared_ptr<std::iostream> logStream_, QWidget *paren
initFolderChooser( OPTION("","datadir",[]{return "";}), uiSettings->dataFolderLineEdit, uiSettings->dataFolderBrowsePushButton);
initIPAddressBox( OPTION("","host",[]{return "";}), uiSettings->routerExternalHostLineEdit, tr("Router external address -> Host"));
initTCPPortBox( OPTION("","port",[]{return "";}), uiSettings->routerExternalPortLineEdit, tr("Router external address -> Port"));
daemonOption=initNonGUIOption( OPTION("","daemon",[]{return "";}),type_bool);
serviceOption=initNonGUIOption( OPTION("","service",[]{return "";}),type_bool);
daemonOption=initNonGUIOption( OPTION("","daemon",[]{return "";}));
serviceOption=initNonGUIOption( OPTION("","service",[]{return "";}));
initStringBox( OPTION("","ifname4",[]{return "";}), uiSettings->ifname4LineEdit);//Network interface to bind to for IPv4
initStringBox( OPTION("","ifname6",[]{return "";}), uiSettings->ifname6LineEdit);//Network interface to bind to for IPv6
initCheckBox( OPTION("","nat",[]{return "true";}), uiSettings->natCheckBox);//If true, assume we are behind NAT. true by default
@ -391,7 +388,7 @@ MainWindow::MainWindow(std::shared_ptr<std::iostream> logStream_, QWidget *paren
uiSettings->configFileLineEdit->setText(confpath);
uiSettings->tunnelsConfigFileLineEdit->setText(tunconfpath);
for(QList<MainWindowItem*>::iterator it = vdata->configItems.begin(); it!= vdata->configItems.end(); ++it) {
for(QList<MainWindowItem*>::iterator it = configItems.begin(); it!= configItems.end(); ++it) {
MainWindowItem* item = *it;
item->installListeners(this);
}
@ -604,7 +601,7 @@ void MainWindow::iconActivated(QSystemTrayIcon::ActivationReason reason) {
setVisible(!isVisible());
break;
default:
qDebug() << "MainWindow::iconActivated(): unknown reason: " << reason << Qt::endl;
qDebug() << "MainWindow::iconActivated(): unknown reason: " << reason << endl;
break;
}
}
@ -667,13 +664,11 @@ MainWindow::~MainWindow()
delete statusPageUpdateTimer;
delete delayedSaveManagerPtr;
delete saverPtr;
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
for(QList<MainWindowItem*>::iterator it = vdata->configItems.begin(); it!= vdata->configItems.end(); ++it) {
for(QList<MainWindowItem*>::iterator it = configItems.begin(); it!= configItems.end(); ++it) {
MainWindowItem* item = *it;
item->deleteLater();
}
vdata->configItems.clear();
configItems.clear();
//QMessageBox::information(0, "Debug", "mw destructor 1");
//delete ui;
//QMessageBox::information(0, "Debug", "mw destructor 2");
@ -683,82 +678,53 @@ FileChooserItem* MainWindow::initFileChooser(ConfigOption option, QLineEdit* fil
FileChooserItem* retVal;
retVal=new FileChooserItem(option, fileNameLineEdit, fileBrowsePushButton, this, requireExistingFile, readOnly);
MainWindowItem* super=retVal;
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(super);
configItems.append(super);
return retVal;
}
void MainWindow::initFolderChooser(ConfigOption option, QLineEdit* folderLineEdit, QPushButton* folderBrowsePushButton){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new FolderChooserItem(option, folderLineEdit, folderBrowsePushButton, this, true));
configItems.append(new FolderChooserItem(option, folderLineEdit, folderBrowsePushButton, this, true));
}
/*void MainWindow::initCombobox(ConfigOption option, QComboBox* comboBox){
configItems.append(new ComboBoxItem(option, comboBox));
QObject::connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(saveAllConfigs()));
}*/
void MainWindow::initLogDestinationCombobox(ConfigOption option, QComboBox* comboBox){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new LogDestinationComboBoxItem(option, comboBox));
configItems.append(new LogDestinationComboBoxItem(option, comboBox));
}
void MainWindow::initLogLevelCombobox(ConfigOption option, QComboBox* comboBox){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new LogLevelComboBoxItem(option, comboBox));
configItems.append(new LogLevelComboBoxItem(option, comboBox));
}
void MainWindow::initSignatureTypeCombobox(ConfigOption option, QComboBox* comboBox){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new SignatureTypeComboBoxItem(option, comboBox));
configItems.append(new SignatureTypeComboBoxItem(option, comboBox));
}
void MainWindow::initIPAddressBox(ConfigOption option, QLineEdit* addressLineEdit, QString fieldNameTranslated){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new IPAddressStringItem(option, addressLineEdit, fieldNameTranslated, this));
configItems.append(new IPAddressStringItem(option, addressLineEdit, fieldNameTranslated, this));
}
void MainWindow::initTCPPortBox(ConfigOption option, QLineEdit* portLineEdit, QString fieldNameTranslated){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new TCPPortStringItem(option, portLineEdit, fieldNameTranslated, this));
configItems.append(new TCPPortStringItem(option, portLineEdit, fieldNameTranslated, this));
}
void MainWindow::initCheckBox(ConfigOption option, QCheckBox* checkBox) {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new CheckBoxItem(option, checkBox));
configItems.append(new CheckBoxItem(option, checkBox));
}
void MainWindow::initIntegerBox(ConfigOption option, QLineEdit* numberLineEdit, QString fieldNameTranslated){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new IntegerStringItem(option, numberLineEdit, fieldNameTranslated, this));
configItems.append(new IntegerStringItem(option, numberLineEdit, fieldNameTranslated, this));
}
void MainWindow::initUInt32Box(ConfigOption option, QLineEdit* numberLineEdit, QString fieldNameTranslated){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new UInt32StringItem(option, numberLineEdit, fieldNameTranslated, this));
configItems.append(new UInt32StringItem(option, numberLineEdit, fieldNameTranslated, this));
}
void MainWindow::initUInt16Box(ConfigOption option, QLineEdit* numberLineEdit, QString fieldNameTranslated){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new UInt16StringItem(option, numberLineEdit, fieldNameTranslated, this));
configItems.append(new UInt16StringItem(option, numberLineEdit, fieldNameTranslated, this));
}
void MainWindow::initStringBox(ConfigOption option, QLineEdit* lineEdit){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(new BaseStringItem(option, lineEdit, QString(), this));
configItems.append(new BaseStringItem(option, lineEdit, QString(), this));
}
NonGUIOptionItem* MainWindow::initNonGUIOption(ConfigOption option, TypeEnum optionValueType) {
NonGUIOptionItem* MainWindow::initNonGUIOption(ConfigOption option) {
NonGUIOptionItem * retValue;
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
vdata->configItems.append(retValue=new NonGUIOptionItem(option));
retValue->optionValueType=optionValueType;
configItems.append(retValue=new NonGUIOptionItem(option));
return retValue;
}
void MainWindow::loadAllConfigs(SaverImpl* saverPtr){
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
//BORROWED FROM ??? //TODO move this code into single location
std::string config; i2p::config::GetOption("conf", config);
@ -802,7 +768,7 @@ void MainWindow::loadAllConfigs(SaverImpl* saverPtr){
saverPtr->setConfPath(this->confpath);
saverPtr->setTunnelsConfPath(this->tunconfpath);
for(QList<MainWindowItem*>::iterator it = vdata->configItems.begin(); it!= vdata->configItems.end(); ++it) {
for(QList<MainWindowItem*>::iterator it = configItems.begin(); it!= configItems.end(); ++it) {
MainWindowItem* item = *it;
item->loadFromConfigOption();
}
@ -821,14 +787,12 @@ void MainWindow::DisableTunnelsPage() {
}
void MainWindow::layoutTunnels() {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
int height=0;
ui->tunnelsScrollAreaWidgetContents->setGeometry(0,0,0,0);
for(const auto& it : vdata->tunnelConfigs) {
//const std::string& name=it.first;
TunnelConfig* tunconf = it.second;
for(std::map<std::string, TunnelConfig*>::iterator it = tunnelConfigs.begin(); it != tunnelConfigs.end(); ++it) {
//const std::string& name=it->first;
TunnelConfig* tunconf = it->second;
TunnelPane * tunnelPane=tunconf->getTunnelPane();
if(!tunnelPane)continue;
int h=tunnelPane->height();
@ -844,12 +808,9 @@ void MainWindow::layoutTunnels() {
}
void MainWindow::deleteTunnelFromUI(std::string tunnelName, TunnelConfig* cnf) {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
TunnelPane* tp = cnf->getTunnelPane();
if(!tp)return;
vdata->tunnelPanes.remove(tp);
tunnelPanes.remove(tp);
tp->deleteWidget();
layoutTunnels();
}
@ -863,10 +824,7 @@ bool MainWindow::saveAllConfigs(bool reloadAfterSave, FocusEnum focusOn, std::st
daemonOption->optionValue=boost::any(false);
serviceOption->optionValue=boost::any(false);
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
for(QList<MainWindowItem*>::iterator it = vdata->configItems.begin(); it != vdata->configItems.end(); ++it) {
for(QList<MainWindowItem*>::iterator it = configItems.begin(); it!= configItems.end(); ++it) {
MainWindowItem* item = *it;
bool alreadyDisplayedIfWrong=false;
if(!item->isValid(alreadyDisplayedIfWrong)){
@ -925,39 +883,34 @@ void MainWindow::updated() {
void MainWindowItem::installListeners(MainWindow *mainWindow) {}
void MainWindow::appendTunnelForms(std::string tunnelNameToFocus) {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
ignoreUpdatesOnAppendForms = true;
int height=0;
ui->tunnelsScrollAreaWidgetContents->setGeometry(0,0,0,0);
std::unordered_map<std::string, TunnelConfig*> tunnelConfigsCopy(vdata->tunnelConfigs);
for(const auto& it : tunnelConfigsCopy) {
const std::string& name=it.first;
ServerTunnelConfig* stc = it.second->asServerTunnelConfig();
for(std::map<std::string, TunnelConfig*>::iterator it = tunnelConfigs.begin(); it != tunnelConfigs.end(); ++it) {
const std::string& name=it->first;
TunnelConfig* tunconf = it->second;
ServerTunnelConfig* stc = tunconf->asServerTunnelConfig();
if(stc){
ServerTunnelPane * tunnelPane=new ServerTunnelPane(&tunnelsPageUpdateListener, stc, ui->wrongInputLabel, ui->wrongInputLabel, this);
stc->setTunnelPane(tunnelPane);
int h=tunnelPane->appendServerTunnelForm(stc, ui->tunnelsScrollAreaWidgetContents, vdata->tunnelPanes.size(), height);
tunconf->setTunnelPane(tunnelPane);
int h=tunnelPane->appendServerTunnelForm(stc, ui->tunnelsScrollAreaWidgetContents, tunnelPanes.size(), height);
height+=h;
//qDebug() << "tun.height:" << height << "sz:" << tunnelPanes.size();
vdata->tunnelPanes.push_back(tunnelPane);
if(name.compare(tunnelNameToFocus)==0){
tunnelPanes.push_back(tunnelPane);
if(name==tunnelNameToFocus){
tunnelPane->getNameLineEdit()->setFocus();
ui->tunnelsScrollArea->ensureWidgetVisible(tunnelPane->getNameLineEdit());
}
continue;
}
ClientTunnelConfig* ctc = it.second->asClientTunnelConfig();
ClientTunnelConfig* ctc = tunconf->asClientTunnelConfig();
if(ctc){
ClientTunnelPane * tunnelPane=new ClientTunnelPane(&tunnelsPageUpdateListener, ctc, ui->wrongInputLabel, ui->wrongInputLabel, this);
ctc->setTunnelPane(tunnelPane);
int h=tunnelPane->appendClientTunnelForm(ctc, ui->tunnelsScrollAreaWidgetContents, vdata->tunnelPanes.size(), height);
tunconf->setTunnelPane(tunnelPane);
int h=tunnelPane->appendClientTunnelForm(ctc, ui->tunnelsScrollAreaWidgetContents, tunnelPanes.size(), height);
height+=h;
//qDebug() << "tun.height:" << height << "sz:" << tunnelPanes.size();
vdata->tunnelPanes.push_back(tunnelPane);
if(name.compare(tunnelNameToFocus)==0){
tunnelPanes.push_back(tunnelPane);
if(name==tunnelNameToFocus){
tunnelPane->getNameLineEdit()->setFocus();
ui->tunnelsScrollArea->ensureWidgetVisible(tunnelPane->getNameLineEdit());
}
@ -970,12 +923,9 @@ void MainWindow::appendTunnelForms(std::string tunnelNameToFocus) {
QList<QWidget*> childWidgets = ui->tunnelsScrollAreaWidgetContents->findChildren<QWidget*>();
foreach(QWidget* widget, childWidgets)
widget->show();
ignoreUpdatesOnAppendForms = false;
}
void MainWindow::deleteTunnelForms() {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
for(std::list<TunnelPane*>::iterator it = vdata->tunnelPanes.begin(); it != vdata->tunnelPanes.end(); ++it) {
for(std::list<TunnelPane*>::iterator it = tunnelPanes.begin(); it != tunnelPanes.end(); ++it) {
TunnelPane* tp = *it;
ServerTunnelPane* stp = tp->asServerTunnelPane();
if(stp){
@ -991,13 +941,11 @@ void MainWindow::deleteTunnelForms() {
}
throw "unknown TunnelPane subtype";
}
vdata->tunnelPanes.clear();
tunnelPanes.clear();
}
bool MainWindow::applyTunnelsUiToConfigs() {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
for(std::list<TunnelPane*>::iterator it = vdata->tunnelPanes.begin(); it != vdata->tunnelPanes.end(); ++it) {
for(std::list<TunnelPane*>::iterator it = tunnelPanes.begin(); it != tunnelPanes.end(); ++it) {
TunnelPane* tp = *it;
if(!tp->applyDataFromUIToTunnelConfig())return false;
}
@ -1009,32 +957,23 @@ void MainWindow::reloadTunnelsConfigAndUI_QString(QString tunnelNameToFocus) {
}
void MainWindow::reloadTunnelsConfigAndUI(std::string tunnelNameToFocus, QWidget* widgetToFocus) {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* vdata = volatileDataHolder->getData();
deleteTunnelForms();
const std::unordered_map<std::string, TunnelConfig*> tunnelConfigsCopy(vdata->tunnelConfigs);
for (const auto& it : tunnelConfigsCopy) {
TunnelConfig* tunconf = it.second;
vdata->tunnelConfigs[tunconf->getName()]=nullptr;
vdata->tunnelConfigsById[tunconf->get_TunnelId()]=nullptr;
for (std::map<std::string,TunnelConfig*>::iterator it=tunnelConfigs.begin(); it!=tunnelConfigs.end(); ++it) {
TunnelConfig* tunconf = it->second;
delete tunconf;
}
vdata->tunnelConfigs.clear();
vdata->tunnelConfigsById.clear();
tunnelConfigs.clear();
ReadTunnelsConfig();
appendTunnelForms(tunnelNameToFocus);
}
void MainWindow::TunnelsPageUpdateListenerMainWindowImpl::updated(std::string oldName, TunnelConfig* tunConf) {
MutexWrapperLock lock(mainWindow->volatileDataHolder->getMutex());
VolatileData* vdata = mainWindow->volatileDataHolder->getData();
if(mainWindow->ignoreUpdatesOnAppendForms)return;
if(oldName.compare(tunConf->getName())!=0) {
if(oldName!=tunConf->getName()) {
//name has changed
auto it=vdata->tunnelConfigs.find(oldName);
if(it!=vdata->tunnelConfigs.end())vdata->tunnelConfigs.erase(it);
vdata->tunnelConfigs[tunConf->getName()]=tunConf;
mainWindow->saveAllConfigs(false, FocusEnum::focusOnTunnelName, tunConf->getName());
std::map<std::string,TunnelConfig*>::const_iterator it=mainWindow->tunnelConfigs.find(oldName);
if(it!=mainWindow->tunnelConfigs.end())mainWindow->tunnelConfigs.erase(it);
mainWindow->tunnelConfigs[tunConf->getName()]=tunConf;
mainWindow->saveAllConfigs(true, FocusEnum::focusOnTunnelName, tunConf->getName());
}
else
mainWindow->saveAllConfigs(false, FocusEnum::noFocus);
@ -1213,18 +1152,3 @@ bool MainWindow::isPreventSaveTunnelsMode() {
void MainWindow::showTunnelsPagePreventedMessage() {
QMessageBox::critical(this,QObject::tr("Error"),QObject::tr("Not saving tunnels configuration due to previous errors with it."));
}
void MainWindow::DeleteTunnelNamed(std::string name) {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
auto it=tunnels->tunnelConfigs.find(name);
if(it!=tunnels->tunnelConfigs.end()){
TunnelConfig* tc=it->second;
deleteTunnelFromUI(name, tc);
tunnels->tunnelConfigs.erase(it);
tunnels->tunnelConfigsById.erase(tc->get_TunnelId());
delete tc;
}
saveAllConfigs(true, FocusEnum::noFocus);
delayedSaveManagerPtr->saveNow();
}

152
src/mainwindow.h
View File

@ -56,8 +56,7 @@
#include "TunnelsPageUpdateListener.h"
#include "controller/i2pd_daemon_controller.h"
#include "DaemonQT.h"
#include "SignatureTypeComboboxFactory.h"
#include "pagewithbackbutton.h"
@ -72,14 +71,11 @@
#include "I2pdQtUtil.h"
#include "ConcurrentHolder.h"
#include "MutexWrapperLock.h"
class SaverImpl;
class LogViewerManager;
/*template<typename ValueType>
template<typename ValueType>
bool isType(boost::any& a) {
return
#ifdef BOOST_AUX_ANY_TYPE_ID_NAME
@ -88,17 +84,7 @@ bool isType(boost::any& a) {
a.type() == typeid(ValueType)
#endif
;
}*/
enum TypeEnum {
type_unknown,
type_std_string,
type_bool,
type_uint16,
type_uint32,
type_int,
type_ushort
};
}
class ConfigOption {
public:
@ -131,7 +117,6 @@ public:
QString& getRequirementToBeValid() { return requirementToBeValid; }
ConfigOption& getConfigOption() { return option; }
boost::any optionValue;
TypeEnum optionValueType;
virtual ~MainWindowItem(){}
virtual void installListeners(MainWindow *mainWindow);
virtual void loadFromConfigOption(){
@ -141,43 +126,39 @@ public:
//qDebug() << "loadFromConfigOption[" << optName.c_str() << "]";
boost::any programOption;
i2p::config::GetOptionAsAny(optName, programOption);
if(programOption.empty()){
optionValue=boost::any(std::string(""));
optionValueType=type_std_string;
}else{
optionValue=boost::any_cast<boost::program_options::variable_value>(programOption).value();
}
optionValue=programOption.empty()?boost::any(std::string(""))
:boost::any_cast<boost::program_options::variable_value>(programOption).value();
}
virtual void saveToStringStream(std::stringstream& out){
if(readOnly)return; //should readOnly items (conf=) error somewhere, instead of silently skipping save?
if(optionValueType==type_std_string) {
const std::string v = boost::any_cast<std::string>(optionValue);
if(isType<std::string>(optionValue)) {
std::string v = boost::any_cast<std::string>(optionValue);
if(v.empty())return;
}
if(optionValue.empty())return;
//std::string rtti = optionValue.type().name();
std::string rtti = optionValue.type().name();
std::string optName="";
if(!option.section.isEmpty())optName=option.section.toStdString()+std::string(".");
optName+=std::string(option.option.toStdString());
optName+=option.option.toStdString();
//qDebug() << "Writing option" << optName.c_str() << "of type" << rtti.c_str();
std::string sectionAsStdStr = std::string(option.section.toStdString());
std::string sectionAsStdStr = option.section.toStdString();
if(!option.section.isEmpty() &&
sectionAsStdStr!=programOptionsWriterCurrentSection) {
out << "[" << sectionAsStdStr << "]\n";
programOptionsWriterCurrentSection=sectionAsStdStr;
}
out << std::string(option.option.toStdString()) << "=";
if(type_std_string==optionValueType) {
out << boost::any_cast<const std::string>(optionValue);
}else if(type_bool==optionValueType) {
out << option.option.toStdString() << "=";
if(isType<std::string>(optionValue)) {
out << boost::any_cast<std::string>(optionValue);
}else if(isType<bool>(optionValue)) {
out << (boost::any_cast<bool>(optionValue) ? "true" : "false");
}else if(type_uint16==optionValueType) {
}else if(isType<uint16_t>(optionValue)) {
out << boost::any_cast<uint16_t>(optionValue);
}else if(type_uint32==optionValueType) {
}else if(isType<uint32_t>(optionValue)) {
out << boost::any_cast<uint32_t>(optionValue);
}else if(type_int==optionValueType) {
}else if(isType<int>(optionValue)) {
out << boost::any_cast<int>(optionValue);
}else if(type_ushort==optionValueType) {
}else if(isType<unsigned short>(optionValue)) {
out << boost::any_cast<unsigned short>(optionValue);
}else out << boost::any_cast<std::string>(optionValue); //let it throw
out << "\n\n";
@ -213,11 +194,9 @@ public:
virtual void saveToStringStream(std::stringstream& out){
optionValue=fromString(lineEdit->text());
optionValueType=getOptionValueType();
MainWindowItem::saveToStringStream(out);
}
virtual bool isValid(bool & alreadyDisplayedIfWrong);
virtual TypeEnum getOptionValueType() {return type_std_string;}
};
class FileOrFolderChooserItem : public BaseStringItem {
protected:
@ -227,7 +206,6 @@ public:
FileOrFolderChooserItem(ConfigOption option_, QLineEdit* lineEdit_, QPushButton* browsePushButton_, MainWindow* mw, bool requireExistingFile_, bool readOnly) :
BaseStringItem(option_, lineEdit_, QString(), mw, readOnly), requireExistingFile(requireExistingFile_), browsePushButton(browsePushButton_) {}
virtual ~FileOrFolderChooserItem(){}
TypeEnum getOptionValueType() {return type_std_string;}
};
class FileChooserItem : public FileOrFolderChooserItem {
Q_OBJECT
@ -266,16 +244,15 @@ public:
virtual ~LogDestinationComboBoxItem(){}
virtual void loadFromConfigOption(){
MainWindowItem::loadFromConfigOption();
comboBox->setCurrentText(QString(boost::any_cast<std::string>(optionValue).c_str()));
const char * ld = boost::any_cast<std::string>(optionValue).c_str();
comboBox->setCurrentText(QString(ld));
}
virtual void saveToStringStream(std::stringstream& out){
const std::string logDest = std::string(comboBox->currentText().toStdString());
std::string logDest = comboBox->currentText().toStdString();
optionValue=logDest;
optionValueType=type_std_string;
MainWindowItem::saveToStringStream(out);
}
//virtual bool isValid(bool & alreadyDisplayedIfWrong) { return true; }
TypeEnum getOptionValueType() {return type_std_string;}
Q_OBJECT
};
@ -285,14 +262,13 @@ public:
virtual ~LogLevelComboBoxItem(){}
virtual void loadFromConfigOption(){
MainWindowItem::loadFromConfigOption();
comboBox->setCurrentText(QString(boost::any_cast<std::string>(optionValue).c_str()));
const char * ll = boost::any_cast<std::string>(optionValue).c_str();
comboBox->setCurrentText(QString(ll));
}
virtual void saveToStringStream(std::stringstream& out){
optionValue=comboBox->currentText().toStdString();
optionValueType=type_std_string;
MainWindowItem::saveToStringStream(out);
}
TypeEnum getOptionValueType() {return type_std_string;}
//virtual bool isValid(bool & alreadyDisplayedIfWrong) { return true; }
};
class SignatureTypeComboBoxItem : public ComboBoxItem {
@ -308,11 +284,9 @@ public:
virtual void saveToStringStream(std::stringstream& out){
uint16_t selected = SignatureTypeComboBoxFactory::getSigType(comboBox->currentData());
optionValue=(unsigned short)selected;
optionValueType=type_ushort;
MainWindowItem::saveToStringStream(out);
}
//virtual bool isValid(bool & alreadyDisplayedIfWrong) { return true; }
TypeEnum getOptionValueType() {return type_ushort;}
};
class CheckBoxItem : public MainWindowItem {
public:
@ -326,12 +300,10 @@ public:
checkBox->setChecked(boost::any_cast<bool>(optionValue));
}
virtual void saveToStringStream(std::stringstream& out){
optionValue=static_cast<bool>(checkBox->isChecked());
optionValueType=type_bool;
optionValue=checkBox->isChecked();
MainWindowItem::saveToStringStream(out);
}
//virtual bool isValid(bool & alreadyDisplayedIfWrong) { return true; }
TypeEnum getOptionValueType() {return type_bool;}
};
class BaseFormattedStringItem : public BaseStringItem {
public:
@ -340,7 +312,6 @@ public:
BaseStringItem(option_, lineEdit_, requirementToBeValid_, mw), fieldNameTranslated(fieldNameTranslated_) {}
virtual ~BaseFormattedStringItem(){}
//virtual bool isValid(bool & alreadyDisplayedIfWrong)=0;
TypeEnum getOptionValueType() {return type_std_string;}
};
class IntegerStringItem : public BaseFormattedStringItem {
public:
@ -358,7 +329,6 @@ public:
}
virtual QString toString(){return QString::number(boost::any_cast<int>(optionValue));}
virtual boost::any fromString(QString s){return boost::any(std::stoi(s.toStdString()));}
TypeEnum getOptionValueType() {return type_int;}
};
class UShortStringItem : public BaseFormattedStringItem {
public:
@ -376,7 +346,6 @@ public:
}
virtual QString toString(){return QString::number(boost::any_cast<unsigned short>(optionValue));}
virtual boost::any fromString(QString s){return boost::any((unsigned short)std::stoi(s.toStdString()));}
TypeEnum getOptionValueType() {return type_ushort;}
};
class UInt32StringItem : public BaseFormattedStringItem {
public:
@ -394,7 +363,6 @@ public:
}
virtual QString toString(){return QString::number(boost::any_cast<uint32_t>(optionValue));}
virtual boost::any fromString(QString s){return boost::any((uint32_t)std::stoi(s.toStdString()));}
TypeEnum getOptionValueType() {return type_uint32;}
};
class UInt16StringItem : public BaseFormattedStringItem {
public:
@ -412,14 +380,12 @@ public:
}
virtual QString toString(){return QString::number(boost::any_cast<uint16_t>(optionValue));}
virtual boost::any fromString(QString s){return boost::any((uint16_t)std::stoi(s.toStdString()));}
TypeEnum getOptionValueType() {return type_uint16;}
};
class IPAddressStringItem : public BaseFormattedStringItem {
public:
IPAddressStringItem(ConfigOption option_, QLineEdit* lineEdit_, QString fieldNameTranslated_, MainWindow* mw) :
BaseFormattedStringItem(option_, lineEdit_, fieldNameTranslated_, QApplication::tr("Must be an IPv4 address"), mw) {}
//virtual bool isValid(bool & alreadyDisplayedIfWrong){return true;}//todo
TypeEnum getOptionValueType() {return type_std_string;}
};
class TCPPortStringItem : public UShortStringItem {
public:
@ -561,6 +527,7 @@ protected:
QString getStatusPageHtml(bool showHiddenInfo);
QList<MainWindowItem*> configItems;
NonGUIOptionItem* daemonOption;
NonGUIOptionItem* serviceOption;
//LogDestinationComboBoxItem* logOption;
@ -579,7 +546,7 @@ protected:
void initUInt32Box(ConfigOption option, QLineEdit* numberLineEdit, QString fieldNameTranslated);
void initUInt16Box(ConfigOption option, QLineEdit* numberLineEdit, QString fieldNameTranslated);
void initStringBox(ConfigOption option, QLineEdit* lineEdit);
NonGUIOptionItem* initNonGUIOption(ConfigOption option, TypeEnum optionValueType);
NonGUIOptionItem* initNonGUIOption(ConfigOption option);
void loadAllConfigs(SaverImpl* saverPtr);
void layoutTunnels();
@ -604,20 +571,10 @@ private:
QString datadir;
QString confpath;
QString tunconfpath;
bool ignoreUpdatesOnAppendForms;
public:
struct VolatileData {
QList<MainWindowItem*> configItems;
std::unordered_map<std::string, TunnelConfig*> tunnelConfigs;
std::unordered_map<int, TunnelConfig*> tunnelConfigsById;
std::list<TunnelPane*> tunnelPanes;
VolatileData():configItems(), tunnelConfigs(), tunnelConfigsById(), tunnelPanes() {}
};
std::map<std::string, TunnelConfig*> tunnelConfigs;
std::list<TunnelPane*> tunnelPanes;
ConcurrentHolder<VolatileData*>* volatileDataHolder;
private:
void appendTunnelForms(std::string tunnelNameToFocus);
void deleteTunnelForms();
void deleteTunnelFromUI(std::string tunnelName, TunnelConfig* cnf);
@ -697,35 +654,30 @@ private:
param.set_i2p_streaming_initialAckDelay(QString::number(_i2p_streaming_initialAckDelay));
}
void DeleteTunnelNamed(std::string name);
void DeleteTunnelNamed(std::string name) {
std::map<std::string,TunnelConfig*>::const_iterator it=tunnelConfigs.find(name);
if(it!=tunnelConfigs.end()){
TunnelConfig* tc=it->second;
deleteTunnelFromUI(name, tc);
tunnelConfigs.erase(it);
delete tc;
}
saveAllConfigs(true, FocusEnum::noFocus);
}
std::string GenerateNewTunnelName() {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
int i=1;
while(true){
std::stringstream name;
name << "name" << i;
const std::string& str=name.str();
if(tunnels->tunnelConfigs.find(str)==tunnels->tunnelConfigs.end())return str;
++i;
}
}
int GenerateNewTunnelId() {
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
int i=1;
while(true){
if(tunnels->tunnelConfigsById.find(i)==tunnels->tunnelConfigsById.end())return i;
if(tunnelConfigs.find(str)==tunnelConfigs.end())return str;
++i;
}
}
void CreateDefaultClientTunnel() {//TODO dedup default values with ReadTunnelsConfig() and with ClientContext.cpp::ReadTunnels ()
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
int tunnelId=GenerateNewTunnelId();
std::string name=GenerateNewTunnelName();
std::string type = I2P_TUNNELS_SECTION_TYPE_CLIENT;
std::string dest = "127.0.0.1";
@ -739,9 +691,7 @@ private:
I2CPParameters i2cpParameters;
CreateDefaultI2CPOptions (i2cpParameters);
tunnels->tunnelConfigs[name]=tunnels->tunnelConfigsById[tunnelId]=new ClientTunnelConfig(
tunnelId,
name, QString(type.c_str()), i2cpParameters,
tunnelConfigs[name]=new ClientTunnelConfig(name, QString(type.c_str()), i2cpParameters,
dest,
port,
keys,
@ -751,13 +701,9 @@ private:
cryptoType);
saveAllConfigs(true, FocusEnum::focusOnTunnelName, name);
delayedSaveManagerPtr->saveNow();
}
void CreateDefaultServerTunnel() {//TODO dedup default values with ReadTunnelsConfig() and with ClientContext.cpp::ReadTunnels ()
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
int tunnelId=GenerateNewTunnelId();
std::string name=GenerateNewTunnelName();
std::string type=I2P_TUNNELS_SECTION_TYPE_SERVER;
std::string host = "127.0.0.1";
@ -777,9 +723,7 @@ private:
I2CPParameters i2cpParameters;
CreateDefaultI2CPOptions (i2cpParameters);
tunnels->tunnelConfigs[name]=tunnels->tunnelConfigsById[tunnelId]=new ServerTunnelConfig(
tunnelId,
name, QString(type.c_str()), i2cpParameters,
tunnelConfigs[name]=new ServerTunnelConfig(name, QString(type.c_str()), i2cpParameters,
host,
port,
keys,
@ -795,14 +739,10 @@ private:
saveAllConfigs(true, FocusEnum::focusOnTunnelName, name);
delayedSaveManagerPtr->saveNow();
}
void ReadTunnelsConfig() //TODO deduplicate the code with ClientContext.cpp::ReadTunnels ()
{
MutexWrapperLock lock(volatileDataHolder->getMutex());
VolatileData* tunnels = volatileDataHolder->getData();
boost::property_tree::ptree pt;
std::string tunConf=tunconfpath.toStdString();
if (tunConf == "") {
@ -857,10 +797,8 @@ private:
std::map<std::string, std::string> options;
I2CPParameters i2cpParameters;
ReadI2CPOptions (section, options, i2cpParameters);
int tunnelId=GenerateNewTunnelId();
tunnels->tunnelConfigs[name]=tunnels->tunnelConfigsById[tunnelId]=
new ClientTunnelConfig(tunnelId,name, QString(type.c_str()), i2cpParameters,
tunnelConfigs[name]=new ClientTunnelConfig(name, QString(type.c_str()), i2cpParameters,
dest,
port,
keys,
@ -893,7 +831,6 @@ private:
std::map<std::string, std::string> options;
I2CPParameters i2cpParameters;
ReadI2CPOptions (section, options, i2cpParameters);
int tunnelId=GenerateNewTunnelId();
/*
std::set<i2p::data::IdentHash> idents;
@ -911,8 +848,7 @@ private:
while (comma != std::string::npos);
}
*/
tunnels->tunnelConfigs[name]=tunnels->tunnelConfigsById[tunnelId]=
new ServerTunnelConfig(tunnelId,name, QString(type.c_str()), i2cpParameters,
tunnelConfigs[name]=new ServerTunnelConfig(name, QString(type.c_str()), i2cpParameters,
host,
port,
keys,