diff options
| -rw-r--r-- | service-quasselcore/patches/net-irc/quassel/quassel-bind-host.patch | 116 |
1 files changed, 116 insertions, 0 deletions
diff --git a/service-quasselcore/patches/net-irc/quassel/quassel-bind-host.patch b/service-quasselcore/patches/net-irc/quassel/quassel-bind-host.patch new file mode 100644 index 0000000..2bf8726 --- /dev/null +++ b/service-quasselcore/patches/net-irc/quassel/quassel-bind-host.patch @@ -0,0 +1,116 @@ +diff --git a/src/common/main.cpp b/src/common/main.cpp +index 0ee13ecd..2df950a0 100644 +--- a/src/common/main.cpp ++++ b/src/common/main.cpp +@@ -185,6 +185,7 @@ int main(int argc, char **argv) + #ifndef BUILD_QTUI + // put core-only arguments here + cliParser->addOption("listen", 0, "The address(es) quasselcore will listen on", "<address>[,<address>[,...]]", "::,0.0.0.0"); ++ cliParser->addOption("bind-host", 0, "The address quasselcore will make outgoing connections from.", "address", ""); + cliParser->addOption("port", 'p', "The port quasselcore will listen at", "port", "4242"); + cliParser->addSwitch("norestore", 'n', "Don't restore last core's state"); + cliParser->addSwitch("config-from-environment", 0, "Load configuration from environment variables"); +diff --git a/src/core/corenetwork.cpp b/src/core/corenetwork.cpp +index fa8ae9bf..af335e1f 100644 +--- a/src/core/corenetwork.cpp ++++ b/src/core/corenetwork.cpp +@@ -22,6 +22,7 @@ + + #include <QDebug> + #include <QHostInfo> ++#include <QHostAddress> + + #include "core.h" + #include "coreidentity.h" +@@ -244,6 +245,76 @@ void CoreNetwork::connectToIrc(bool reconnecting) + displayStatusMsg(tr("Connecting to %1:%2...").arg(server.host).arg(server.port)); + displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Connecting to %1:%2...").arg(server.host).arg(server.port)); + ++ QHostInfo targetinfo; ++ ++ // Qt caches DNS entries for a minute, resulting in round-robin (e.g. for chat.freenode.net) not working if several users ++ // connect at a similar time. QHostInfo::fromName(), however, always performs a fresh lookup, overwriting the cache entry. ++ if (! server.useProxy) { ++ //Avoid hostname lookups when a proxy is specified. The lookups won't use the proxy and may therefore leak the DNS ++ //hostname of the server. Qt's DNS cache also isn't used by the proxy so we don't need to refresh the entry. ++ //TODO: don't do this twice if bind-host is set ++ targetinfo = QHostInfo::fromName(server.host); ++ } else if (Quassel::isOptionSet("bind-host")) { ++ qWarning() << tr("bind-host not supported if proxy is set"); ++ } ++ ++ if (!server.useProxy && Quassel::isOptionSet("bind-host")) { ++ QHostAddress hostaddr = QHostAddress(); ++ QString bindaddr = Quassel::optionValue("bind-host"); ++ ++ QHostInfo bindinfo = QHostInfo::fromName(bindaddr); ++ ++ if (bindinfo.error() != QHostInfo::NoError) { ++ qWarning() << qPrintable(tr("Could not look up bind host \"%1\": %2").arg(bindaddr).arg(bindinfo.errorString())); ++ } else if (targetinfo.error() != QHostInfo::NoError) { ++ qWarning() << qPrintable(tr("Could not look up server host %1").arg(targetinfo.errorString())); ++ } else { ++ QHostAddress baddr4 = QHostAddress(); ++ QHostAddress baddr6 = QHostAddress(); ++ for (int i = 0; i < bindinfo.addresses().size(); i++) { ++ if (!baddr4.isNull() && !baddr6.isNull()) { ++ break; ++ } ++ if (baddr4.isNull() && bindinfo.addresses()[i].protocol() == QAbstractSocket::IPv4Protocol) { ++ baddr4 = bindinfo.addresses()[i]; ++ } ++ if (baddr6.isNull() && bindinfo.addresses()[i].protocol() == QAbstractSocket::IPv6Protocol) { ++ baddr6 = bindinfo.addresses()[i]; ++ } ++ } ++ ++ QHostAddress taddr4 = QHostAddress(); ++ QHostAddress taddr6 = QHostAddress(); ++ for (int i = 0; i < targetinfo.addresses().size(); i++) { ++ if (!taddr4.isNull() && !taddr6.isNull()) { ++ break; ++ } ++ if (taddr4.isNull() && targetinfo.addresses()[i].protocol() == QAbstractSocket::IPv4Protocol) { ++ taddr4 = targetinfo.addresses()[i]; ++ } ++ if (taddr6.isNull() && targetinfo.addresses()[i].protocol() == QAbstractSocket::IPv6Protocol) { ++ taddr6 = targetinfo.addresses()[i]; ++ } ++ } ++ ++ QHostAddress bind = QHostAddress(); ++ if (!baddr6.isNull() && !taddr6.isNull()) { ++ bind = baddr6; ++ } else if (!baddr4.isNull() && !taddr4.isNull()) { ++ bind = baddr4; ++ } else { ++ qWarning() << tr("Mismatched bind-host and server family."); ++ } ++ ++ if (!bind.isNull()) { ++ qWarning() << qPrintable(tr("Binding to %1").arg(bind.toString())); ++ if (!socket.bind(bind)) { ++ qWarning() << qPrintable(tr("Could not bind to %1").arg(bind.toString())); ++ } ++ } ++ } ++ } ++ + if (server.useProxy) { + QNetworkProxy proxy((QNetworkProxy::ProxyType)server.proxyType, server.proxyHost, server.proxyPort, server.proxyUser, server.proxyPass); + socket.setProxy(proxy); +@@ -256,14 +327,6 @@ void CoreNetwork::connectToIrc(bool reconnecting) + + // Reset tracking for valid timestamps in PONG replies + setPongTimestampValid(false); +- +- // Qt caches DNS entries for a minute, resulting in round-robin (e.g. for chat.freenode.net) not working if several users +- // connect at a similar time. QHostInfo::fromName(), however, always performs a fresh lookup, overwriting the cache entry. +- if (! server.useProxy) { +- //Avoid hostname lookups when a proxy is specified. The lookups won't use the proxy and may therefore leak the DNS +- //hostname of the server. Qt's DNS cache also isn't used by the proxy so we don't need to refresh the entry. +- QHostInfo::fromName(server.host); +- } + #ifdef HAVE_SSL + if (server.useSsl) { + CoreIdentity *identity = identityPtr(); |