Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-12-29 01:16:20 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

finished removing latest Qt bits

Browse Source
This commit is contained in:
csoler 2021-12-06 22:08:56 +01:00
parent e75d312724
commit 7dc5c90d63
12 changed files with 125 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
libretroshare/src/tor/AddOnionCommand.cpp
View File

@ -40,7 +40,7 @@ using namespace Tor;
AddOnionCommand::AddOnionCommand(HiddenService *service)
: m_service(service)
{
Q_ASSERT(m_service);
assert(m_service);
}
bool AddOnionCommand::isSuccessful() const
@ -61,13 +61,14 @@ ByteArray AddOnionCommand::build()
out += " NEW:BEST"; // this is v3, but without control of key type. Generates a RSA1024 key on older Tor versions.
}
foreach (const HiddenService::Target &target, m_service->targets()) {
for(const HiddenService::Target& target: m_service->targets())
{
out += " Port=";
out += QByteArray::number(target.servicePort);
out += RsUtil::NumberToString(target.servicePort);
out += ",";
out += target.targetAddress;
out += ":";
out += QByteArray::number(target.targetPort);
out += RsUtil::NumberToString(target.targetPort);
}
out.append("\r\n");
@ -82,8 +83,8 @@ void AddOnionCommand::onReply(int statusCode, const ByteArray &data)
return;
}
const QByteArray keyPrefix("PrivateKey=");
const QByteArray sidPrefix("ServiceID=");
const ByteArray keyPrefix("PrivateKey=");
const ByteArray sidPrefix("ServiceID=");
if(data.startsWith("ServiceID=")){
ByteArray service_id = data.mid(sidPrefix.size());

6
libretroshare/src/tor/AddOnionCommand.h
View File

@ -30,8 +30,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ADDONIONCOMMAND_H
#define ADDONIONCOMMAND_H
#pragma once
#include "TorControlCommand.h"
@ -69,6 +68,3 @@ protected:
};
}
#endif // ADDONIONCOMMAND_H

9
libretroshare/src/tor/CryptoKey.h
View File

@ -30,12 +30,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CRYPTOKEY_H
#define CRYPTOKEY_H
#include <QString>
#include <QSharedData>
#include <QExplicitlySharedDataPointer>
#pragma once
#include "bytearray.h"
@ -67,5 +62,3 @@ private:
};
ByteArray torControlHashedPassword(const ByteArray &password);
#endif // CRYPTOKEY_H

2
libretroshare/src/tor/HiddenService.cpp
View File

@ -83,7 +83,7 @@ void HiddenService::addTarget(const Target &target)
m_targets.push_back(target);
}
void HiddenService::addTarget(quint16 servicePort, std::string targetAddress, quint16 targetPort)
void HiddenService::addTarget(uint16_t servicePort, std::string targetAddress, uint16_t targetPort)
{
Target t = { targetAddress, servicePort, targetPort };
m_targets.push_back(t);

18
libretroshare/src/tor/HiddenService.h
View File

@ -33,7 +33,6 @@
#ifndef HIDDENSERVICE_H
#define HIDDENSERVICE_H
#include <QObject>
#include "CryptoKey.h"
#include "bytearray.h"
@ -52,18 +51,15 @@ public:
virtual void hiddenServiceHostnameChanged() =0;
};
class HiddenService : public QObject
class HiddenService
{
Q_OBJECT
Q_DISABLE_COPY(HiddenService)
friend class TorControlPrivate;
friend class TorControl;
public:
struct Target
{
std::string targetAddress;
quint16 servicePort, targetPort;
uint16_t servicePort, targetPort;
};
enum Status
@ -89,9 +85,9 @@ public:
const std::list<Target> &targets() const { return m_targets; }
void addTarget(const Target &target);
void addTarget(quint16 servicePort, std::string targetAddress, quint16 targetPort);
void addTarget(uint16_t servicePort, std::string targetAddress, uint16_t targetPort);
private slots:
//private slots:
void servicePublished();
private:
@ -106,6 +102,10 @@ private:
void setStatus(Status newStatus);
HiddenServiceClient *m_client;
// make the object non copyable
HiddenService(const HiddenService& s) {}
HiddenService& operator=(const HiddenService& s) { return *this ; }
};
}

16
libretroshare/src/tor/PendingOperation.cpp
View File

@ -30,10 +30,11 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <assert.h>
#include "PendingOperation.h"
PendingOperation::PendingOperation(QObject *parent)
: QObject(parent), m_finished(false)
PendingOperation::PendingOperation()
: m_finished(false)
{
}
@ -65,20 +66,21 @@ void PendingOperation::finishWithError(const std::string &message)
if (!m_finished) {
m_finished = true;
emit finished();
emit error(m_errorMessage);
finished_callback();
error_callback(m_errorMessage);
}
}
void PendingOperation::finishWithSuccess()
{
Q_ASSERT(m_errorMessage.empty());
assert(m_errorMessage.empty());
if (!m_finished) {
m_finished = true;
emit finished();
finished_callback();
if (isSuccess())
emit success();
success_callback();
}
}

44
libretroshare/src/tor/PendingOperation.h
View File

@ -30,10 +30,9 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PENDINGOPERATION_H
#define PENDINGOPERATION_H
#pragma once
#include <QObject>
#include <functional>
/* Represents an asynchronous operation for reporting status
*
@ -48,40 +47,41 @@
* PendingOperation will emit finished() and one of success() or
* error() when completed.
*/
class PendingOperation : public QObject
class PendingOperation
{
Q_OBJECT
Q_PROPERTY(bool isFinished READ isFinished NOTIFY finished FINAL)
Q_PROPERTY(bool isSuccess READ isSuccess NOTIFY success FINAL)
Q_PROPERTY(bool isError READ isError NOTIFY error FINAL)
Q_PROPERTY(std::string errorMessage READ errorMessage NOTIFY finished FINAL)
// Q_PROPERTY(bool isFinished READ isFinished NOTIFY finished FINAL)
// Q_PROPERTY(bool isSuccess READ isSuccess NOTIFY success FINAL)
// Q_PROPERTY(bool isError READ isError NOTIFY error FINAL)
// Q_PROPERTY(std::string errorMessage READ errorMessage NOTIFY finished FINAL)
public:
PendingOperation(QObject *parent = 0);
PendingOperation();
bool isFinished() const;
bool isSuccess() const;
bool isError() const;
std::string errorMessage() const;
signals:
// Always emitted once when finished, regardless of status
void finished();
// signals:
// // Always emitted once when finished, regardless of status
// void finished();
//
// // One of error() or success() is emitted once
// void error(const std::string &errorMessage);
// void success();
// One of error() or success() is emitted once
void error(const std::string &errorMessage);
void success();
protected slots:
//protected slots:
void finishWithError(const std::string &errorMessage);
void finishWithSuccess();
void set_finished_callback(const std::function<void(void)>& f) { finished_callback = f; }
private:
bool m_finished;
std::string m_errorMessage;
std::function<void(void)> finished_callback;
std::function<void(void)> success_callback;
std::function<void(const std::string&)> error_callback;
};
Q_DECLARE_METATYPE(PendingOperation*)
#endif

2
libretroshare/src/tor/ProtocolInfoCommand.cpp
View File

@ -56,7 +56,7 @@ void ProtocolInfoCommand::onReply(int statusCode, const ByteArray &data)
{
std::list<ByteArray> tokens = splitQuotedStrings(data.mid(5), ' ');
foreach (ByteArray token, tokens)
for(ByteArray token: tokens)
{
if (token.startsWith("METHODS="))
{

92
libretroshare/src/tor/TorControl.cpp
View File

@ -81,7 +81,7 @@ namespace Tor {
// ByteArray authPassword;
// std::string socksAddress;
// QList<HiddenService*> services;
// quint16 controlPort, socksPort;
// uint16_t controlPort, socksPort;
// TorControl::Status status;
// TorControl::TorStatus torStatus;
// std::map<std::string,std::string> bootstrapStatus;
@ -177,14 +177,12 @@ void TorControl::setStatus(TorControl::Status n)
rsEvents->sendEvent(ev);
}
#ifdef TO_REMOVE
emit statusChanged(status, old);
mStatusChanged_callback(mStatus, old);
if (status == TorControl::Connected && old < TorControl::Connected)
emit connected();
else if (status < TorControl::Connected && old >= TorControl::Connected)
emit disconnected();
#endif
if (mStatus == TorControl::Connected && old < TorControl::Connected)
socketConnected();//mConnected_callback();
else if (mStatus < TorControl::Connected && old >= TorControl::Connected)
socketDisconnected();//mDisconnected_callback();
}
void TorControl::setTorStatus(TorControl::TorStatus n)
@ -194,10 +192,6 @@ void TorControl::setTorStatus(TorControl::TorStatus n)
TorControl::TorStatus old = mTorStatus;
mTorStatus = n;
#ifdef TO_REMOVE
emit torStatusChanged(torStatus, old);
emit connectivityChanged();
#endif
if(rsEvents)
{
@ -255,7 +249,7 @@ std::string TorControl::socksAddress() const
return mSocksAddress;
}
quint16 TorControl::socksPort() const
uint16_t TorControl::socksPort() const
{
return mSocksPort;
}
@ -275,7 +269,7 @@ void TorControl::setAuthPassword(const ByteArray &password)
mAuthPassword = password;
}
void TorControl::connect(const std::string &address, quint16 port)
void TorControl::connect(const std::string &address, uint16_t port)
{
if (status() > Connecting)
{
@ -306,9 +300,9 @@ void TorControl::reconnect()
mSocket->connectToHost(mTorAddress, mControlPort);
}
void TorControl::authenticateReply()
void TorControl::authenticateReply(TorControlCommand *sender)
{
AuthenticateCommand *command = qobject_cast<AuthenticateCommand*>(sender());
AuthenticateCommand *command = dynamic_cast<AuthenticateCommand*>(sender);
assert(command);
assert(mStatus == TorControl::Authenticating);
if (!command)
@ -384,17 +378,18 @@ void TorControl::protocolInfoReply(TorControlCommand *sender)
if (mStatus == TorControl::Authenticating)
{
AuthenticateCommand *auth = new AuthenticateCommand;
connect(auth, &TorControlCommand::finished, this, &TorControl::authenticateReply);
//connect(auth, &TorControlCommand::finished, this, &TorControl::authenticateReply);
auth->set_finished_callback( [this](TorControlCommand *sender) { authenticateReply(sender); });
ByteArray data;
ProtocolInfoCommand::AuthMethod methods = info->authMethods();
if (methods.testFlag(ProtocolInfoCommand::AuthNull))
if(methods & ProtocolInfoCommand::AuthNull)
{
torCtrlDebug() << "torctrl: Using null authentication" << std::endl;
data = auth->build();
}
else if (methods.testFlag(ProtocolInfoCommand::AuthCookie) && !info->cookieFile().empty())
else if ((methods & ProtocolInfoCommand::AuthCookie) && !info->cookieFile().empty())
{
std::string cookieFile = info->cookieFile();
std::string cookieError;
@ -425,7 +420,7 @@ void TorControl::protocolInfoReply(TorControlCommand *sender)
/* If we know a password and password authentication is allowed, try using that instead.
* This is a strange corner case that will likely never happen in a normal configuration,
* but it has happened. */
if (methods.testFlag(ProtocolInfoCommand::AuthHashedPassword) && !mAuthPassword.empty())
if ((methods & ProtocolInfoCommand::AuthHashedPassword) && !mAuthPassword.empty())
{
torCtrlDebug() << "torctrl: Unable to read authentication cookie file:" << cookieError << std::endl;
goto usePasswordAuth;
@ -436,7 +431,7 @@ void TorControl::protocolInfoReply(TorControlCommand *sender)
return;
}
}
else if (methods.testFlag(ProtocolInfoCommand::AuthHashedPassword) && !mAuthPassword.empty())
else if ((methods & ProtocolInfoCommand::AuthHashedPassword) && !mAuthPassword.empty())
{
usePasswordAuth:
torCtrlDebug() << "torctrl: Using hashed password authentication" << std::endl;
@ -444,7 +439,7 @@ void TorControl::protocolInfoReply(TorControlCommand *sender)
}
else
{
if (methods.testFlag(ProtocolInfoCommand::AuthHashedPassword))
if (methods & ProtocolInfoCommand::AuthHashedPassword)
setError("Tor requires a control password to connect, but no password is configured.");
else
setError("Tor is not configured to accept any supported authentication methods.");
@ -461,7 +456,8 @@ void TorControl::getTorInfo()
assert(isConnected());
GetConfCommand *command = new GetConfCommand(GetConfCommand::GetInfo);
connect(command, &TorControlCommand::finished, this, &TorControl::getTorInfoReply);
//connect(command, &TorControlCommand::finished, this, &TorControl::getTorInfoReply);
command->set_finished_callback( [this](TorControlCommand *sender) { getTorInfoReply(sender); });
std::list<std::string> keys{ "status/circuit-established","status/bootstrap-phase" };
@ -469,7 +465,7 @@ void TorControl::getTorInfo()
/* If these are set in the config, they override the automatic behavior. */
SettingsObject settings("tor");
QHostAddress forceAddress(settings.read("socksAddress").toString());
quint16 port = (quint16)settings.read("socksPort").toInt();
uint16_t port = (uint16_t)settings.read("socksPort").toInt();
if (!forceAddress.isNull() && port) {
torCtrlDebug() << "torctrl: Using manually specified SOCKS connection settings";
@ -491,9 +487,9 @@ void TorControl::getTorInfo()
mSocket->sendCommand(command, command->build(keys));
}
void TorControl::getTorInfoReply()
void TorControl::getTorInfoReply(TorControlCommand *sender)
{
GetConfCommand *command = qobject_cast<GetConfCommand*>(sender());
GetConfCommand *command = dynamic_cast<GetConfCommand*>(sender);
if (!command || !isConnected())
return;
@ -503,7 +499,7 @@ void TorControl::getTorInfoReply()
ByteArray value = unquotedString(add);
int sepp = value.indexOf(':');
std::string address(value.mid(0, sepp).toString());
quint16 port = (quint16)value.mid(sepp+1).toInt();
uint16_t port = (uint16_t)value.mid(sepp+1).toInt();
/* Use the first address that matches the one used for this control connection. If none do,
* just use the first address and rely on the user to reconfigure if necessary (not a problem;
@ -586,7 +582,8 @@ void TorControl::publishServices()
else
torCtrlDebug() << "torctrl: Publishing hidden service: " << service->hostname() << std::endl;
AddOnionCommand *onionCommand = new AddOnionCommand(service);
QObject::connect(onionCommand, &AddOnionCommand::succeeded, service, &HiddenService::servicePublished);
//protocolInfoReplyQObject::connect(onionCommand, &AddOnionCommand::succeeded, service, &HiddenService::servicePublished);
onionCommand->set_succeeded_callback( [service]() { service->servicePublished(); });
mSocket->sendCommand(onionCommand, onionCommand->build());
}
} else {
@ -618,7 +615,8 @@ void TorControl::publishServices()
torConfig.push_back(std::make_pair("HiddenServicePort", target));
}
QObject::connect(command, &SetConfCommand::setConfSucceeded, service, &HiddenService::servicePublished);
command->set_ConfSucceeded_callback( [service]() { service->servicePublished(); });
//QObject::connect(command, &SetConfCommand::setConfSucceeded, service, &HiddenService::servicePublished);
}
if (!torConfig.empty())
@ -650,10 +648,8 @@ void TorControl::shutdownSync()
mSocket->close();
}
void TorControl::statusEvent(int code, const ByteArray &data)
void TorControl::statusEvent(int /* code */, const ByteArray &data)
{
Q_UNUSED(code);
std::list<ByteArray> tokens = splitQuotedStrings(data.trimmed(), ' ');
if (tokens.size() < 3)
return;
@ -673,9 +669,9 @@ void TorControl::statusEvent(int code, const ByteArray &data)
void TorControl::updateBootstrap(const std::list<ByteArray> &data)
{
bootstrapStatus.clear();
mBootstrapStatus.clear();
// WARN or NOTICE
bootstrapStatus["severity"] = (*data.begin()).toString();
mBootstrapStatus["severity"] = (*data.begin()).toString();
auto dat = data.begin();
++dat;
@ -688,7 +684,7 @@ void TorControl::updateBootstrap(const std::list<ByteArray> &data)
if (equals >= 0)
value = unquotedString((*dat).mid(equals + 1));
bootstrapStatus[key.toLower().toString()] = value.toString();
mBootstrapStatus[key.toLower().toString()] = value.toString();
}
//torCtrlDebug() << bootstrapStatus << std::endl;
@ -702,7 +698,7 @@ void TorControl::updateBootstrap(const std::list<ByteArray> &data)
}
}
QObject *TorControl::getConfiguration(const std::string& options)
TorControlCommand *TorControl::getConfiguration(const std::string& options)
{
GetConfCommand *command = new GetConfCommand(GetConfCommand::GetConf);
mSocket->sendCommand(command, command->build(options));
@ -711,7 +707,7 @@ QObject *TorControl::getConfiguration(const std::string& options)
return command;
}
QObject *TorControl::setConfiguration(const std::list<std::pair<std::string,std::string> >& options)
TorControlCommand *TorControl::setConfiguration(const std::list<std::pair<std::string,std::string> >& options)
{
SetConfCommand *command = new SetConfCommand;
command->setResetMode(true);
@ -725,27 +721,25 @@ namespace Tor {
class SaveConfigOperation : public PendingOperation
{
Q_OBJECT
public:
SaveConfigOperation(QObject *parent)
: PendingOperation(parent), command(0)
SaveConfigOperation()
: PendingOperation(), command(0)
{
}
void start(TorControlSocket *socket)
{
Q_ASSERT(!command);
assert(!command);
command = new GetConfCommand(GetConfCommand::GetInfo);
QObject::connect(command, &TorControlCommand::finished, this, &SaveConfigOperation::configTextReply);
//QObject::connect(command, &TorControlCommand::finished, this, &SaveConfigOperation::configTextReply);
command->set_finished_callback([this](TorControlCommand *sender){ configTextReply(sender); });
socket->sendCommand(command, command->build(std::list<std::string> { "config-text" , "config-file" } ));
}
private slots:
void configTextReply()
void configTextReply(TorControlCommand * /*sender*/)
{
Q_ASSERT(command);
assert(command);
if (!command)
return;
@ -823,8 +817,10 @@ PendingOperation *TorControl::saveConfiguration()
return 0;
}
SaveConfigOperation *operation = new SaveConfigOperation(this);
QObject::connect(operation, &PendingOperation::finished, operation, &QObject::deleteLater);
SaveConfigOperation *operation = new SaveConfigOperation();
//QObject::connect(operation, &PendingOperation::finished, operation, &QObject::deleteLater);
operation->set_finished_callback( [operation]() { delete operation; });
operation->start(mSocket);
//QQmlEngine::setObjectOwnership(operation, QQmlEngine::CppOwnership);

24
libretroshare/src/tor/TorControl.h
View File

@ -39,7 +39,6 @@
#include "bytearray.h"
#include "TorControlSocket.h"
class QNetworkProxy;
namespace Tor
{
@ -91,15 +90,14 @@ public:
bool hasConnectivity() const;
std::string socksAddress() const;
quint16 socksPort() const;
QNetworkProxy connectionProxy();
uint16_t socksPort() const;
/* Authentication */
void setAuthPassword(const ByteArray& password);
/* Connection */
bool isConnected() const { return status() == Connected; }
void connect(const std::string &address, quint16 port);
void connect(const std::string &address, uint16_t port);
/* Ownership means that tor is managed by this socket, and we
* can shut it down, own its configuration, etc. */
@ -111,8 +109,8 @@ public:
void addHiddenService(HiddenService *service);
std::map<std::string, std::string> bootstrapStatus() const;
/*Q_INVOKABLE*/ QObject *getConfiguration(const std::string &options);
/*Q_INVOKABLE*/ QObject *setConfiguration(const std::list<std::pair<std::string, std::string> > &options);
/*Q_INVOKABLE*/ TorControlCommand *getConfiguration(const std::string &options);
/*Q_INVOKABLE*/ TorControlCommand *setConfiguration(const std::list<std::pair<std::string, std::string> > &options);
/*Q_INVOKABLE*/ PendingOperation *saveConfiguration();
//signals:
@ -124,6 +122,10 @@ public:
// void bootstrapStatusChanged();
// void hasOwnershipChanged();
void set_statusChanged_callback(const std::function<void(int,int)>& f) { mStatusChanged_callback = f ;}
void set_connected_callback(const std::function<void(void)>& f) { mConnected_callback = f ;}
void set_disconnected_callback(const std::function<void(void)>& f) { mDisconnected_callback = f ;}
virtual void socketError(const std::string &s) override;
//public slots:
@ -142,14 +144,14 @@ private:
ByteArray mAuthPassword;
std::string mSocksAddress;
std::list<HiddenService*> mServices;
quint16 mControlPort, mSocksPort;
uint16_t mControlPort, mSocksPort;
TorControl::Status mStatus;
TorControl::TorStatus mTorStatus;
std::map<std::string,std::string> mBootstrapStatus;
bool mHasOwnership;
void getTorInfo();
void getTorInfoReply();
void getTorInfoReply(TorControlCommand *sender);
void setStatus(TorControl::Status n);
void statusEvent(int code, const ByteArray &data);
void setTorStatus(TorControl::TorStatus n);
@ -159,7 +161,11 @@ private:
void protocolInfoReply(TorControlCommand *sender);
void socketDisconnected();
void socketConnected();
void authenticateReply();
void authenticateReply(TorControlCommand *sender);
std::function<void(int,int)> mStatusChanged_callback;
std::function<void(void)> mConnected_callback;
std::function<void(void)> mDisconnected_callback;
};
}

37
libretroshare/src/tor/TorManager.cpp
View File

@ -44,29 +44,20 @@
#include "util/rsdir.h"
#include "retroshare/rsinit.h"
#include <QObject>
#include "TorManager.h"
#include "TorProcess.h"
#include "TorControl.h"
#include "CryptoKey.h"
#include "HiddenService.h"
#include "GetConfCommand.h"
#include <QFile>
#include <QDir>
#include <QCoreApplication>
#include <QTcpServer>
#include <QTextStream>
using namespace Tor;
namespace Tor
{
class TorManagerPrivate : public QObject, public TorProcessClient
class TorManagerPrivate : public TorProcessClient
{
Q_OBJECT
public:
TorManager *q;
TorProcess *process;
@ -91,9 +82,9 @@ public:
virtual void processErrorChanged(const std::string &errorMessage) override;
virtual void processLogMessage(const std::string &message) override;
public slots:
//public slots:
void controlStatusChanged(int status);
void getConfFinished();
void getConfFinished(TorControlCommand *sender);
};
}
@ -104,14 +95,14 @@ TorManager::TorManager()
}
TorManagerPrivate::TorManagerPrivate(TorManager *parent)
: QObject(nullptr)
, q(parent)
: q(parent)
, process(0)
, control(new TorControl(this))
, control(new TorControl())
, configNeeded(false)
, hiddenService(NULL)
{
connect(control, SIGNAL(statusChanged(int,int)), SLOT(controlStatusChanged(int)));
//connect(control, SIGNAL(statusChanged(int,int)), SLOT(controlStatusChanged(int)));
control->set_statusChanged_callback([this](int new_status,int /*old_status*/) { controlStatusChanged(new_status); });
}
TorManager *TorManager::instance()
@ -178,12 +169,12 @@ bool TorManager::setupHiddenService()
std::cerr << "Using legacy dir: " << legacyDir << std::endl;
if (!legacyDir.empty() && QFile::exists(legacyDir.c_str() + QLatin1String("/private_key")))
if (!legacyDir.empty() && RsDirUtil::fileExists(RsDirUtil::makePath(legacyDir,"/private_key")))
{
std::cerr << "Attempting to load key from legacy filesystem format in " << legacyDir << std::endl;
CryptoKey key;
if (!key.loadFromFile(legacyDir + "/private_key"))
if (!key.loadFromFile(RsDirUtil::makePath(legacyDir , "/private_key")))
{
RsWarn() << "Cannot load legacy format key from" << legacyDir << "for conversion";
return false;
@ -417,7 +408,7 @@ bool TorManager::getProxyServerInfo(std::string& proxy_server_adress,uint16_t& p
bool TorManager::getHiddenServiceInfo(std::string& service_id,std::string& service_onion_address,uint16_t& service_port, std::string& service_target_address,uint16_t& target_port)
{
QList<Tor::HiddenService*> hidden_services = control()->hiddenServices();
auto hidden_services = control()->hiddenServices();
if(hidden_services.empty())
return false ;
@ -471,8 +462,8 @@ void TorManagerPrivate::controlStatusChanged(int status)
if (status == TorControl::Connected) {
if (!configNeeded) {
// If DisableNetwork is 1, trigger configurationNeeded
connect(control->getConfiguration("DisableNetwork"),
SIGNAL(finished()), SLOT(getConfFinished()));
auto cmd = control->getConfiguration("DisableNetwork");
cmd->set_finished_callback( [this](TorControlCommand *sender) { getConfFinished(sender) ; });
}
if (process) {
@ -482,9 +473,9 @@ void TorManagerPrivate::controlStatusChanged(int status)
}
}
void TorManagerPrivate::getConfFinished()
void TorManagerPrivate::getConfFinished(TorControlCommand *sender)
{
GetConfCommand *command = qobject_cast<GetConfCommand*>(sender());
GetConfCommand *command = dynamic_cast<GetConfCommand*>(sender);
if (!command)
return;

1
libretroshare/src/tor/bytearray.h
View File

@ -49,6 +49,7 @@ public:
return res;
}
bool endsWith(const ByteArray& b) const { return size() >= b.size() && !memcmp(&data()[size()-b.size()],b.data(),b.size()); }
bool startsWith(const ByteArray& b) const { return b.size() <= size() && !strncmp((char*)b.data(),(char*)data(),std::min(size(),b.size())); }
bool startsWith(const char *b) const
{
for(uint32_t n=0;b[n]!=0;++n)