Commit cbb7f575 authored by Martin Flöser's avatar Martin Flöser
Browse files

Improved resolving whether a window is on local machine

Most windows use the hostname in WM_CLIENT_MACHINE, but there are windows
using the FQDN (for example libreoffice). So instead of "foo" it is
"foo.local.net" or similar. The logic so far has been unable to properly
determine whether windows with FQDN are on the local system.

In order to solve this problem the handling is split out into an own
class which stores the information of hostname and whether it is a local
machine. This is to not query multiple times. To determine whether the
Client is on the local system getaddrinfo is used for the own hostname
and the FQDN provided in WM_CLIENT_MACHINE. If one of the queried
names matches, we know that it is on the local machine. The old logic to
compare the hostname is still used and getaddrinfo is only a fallback in
case hostname does not match.

The problem with getaddrinfo is, that it accesses the network and by that
could block. To circumvent this problem the calls are moved into threads
by using QtConcurrent::run.

Obviously this brings disadvantages. When trying to resolve whether a
Client is on the local machine and a FQDN is used, the information is
initially wrong. The new ClientMachine class emits a signal when the
information that the system is local becomes available, but for some
things this is just too late:
* window rules are already gathered
* Session Management has already taken place

In both cases this is an acceptable loss. For window rules it just needs
a proper matching of the machine in case of localhost (remote hosts are
not affected). And the case of session management is very academic as it
is unlikely that a restoring session contains remote windows.

BUG: 308391
FIXED-IN: 4.11
REVIEW: 108235
parent 7dfc8c1d
......@@ -93,6 +93,7 @@ set(kwin_KDEINIT_SRCS
workspace.cpp
dbusinterface.cpp
client.cpp
client_machine.cpp
tabgroup.cpp
placement.cpp
atoms.cpp
......
......@@ -41,6 +41,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <signal.h>
#include "bridge.h"
#include "client_machine.h"
#include "composite.h"
#include "group.h"
#include "workspace.h"
......@@ -211,6 +212,8 @@ Client::Client(Workspace* ws)
connect(this, SIGNAL(clientStartUserMovedResized(KWin::Client*)), SIGNAL(moveResizedChanged()));
connect(this, SIGNAL(clientFinishUserMovedResized(KWin::Client*)), SIGNAL(moveResizedChanged()));
connect(clientMachine(), SIGNAL(localhostChanged()), SLOT(updateCaption()));
// SELI TODO: Initialize xsizehints??
}
......@@ -1373,21 +1376,20 @@ void Client::killProcess(bool ask, Time timestamp)
if (m_killHelperPID && !::kill(m_killHelperPID, 0)) // means the process is alive
return;
Q_ASSERT(!ask || timestamp != CurrentTime);
QByteArray machine = wmClientMachine(true);
pid_t pid = info->pid();
if (pid <= 0 || machine.isEmpty()) // Needed properties missing
if (pid <= 0 || clientMachine()->hostName().isEmpty()) // Needed properties missing
return;
kDebug(1212) << "Kill process:" << pid << "(" << machine << ")";
kDebug(1212) << "Kill process:" << pid << "(" << clientMachine()->hostName() << ")";
if (!ask) {
if (machine != "localhost") {
if (!clientMachine()->isLocal()) {
QStringList lst;
lst << machine << "kill" << QString::number(pid);
lst << clientMachine()->hostName() << "kill" << QString::number(pid);
QProcess::startDetached("xon", lst);
} else
::kill(pid, SIGTERM);
} else {
QProcess::startDetached(KStandardDirs::findExe("kwin_killer_helper"),
QStringList() << "--pid" << QByteArray().setNum(unsigned(pid)) << "--hostname" << machine
QStringList() << "--pid" << QByteArray().setNum(unsigned(pid)) << "--hostname" << clientMachine()->hostName()
<< "--windowname" << caption()
<< "--applicationname" << resourceClass()
<< "--wid" << QString::number(window())
......@@ -1774,8 +1776,8 @@ void Client::setCaption(const QString& _s, bool force)
cap_suffix.clear();
QString machine_suffix;
if (!options->condensedTitle()) { // machine doesn't qualify for "clean"
if (wmClientMachine(false) != "localhost" && !isLocalMachine(wmClientMachine(false)))
machine_suffix = QString(" <@") + wmClientMachine(true) + '>' + LRM;
if (clientMachine()->hostName() != ClientMachine::localhost() && !clientMachine()->isLocal())
machine_suffix = QString(" <@") + clientMachine()->hostName() + '>' + LRM;
}
QString shortcut_suffix = !shortcut().isEmpty() ? (" {" + shortcut().toString() + '}') : QString();
cap_suffix = machine_suffix + shortcut_suffix;
......
......@@ -499,7 +499,6 @@ public:
void updateCompositeBlocking(bool readProperty = false);
QString caption(bool full = true, bool stripped = false) const;
void updateCaption();
void keyPressEvent(uint key_code); // FRAME ??
void updateMouseGrab();
......@@ -654,6 +653,7 @@ public:
public slots:
void closeWindow();
void updateCaption();
private slots:
void autoRaise();
......
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
// own
#include "client_machine.h"
// KWin
#include "utils.h"
// KDE
#include <KDE/KDebug>
// Qt
#include <QtConcurrentRun>
#include <QFutureWatcher>
// system
#include <unistd.h>
#include <netdb.h>
namespace KWin {
static QByteArray getHostName()
{
#ifdef HOST_NAME_MAX
char hostnamebuf[HOST_NAME_MAX];
#else
char hostnamebuf[256];
#endif
if (gethostname(hostnamebuf, sizeof hostnamebuf) >= 0) {
hostnamebuf[sizeof(hostnamebuf)-1] = 0;
return QByteArray(hostnamebuf);
}
return QByteArray();
}
GetAddrInfo::GetAddrInfo(const QByteArray &hostName, QObject *parent)
: QObject(parent)
, m_resolving(false)
, m_resolved(false)
, m_ownResolved(false)
, m_hostName(hostName)
, m_addressHints(new addrinfo)
, m_address(NULL)
, m_ownAddress(NULL)
, m_watcher(new QFutureWatcher<int>(this))
, m_ownAddressWatcher(new QFutureWatcher<int>(this))
{
// watcher will be deleted together with the GetAddrInfo once the future
// got canceled or finished
connect(m_watcher, SIGNAL(canceled()), SLOT(deleteLater()));
connect(m_watcher, SIGNAL(finished()), SLOT(slotResolved()));
connect(m_ownAddressWatcher, SIGNAL(canceled()), SLOT(deleteLater()));
connect(m_ownAddressWatcher, SIGNAL(finished()), SLOT(slotOwnAddressResolved()));
}
GetAddrInfo::~GetAddrInfo()
{
if (m_watcher && m_watcher->isRunning()) {
m_watcher->cancel();
}
if (m_ownAddressWatcher && m_ownAddressWatcher->isRunning()) {
m_ownAddressWatcher->cancel();
}
if (m_address) {
freeaddrinfo(m_address);
}
if (m_ownAddress) {
freeaddrinfo(m_ownAddress);
}
delete m_addressHints;
}
void GetAddrInfo::resolve()
{
if (m_resolving) {
return;
}
m_resolving = true;
memset(m_addressHints, 0, sizeof(*m_addressHints));
m_addressHints->ai_family = PF_UNSPEC;
m_addressHints->ai_socktype = SOCK_STREAM;
m_addressHints->ai_flags |= AI_CANONNAME;
// TODO: C++11 nullptr
const char* nullPtr = NULL;
m_watcher->setFuture(QtConcurrent::run(getaddrinfo, m_hostName, nullPtr, m_addressHints, &m_address));
m_ownAddressWatcher->setFuture(QtConcurrent::run(getaddrinfo, getHostName(), nullPtr, m_addressHints, &m_ownAddress));
}
void GetAddrInfo::slotResolved()
{
if (resolved(m_watcher)) {
m_resolved = true;
compare();
}
}
void GetAddrInfo::slotOwnAddressResolved()
{
if (resolved(m_ownAddressWatcher)) {
m_ownResolved = true;
compare();
}
}
bool GetAddrInfo::resolved(QFutureWatcher< int >* watcher)
{
if (!watcher->isFinished()) {
return false;
}
if (watcher->result() != 0) {
kDebug(1212) << "getaddrinfo failed with error:" << gai_strerror(watcher->result());
// call failed;
deleteLater();
return false;
}
return true;
}
void GetAddrInfo::compare()
{
if (!m_resolved || !m_ownResolved) {
return;
}
addrinfo *address = m_address;
while (address) {
if (address->ai_canonname && m_hostName == QByteArray(address->ai_canonname).toLower()) {
addrinfo *ownAddress = m_ownAddress;
bool localFound = false;
while (ownAddress) {
if (ownAddress->ai_canonname && QByteArray(ownAddress->ai_canonname).toLower() == m_hostName) {
localFound = true;
break;
}
ownAddress = ownAddress->ai_next;
}
if (localFound) {
emit local();
break;
}
}
address = address->ai_next;
}
deleteLater();
}
ClientMachine::ClientMachine(QObject *parent)
: QObject(parent)
, m_localhost(false)
, m_resolved(false)
, m_resolving(false)
{
}
ClientMachine::~ClientMachine()
{
}
void ClientMachine::resolve(xcb_window_t window, xcb_window_t clientLeader)
{
if (m_resolved) {
return;
}
QByteArray name = getStringProperty(window, XCB_ATOM_WM_CLIENT_MACHINE);
if (name.isEmpty() && clientLeader && clientLeader != window) {
name = getStringProperty(clientLeader, XCB_ATOM_WM_CLIENT_MACHINE);
}
if (name.isEmpty()) {
name = localhost();
}
if (name == localhost()) {
setLocal();
}
m_hostName = name;
checkForLocalhost();
m_resolved = true;
}
void ClientMachine::checkForLocalhost()
{
if (isLocal()) {
// nothing to do
return;
}
QByteArray host = getHostName();
if (!host.isEmpty()) {
host = host.toLower();
const QByteArray lowerHostName(m_hostName.toLower());
if (host == lowerHostName) {
setLocal();
return;
}
if (char *dot = strchr(host.data(), '.')) {
*dot = '\0';
if (host == lowerHostName) {
setLocal();
return;
}
} else {
m_resolving = true;
// check using information from get addr info
// GetAddrInfo gets automatically destroyed once it finished or not
GetAddrInfo *info = new GetAddrInfo(lowerHostName, this);
connect(info, SIGNAL(local()), SLOT(setLocal()));
connect(info, SIGNAL(destroyed(QObject*)), SLOT(resolveFinished()));
info->resolve();
}
}
}
void ClientMachine::setLocal()
{
m_localhost = true;
emit localhostChanged();
}
void ClientMachine::resolveFinished()
{
m_resolving = false;
}
} // namespace
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_CLIENT_MACHINE_H
#define KWIN_CLIENT_MACHINE_H
#include <QObject>
#include <xcb/xcb.h>
// forward declaration
struct addrinfo;
template <typename T>
class QFutureWatcher;
namespace KWin {
class GetAddrInfo : public QObject
{
Q_OBJECT
public:
explicit GetAddrInfo(const QByteArray &hostName, QObject *parent = NULL);
virtual ~GetAddrInfo();
void resolve();
Q_SIGNALS:
void local();
private Q_SLOTS:
void slotResolved();
void slotOwnAddressResolved();
private:
void compare();
bool resolved(QFutureWatcher<int> *watcher);
bool m_resolving;
bool m_resolved;
bool m_ownResolved;
QByteArray m_hostName;
addrinfo *m_addressHints;
addrinfo *m_address;
addrinfo *m_ownAddress;
QFutureWatcher<int> *m_watcher;
QFutureWatcher<int> *m_ownAddressWatcher;
};
class ClientMachine : public QObject
{
Q_OBJECT
public:
explicit ClientMachine(QObject *parent = NULL);
virtual ~ClientMachine();
void resolve(xcb_window_t window, xcb_window_t clientLeader);
const QByteArray &hostName() const;
bool isLocal() const;
static QByteArray localhost();
bool isResolving() const;
Q_SIGNALS:
void localhostChanged();
private Q_SLOTS:
void setLocal();
void resolveFinished();
private:
void checkForLocalhost();
QByteArray m_hostName;
bool m_localhost;
bool m_resolved;
bool m_resolving;
};
inline
bool ClientMachine::isLocal() const
{
return m_localhost;
}
inline
const QByteArray &ClientMachine::hostName() const
{
return m_hostName;
}
inline
QByteArray ClientMachine::localhost()
{
return "localhost";
}
inline
bool ClientMachine::isResolving() const
{
return m_resolving;
}
} // namespace
#endif
ADD_DEFINITIONS(-DKCMRULES)
########### next target ###############
set (kwinrules_MOC_HDRS yesnobox.h)
set (kwinrules_MOC_HDRS yesnobox.h ../../client_machine.h)
qt4_wrap_cpp(kwinrules_MOC_SRCS ${kwinrules_MOC_HDRS})
set(kwinrules_SRCS ruleswidget.cpp ruleslist.cpp kwinsrc.cpp detectwidget.cpp ${kwinrules_MOC_SRCS})
......
......@@ -24,3 +24,4 @@
#include "../../placement.cpp"
#include "../../options.cpp"
#include "../../utils.cpp"
#include "../../client_machine.cpp"
......@@ -27,6 +27,7 @@
#include "ruleswidget.h"
#include "../../rules.h"
#include "../../client_machine.h"
#include <QByteArray>
namespace KWin
......@@ -72,6 +73,8 @@ static Rules* findRule(const QList< Rules* >& rules, Window wid, bool whole_app)
NET::WM2WindowClass | NET::WM2WindowRole | NET::WM2ClientMachine);
if (!info.valid()) // shouldn't really happen
return NULL;
ClientMachine clientMachine;
clientMachine.resolve(info.win(), info.groupLeader());
QByteArray wmclass_class = info.windowClassClass().toLower();
QByteArray wmclass_name = info.windowClassName().toLower();
QByteArray role = info.windowRole().toLower();
......@@ -79,7 +82,7 @@ static Rules* findRule(const QList< Rules* >& rules, Window wid, bool whole_app)
| NET::ToolbarMask | NET::MenuMask | NET::DialogMask | NET::OverrideMask | NET::TopMenuMask
| NET::UtilityMask | NET::SplashMask);
QString title = info.name();
QByteArray machine = info.clientMachine().toLower();
QByteArray machine = clientMachine.hostName();
Rules* best_match = NULL;
int match_quality = 0;
for (QList< Rules* >::ConstIterator it = rules.constBegin();
......@@ -126,7 +129,7 @@ static Rules* findRule(const QList< Rules* >& rules, Window wid, bool whole_app)
if (!rule->matchType(type)
|| !rule->matchRole(role)
|| !rule->matchTitle(title)
|| !rule->matchClientMachine(machine))
|| !rule->matchClientMachine(machine, clientMachine.isLocal()))
continue;
if (quality > match_quality) {
best_match = rule;
......
......@@ -30,6 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef KCMRULES
#include <QDesktopWidget>
#include "client.h"
#include "client_machine.h"
#include "workspace.h"
#endif
......@@ -394,12 +395,12 @@ bool Rules::matchTitle(const QString& match_title) const
return true;
}
bool Rules::matchClientMachine(const QByteArray& match_machine) const
bool Rules::matchClientMachine(const QByteArray& match_machine, bool local) const
{
if (clientmachinematch != UnimportantMatch) {
// if it's localhost, check also "localhost" before checking hostname
if (match_machine != "localhost" && isLocalMachine(match_machine)
&& matchClientMachine("localhost"))
if (match_machine != "localhost" && local
&& matchClientMachine("localhost", true))
return true;
if (clientmachinematch == RegExpMatch
&& QRegExp(clientmachine).indexIn(match_machine) == -1)
......@@ -425,7 +426,7 @@ bool Rules::match(const Client* c) const
return false;
if (!matchTitle(c->caption(false)))
return false;
if (!matchClientMachine(c->wmClientMachine(false)))
if (!matchClientMachine(c->clientMachine()->hostName(), c->clientMachine()->isLocal()))
return false;
return true;
}
......
......@@ -160,7 +160,7 @@ private:
bool matchWMClass(const QByteArray& match_class, const QByteArray& match_name) const;
bool matchRole(const QByteArray& match_role) const;
bool matchTitle(const QString& match_title) const;
bool matchClientMachine(const QByteArray& match_machine) const;
bool matchClientMachine(const QByteArray& match_machine, bool local) const;
// All these values are saved to the cfg file, and are also used in kstart!
enum {
Unused = 0,
......
......@@ -33,3 +33,20 @@ target_link_libraries( testVirtualDesktops
${QT_QTCORE_LIBRARY}
${QT_QTTEST_LIBRARY}
)
########################################################
# Test ClientMachine
########################################################
set( testClientMachine_SRCS
test_client_machine.cpp
../client_machine.cpp
)
kde4_add_unit_test( testClientMachine TESTNAME kwin-TestClientMachine ${testClientMachine_SRCS} )
target_link_libraries( testClientMachine
${QT_QTTEST_LIBRARY}
${QT_QTCORE_LIBRARY}
${KDE4_KDEUI_LIBS}
${XCB_XCB_LIBRARIES}
${X11_XCB_LIBRARIES}
)
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
// KWin
#include "../client_machine.h"
#include "../utils.h"
// Qt
#include <QApplication>
#include <QtTest/QtTest>
// xcb
#include <xcb/xcb.h>
// system
#include <unistd.h>
#include <netdb.h>
namespace KWin {
// mock required function from utils
QByteArray getStringProperty(WId w, Atom prop, char separator)
{
Q_UNUSED(separator)
ScopedCPointer<xcb_get_property_reply_t> property(xcb_get_property_reply(connection(),
xcb_get_property_unchecked(connection(), false, w, prop, XCB_ATOM_STRING, 0, 10000),
NULL));
if (property.isNull()) {
return QByteArray();
}
void *data = xcb_get_property_value(property.data());
if (data && property->value_len > 0) {
QByteArray result = QByteArray((const char*) data, property->value_len);
return result;
}
return QByteArray();
}
}
using namespace KWin;
class TestClientMachine : public QObject
{
Q_OBJECT
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void hostName_data();
void hostName();
void emptyHostName();
private:
xcb_window_t createWindow();