diff options
Diffstat (limited to 'kdesktop/lockeng.cpp')
| -rw-r--r-- | kdesktop/lockeng.cpp | 1004 |
1 files changed, 1004 insertions, 0 deletions
diff --git a/kdesktop/lockeng.cpp b/kdesktop/lockeng.cpp new file mode 100644 index 000000000..f02e51440 --- /dev/null +++ b/kdesktop/lockeng.cpp @@ -0,0 +1,1004 @@ +//=========================================================================== +// +// This file is part of the TDE project +// +// Copyright (c) 1999 Martin R. Jones <mjones@kde.org> +// Copyright (c) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net> +// + + +#include <config.h> + +#include <stdlib.h> +#include <sys/stat.h> + +#include <ksslcertificate.h> + +#include <tdehardwaredevices.h> +#include <tdecryptographiccarddevice.h> + +#include <kstandarddirs.h> +#include <tdeapplication.h> +#include <kservicegroup.h> +#include <ksimpleconfig.h> +#include <kdebug.h> +#include <kuser.h> +#include <tdelocale.h> +#include <tqfile.h> +#include <tqtimer.h> +#include <tqeventloop.h> +#include <dcopclient.h> +#include <assert.h> + +#include <dmctl.h> + +#include <dbus/dbus-shared.h> +#include <tqdbusdata.h> +#include <tqdbuserror.h> +#include <tqdbusmessage.h> +#include <tqdbusobjectpath.h> +#include <tqdbusproxy.h> + +#include "lockeng.h" +#include "lockeng.moc" +#include "kdesktopsettings.h" + +#define SYSTEMD_LOGIN1_SERVICE "org.freedesktop.login1" +#define SYSTEMD_LOGIN1_PATH "/org/freedesktop/login1" +#define SYSTEMD_LOGIN1_MANAGER_IFACE "org.freedesktop.login1.Manager" +#define SYSTEMD_LOGIN1_SESSION_IFACE "org.freedesktop.login1.Session" +#define SYSTEMD_LOGIN1_SEAT_IFACE "org.freedesktop.login1.Seat" + +#define DBUS_CONN_NAME "kdesktop_lock" + +#include "xautolock_c.h" +extern xautolock_corner_t xautolock_corners[ 4 ]; + +bool trinity_lockeng_sak_available = TRUE; + +SaverEngine* m_masterSaverEngine = NULL; +static void sigusr1_handler(int) +{ + if (m_masterSaverEngine) { + m_masterSaverEngine->m_threadHelperObject->slotLockProcessWaiting(); + } +} +static void sigusr2_handler(int) +{ + if (m_masterSaverEngine) { + m_masterSaverEngine->m_threadHelperObject->slotLockProcessFullyActivated(); + } +} +static void sigttin_handler(int) +{ + if (m_masterSaverEngine) { + m_masterSaverEngine->slotLockProcessReady(); + } +} + +//=========================================================================== +// +// Screen saver engine. Doesn't handle the actual screensaver window, +// starting screensaver hacks, or password entry. That's done by +// a newly started process. +// +SaverEngine::SaverEngine() + : TQWidget(), + KScreensaverIface(), + mBlankOnly(false), + mSAKProcess(NULL), + mTerminationRequested(false), + mSaverProcessReady(false), + mNewVTAfterLockEngage(false), + mValidCryptoCardInserted(false), + mSwitchVTAfterLockEngage(-1), + dBusLocal(0), + dBusWatch(0), + systemdSession(0) +{ + // handle SIGUSR1 + m_masterSaverEngine = this; + mSignalAction.sa_handler= sigusr1_handler; + sigemptyset(&(mSignalAction.sa_mask)); + sigaddset(&(mSignalAction.sa_mask), SIGUSR1); + mSignalAction.sa_flags = 0; + sigaction(SIGUSR1, &mSignalAction, 0L); + + // handle SIGUSR2 + m_masterSaverEngine = this; + mSignalAction.sa_handler= sigusr2_handler; + sigemptyset(&(mSignalAction.sa_mask)); + sigaddset(&(mSignalAction.sa_mask), SIGUSR2); + mSignalAction.sa_flags = 0; + sigaction(SIGUSR2, &mSignalAction, 0L); + + // handle SIGTTIN + m_masterSaverEngine = this; + mSignalAction.sa_handler= sigttin_handler; + sigemptyset(&(mSignalAction.sa_mask)); + sigaddset(&(mSignalAction.sa_mask), SIGTTIN); + mSignalAction.sa_flags = 0; + sigaction(SIGTTIN, &mSignalAction, 0L); + + // Save X screensaver parameters + XGetScreenSaver(tqt_xdisplay(), &mXTimeout, &mXInterval, + &mXBlanking, &mXExposures); + + mState = Waiting; + mXAutoLock = 0; + mEnabled = false; + + m_helperThread = new TQEventLoopThread; + m_helperThread->start(); + m_threadHelperObject = new SaverEngineThreadHelperObject; + m_threadHelperObject->moveToThread(m_helperThread); + connect(this, TQT_SIGNAL(terminateHelperThread()), m_threadHelperObject, TQT_SLOT(terminateThread())); + connect(m_threadHelperObject, TQT_SIGNAL(lockProcessWaiting()), this, TQT_SLOT(lockProcessWaiting())); + connect(m_threadHelperObject, TQT_SIGNAL(lockProcessFullyActivated()), this, TQT_SLOT(lockProcessFullyActivated())); + + connect(&mLockProcess, TQT_SIGNAL(processExited(TDEProcess *)), + TQT_SLOT(lockProcessExited())); + + configure(); + + // Create SAK process only if SAK is enabled + KSimpleConfig *config; + struct stat st; + if (stat( KDE_CONFDIR "/tdm/tdmdistrc" , &st) == 0) { + config = new KSimpleConfig( TQString::fromLatin1( KDE_CONFDIR "/tdm/tdmdistrc" )); + } + else { + config = new KSimpleConfig( TQString::fromLatin1( KDE_CONFDIR "/tdm/tdmrc" )); + } + config->setGroup("X-:*-Greeter"); + bool useSAKProcess = false; +#ifdef BUILD_TSAK + useSAKProcess = config->readBoolEntry("UseSAK", false) && KDesktopSettings::useTDESAK(); +#endif + if (useSAKProcess) { + mSAKProcess = new TDEProcess; + *mSAKProcess << "tdmtsak"; + connect(mSAKProcess, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotSAKProcessExited())); + TQTimer::singleShot( 0, this, TQT_SLOT(handleSecureDialog()) ); + } + + mLockProcess.clearArguments(); + TQString path = TDEStandardDirs::findExe( "kdesktop_lock" ); + if( path.isEmpty()) + { + kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl; + } + mLockProcess << path; + mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid()); + if (mLockProcess.start() == false ) + { + kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl; + } + + // Prevent kdesktop_lock signals from being handled by the wrong (GUI) thread + sigemptyset(&mThreadBlockSet); + sigaddset(&mThreadBlockSet, SIGUSR1); + sigaddset(&mThreadBlockSet, SIGUSR2); + sigaddset(&mThreadBlockSet, SIGTTIN); + pthread_sigmask(SIG_BLOCK, &mThreadBlockSet, NULL); + + // Wait for the saver process to signal ready... + if (!waitForLockProcessStart()) { + kdDebug( 1204 ) << "Failed to initialize kdesktop_lock (unexpected termination)!" << endl; + } + + // lock the desktop if required + config->setGroup("X-:0-Core"); + bool autoLoginEnable = config->readBoolEntry("AutoLoginEnable", false); + bool autoLoginLocked = config->readBoolEntry("AutoLoginLocked", false); + if (autoLoginEnable && autoLoginLocked) { + mLockProcess.kill(SIGTTOU); + mLockProcess.kill(SIGUSR1); + } + delete config; + config = NULL; + + // Initialize SmartCard readers + TDEGenericDevice *hwdevice; + TDEHardwareDevices *hwdevices = TDEGlobal::hardwareDevices(); + TDEGenericHardwareList cardReaderList = hwdevices->listByDeviceClass(TDEGenericDeviceType::CryptographicCard); + for (hwdevice = cardReaderList.first(); hwdevice; hwdevice = cardReaderList.next()) { + TDECryptographicCardDevice* cdevice = static_cast<TDECryptographicCardDevice*>(hwdevice); + connect(cdevice, TQT_SIGNAL(certificateListAvailable(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardInserted(TDECryptographicCardDevice*))); + connect(cdevice, TQT_SIGNAL(cardRemoved(TDECryptographicCardDevice*)), this, TQT_SLOT(cryptographicCardRemoved(TDECryptographicCardDevice*))); + cdevice->enableCardMonitoring(true); + } + + // Check card login status + KUser userinfo; + TQString fileName = userinfo.homeDir() + "/.tde_card_login_state"; + TQFile flagFile(fileName); + if (flagFile.open(IO_ReadOnly)) { + TQTextStream stream(&flagFile); + if (stream.readLine().startsWith("1")) { + // Card was likely used to log in + TQTimer::singleShot(5000, this, SLOT(cardStartupTimeout())); + } + flagFile.close(); + } + + dBusConnect(); +} + +//--------------------------------------------------------------------------- +// +// Destructor - usual cleanups. +// +SaverEngine::~SaverEngine() +{ + if (mState == Waiting) { + kill(mLockProcess.pid(), SIGKILL); + } + + mLockProcess.detach(); // don't kill it if we crash + delete mXAutoLock; + + dBusClose(); + + // Restore X screensaver parameters + XSetScreenSaver(tqt_xdisplay(), mXTimeout, mXInterval, mXBlanking, + mXExposures); + + terminateHelperThread(); + m_helperThread->wait(); + delete m_threadHelperObject; + delete m_helperThread; +} + +void SaverEngine::cardStartupTimeout() { + if (!mValidCryptoCardInserted) { + // Restore saver timeout + configure(); + + // Force lock + lockScreen(); + } +} + +void SaverEngine::cryptographicCardInserted(TDECryptographicCardDevice* cdevice) { + TQString login_name = TQString::null; + X509CertificatePtrList certList = cdevice->cardX509Certificates(); + if (certList.count() > 0) { + KSSLCertificate* card_cert = NULL; + card_cert = KSSLCertificate::fromX509(certList[0]); + TQStringList cert_subject_parts = TQStringList::split("/", card_cert->getSubject(), false); + for (TQStringList::Iterator it = cert_subject_parts.begin(); it != cert_subject_parts.end(); ++it ) { + TQString lcpart = (*it).lower(); + if (lcpart.startsWith("cn=")) { + login_name = lcpart.right(lcpart.length() - strlen("cn=")); + } + } + delete card_cert; + } + + if (login_name != "") { + KUser user; + if (login_name == user.loginName()) { + mValidCryptoCardInserted = true; + } + } +} + +void SaverEngine::cryptographicCardRemoved(TDECryptographicCardDevice* cdevice) { + if (mValidCryptoCardInserted) { + mValidCryptoCardInserted = false; + + // Restore saver timeout + configure(); + + // Force lock + lockScreen(); + } +} + +//--------------------------------------------------------------------------- +// +// This should be called only using DCOP. +// +void SaverEngine::lock() +{ + lockScreen(true); +} + +//--------------------------------------------------------------------------- +// +// Lock the screen +// +void SaverEngine::lockScreen(bool DCOP) +{ + if (mValidCryptoCardInserted) { + return; + } + + bool ok = true; + if (mState == Waiting) + { + ok = startLockProcess( ForceLock ); + // It takes a while for kdesktop_lock to start and lock the screen. + // Therefore delay the DCOP call until it tells kdesktop that the locking is in effect. + // This is done only for --forcelock . + if( ok && mState != Saving ) + { + if (DCOP) { + DCOPClientTransaction* trans = kapp->dcopClient()->beginTransaction(); + if (trans) { + mLockTransactions.append( trans ); + } + } + } + } + else + { + mLockProcess.kill( SIGHUP ); + } +} + +void SaverEngine::processLockTransactions() +{ + for( TQValueVector< DCOPClientTransaction* >::ConstIterator it = mLockTransactions.begin(); + it != mLockTransactions.end(); + ++it ) + { + TQCString replyType = "void"; + TQByteArray arr; + kapp->dcopClient()->endTransaction( *it, replyType, arr ); + } + mLockTransactions.clear(); +} + +void SaverEngine::saverLockReady() +{ + if( mState != Engaging ) + { + kdDebug( 1204 ) << "Got unexpected saverReady()" << endl; + } + kdDebug( 1204 ) << "Saver Lock Ready" << endl; + processLockTransactions(); +} + +//--------------------------------------------------------------------------- +void SaverEngine::save() +{ + if (!mValidCryptoCardInserted) { + if (mState == Waiting) { + startLockProcess( DefaultLock ); + } + } +} + +//--------------------------------------------------------------------------- +void SaverEngine::quit() +{ + if (mState == Saving || mState == Engaging) + { + stopLockProcess(); + } +} + +//--------------------------------------------------------------------------- +bool SaverEngine::isEnabled() +{ + return mEnabled; +} + +//--------------------------------------------------------------------------- +bool SaverEngine::enable( bool e ) +{ + if ( e == mEnabled ) + return true; + + // If we aren't in a suitable state, we will not reconfigure. + if (mState != Waiting) + return false; + + mEnabled = e; + + if (mEnabled) { + if ( !mXAutoLock ) { + mXAutoLock = new XAutoLock(); + connect(mXAutoLock, TQT_SIGNAL(timeout()), TQT_SLOT(idleTimeout())); + } + mXAutoLock->setTimeout(mTimeout); + mXAutoLock->setDPMS(true); + //mXAutoLock->changeCornerLockStatus( mLockCornerTopLeft, mLockCornerTopRight, mLockCornerBottomLeft, mLockCornerBottomRight); + + // We'll handle blanking + XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures); + kdDebug() << "XSetScreenSaver " << mTimeout + 10 << endl; + + mXAutoLock->start(); + + kdDebug(1204) << "Saver Engine started, timeout: " << mTimeout << endl; + } + else { + if (mXAutoLock) { + delete mXAutoLock; + mXAutoLock = 0; + } + + XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); + XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures); + kdDebug(1204) << "Saver Engine disabled" << endl; + } + + return true; +} + +//--------------------------------------------------------------------------- +bool SaverEngine::isBlanked() +{ + return (mState != Waiting); +} + +void SaverEngine::enableExports() +{ +#ifdef Q_WS_X11 + kdDebug(270) << k_lineinfo << "activating background exports.\n"; + DCOPClient *client = kapp->dcopClient(); + if (!client->isAttached()) { + client->attach(); + } + TQByteArray data; + TQDataStream args( data, IO_WriteOnly ); + args << 1; + + TQCString appname( "kdesktop" ); + int screen_number = DefaultScreen(tqt_xdisplay()); + if ( screen_number ) { + appname.sprintf("kdesktop-screen-%d", screen_number ); + } + + client->send( appname, "KBackgroundIface", "setExport(int)", data ); +#endif +} + +//--------------------------------------------------------------------------- +void SaverEngine::handleSecureDialog() +{ + // Wait for SAK press + if (mSAKProcess && !mSAKProcess->isRunning()) { + mSAKProcess->start(); + } +} + +void SaverEngine::slotSAKProcessExited() +{ + if (!mSAKProcess) { + printf("[kdesktop] SAK process does not exist. Something went wrong. Ignoring...\n"); fflush(stdout); + return; + } + int retcode = mSAKProcess->exitStatus(); + if ((retcode != 0) && (mSAKProcess->normalExit())) { + trinity_lockeng_sak_available = FALSE; + printf("[kdesktop] SAK driven secure dialog is not available for use (retcode %d). Check tdmtsak for proper functionality.\n", retcode); fflush(stdout); + } + + if (mState == Preparing) { + return; + } + + if ((mSAKProcess->normalExit()) && (trinity_lockeng_sak_available == TRUE)) { + bool ok = true; + if (mState == Waiting) + { + ok = startLockProcess( SecureDialog ); + if( ok && mState != Saving ) + { + } + } + else + { + mLockProcess.kill( SIGHUP ); + } + } +} + +//--------------------------------------------------------------------------- +// +// Read and apply configuration. +// +void SaverEngine::configure() +{ + // If we aren't in a suitable state, we will not reconfigure. + if (mState != Waiting) { + return; + } + + // create a new config obj to ensure we read the latest options + KDesktopSettings::self()->readConfig(); + + bool e = KDesktopSettings::screenSaverEnabled(); + mTimeout = KDesktopSettings::timeout(); + + mEnabled = !e; // force the enable() + + int action; + action = KDesktopSettings::actionTopLeft(); + xautolock_corners[0] = applyManualSettings(action); + action = KDesktopSettings::actionTopRight(); + xautolock_corners[1] = applyManualSettings(action); + action = KDesktopSettings::actionBottomLeft(); + xautolock_corners[2] = applyManualSettings(action); + action = KDesktopSettings::actionBottomRight(); + xautolock_corners[3] = applyManualSettings(action); + + enable( e ); +} + +//--------------------------------------------------------------------------- +// +// Set a variable to indicate only using the blanker and not the saver. +// +void SaverEngine::setBlankOnly( bool blankOnly ) +{ + mBlankOnly = blankOnly; + // FIXME: if running, stop and restart? What about security + // implications of this? +} + +bool SaverEngine::restartDesktopLockProcess() +{ + if (!mLockProcess.isRunning()) { + mSaverProcessReady = false; + mLockProcess.clearArguments(); + TQString path = TDEStandardDirs::findExe( "kdesktop_lock" ); + if (path.isEmpty()) { + kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl; + return false; + } + mLockProcess << path; + mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid()); + if (mLockProcess.start() == false) { + kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl; + return false; + } + // Wait for the saver process to signal ready... + if (!waitForLockProcessStart()) { + kdDebug( 1204 ) << "Failed to initialize kdesktop_lock (unexpected termination)!" << endl; + return false; + } + } + return true; +} + +//--------------------------------------------------------------------------- +// +// Start the screen saver. +// +bool SaverEngine::startLockProcess( LockType lock_type ) +{ + int ret; + + if (mState == Saving) { + return true; + } + + mState = Preparing; + if (mSAKProcess) { + mSAKProcess->kill(SIGTERM); + } + + enableExports(); + + kdDebug(1204) << "SaverEngine: starting saver" << endl; + emitDCOPSignal("KDE_start_screensaver()", TQByteArray()); + + if (!restartDesktopLockProcess()) { + mState = Waiting; + return false; + } + + switch( lock_type ) + { + case ForceLock: + mLockProcess.kill(SIGUSR1); // Request forcelock + break; + case DontLock: + mLockProcess.kill(SIGUSR2); // Request dontlock + break; + case SecureDialog: + mLockProcess.kill(SIGWINCH); // Request secure dialog + break; + default: + break; + } + if (mBlankOnly) { + mLockProcess.kill(SIGTTIN); // Request blanking + } + + ret = mLockProcess.kill(SIGTTOU); // Start lock + if (!ret) { + mState = Waiting; + return false; + } + XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, mXExposures); + + mState = Engaging; + if (mXAutoLock) { + mXAutoLock->stop(); + } + return true; +} + +//--------------------------------------------------------------------------- +// +// Stop the screen saver. +// +void SaverEngine::stopLockProcess() +{ + if (mState == Waiting) { + kdWarning(1204) << "SaverEngine::stopSaver() saver not active" << endl; + return; + } + kdDebug(1204) << "SaverEngine: stopping lock" << endl; + emitDCOPSignal("KDE_stop_screensaver()", TQByteArray()); + + mTerminationRequested = true; + mLockProcess.kill(); + + if (mEnabled) { + if (mXAutoLock) { + mXAutoLock->start(); + } + XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); + XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures); + } + processLockTransactions(); + mState = Waiting; + + if( systemdSession && systemdSession->canSend() ) { + TQValueList<TQT_DBusData> params; + params << TQT_DBusData::fromBool(false); + TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params); + } +} + +void SaverEngine::recoverFromHackingAttempt() +{ + // Try to relaunch saver with forcelock + if (!startLockProcess(ForceLock)) { + // Terminate the TDE session ASAP! + // Values are explained at http://lists.kde.org/?l=kde-linux&m=115770988603387 + TQByteArray data; + TQDataStream arg(data, IO_WriteOnly); + arg << (int)0 << (int)0 << (int)2; + if (!kapp->dcopClient()->send("ksmserver", "default", "logout(int,int,int)", data)) { + // Someone got to DCOP before we did + // Try an emergency system logout + system("logout"); + } + } +} + +void SaverEngine::lockProcessExited() +{ + bool abnormalExit = false; + if (mLockProcess.normalExit() == false) { + abnormalExit = true; + } + else { + if (mLockProcess.exitStatus() != 0) { + abnormalExit = true; + } + } + if (mTerminationRequested == true) { + abnormalExit = false; + mTerminationRequested = false; + } + if (abnormalExit == true) { + // PROBABLE HACKING ATTEMPT DETECTED + restartDesktopLockProcess(); + mState = Waiting; + TQTimer::singleShot( 100, this, SLOT(recoverFromHackingAttempt()) ); + } + else { + // Restart the lock process + restartDesktopLockProcess(); + } +} + +void SaverEngineThreadHelperObject::slotLockProcessWaiting() +{ + // lockProcessWaiting cannot be called directly from a signal handler, as it will hang in certain obscure circumstances + // Instead we use a single-shot timer to immediately call lockProcessWaiting once control has returned to the Qt main loop + lockProcessWaiting(); +} + +void SaverEngineThreadHelperObject::slotLockProcessFullyActivated() +{ + lockProcessFullyActivated(); +} + +void SaverEngine::lockProcessFullyActivated() +{ + mState = Saving; + + if( systemdSession && systemdSession->canSend() ) { + TQValueList<TQT_DBusData> params; + params << TQT_DBusData::fromBool(true); + TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params); + } + + if (mNewVTAfterLockEngage) { + DM().startReserve(); + mNewVTAfterLockEngage = false; + } + else if (mSwitchVTAfterLockEngage != -1) { + DM().switchVT(mSwitchVTAfterLockEngage); + mSwitchVTAfterLockEngage = -1; + } +} + +void SaverEngine::slotLockProcessReady() +{ + mSaverProcessReady = true; +} + +void SaverEngine::lockProcessWaiting() +{ + kdDebug(1204) << "SaverEngine: lock exited" << endl; + if (trinity_lockeng_sak_available == TRUE) { + handleSecureDialog(); + } + if( mState == Waiting ) { + return; + } + emitDCOPSignal("KDE_stop_screensaver()", TQByteArray()); + if (mEnabled) { + if (mXAutoLock) { + mXAutoLock->start(); + } + XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); + XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures); + } + processLockTransactions(); + mState = Waiting; + + if( systemdSession && systemdSession->canSend() ) { + TQValueList<TQT_DBusData> params; + params << TQT_DBusData::fromBool(false); + TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params); + } +} + +//--------------------------------------------------------------------------- +// +// XAutoLock has detected the required idle time. +// +void SaverEngine::idleTimeout() +{ + if (!mValidCryptoCardInserted) { + // disable X screensaver + XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); + XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures); + startLockProcess( DefaultLock ); + } +} + +xautolock_corner_t SaverEngine::applyManualSettings(int action) +{ + if (action == 0) { + kdDebug() << "no lock" << endl; + return ca_nothing; + } + else if (action == 1) { + kdDebug() << "lock screen" << endl; + return ca_forceLock; + } + else if (action == 2) { + kdDebug() << "prevent lock" << endl; + return ca_dontLock; + } + else{ + kdDebug() << "no lock nothing" << endl; + return ca_nothing; + } +} + +/*! + * This function try a reconnect to D-Bus. + * \return boolean with the result of the operation + * \retval true if successful reconnected to D-Bus + * \retval false if unsuccessful + */ +bool SaverEngine::dBusReconnect() { + // close D-Bus connection + dBusClose(); + // init D-Bus conntection + return (dBusConnect()); +} + +/*! + * This function is used to close D-Bus connection. + */ +void SaverEngine::dBusClose() { + if( dBusConn.isConnected() ) { + if( dBusLocal ) { + delete dBusLocal; + dBusLocal = 0; + } + if( dBusWatch ) { + delete dBusWatch; + dBusWatch = 0; + } + if( systemdSession ) { + delete systemdSession; + systemdSession = 0; + } + } + dBusConn.closeConnection(DBUS_CONN_NAME); +} + +/*! + * This function is used to connect to D-Bus. + */ +bool SaverEngine::dBusConnect() { + dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME); + if( !dBusConn.isConnected() ) { + kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl; + TQTimer::singleShot(4000, this, TQT_SLOT(dBusReconnect())); + return false; + } + + // watcher for Disconnect signal + dBusLocal = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_LOCAL, DBUS_INTERFACE_LOCAL, dBusConn); + TQObject::connect(dBusLocal, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)), + this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&))); + + // watcher for NameOwnerChanged signals + dBusWatch = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn); + TQObject::connect(dBusWatch, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)), + this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&))); + + // find already running SystemD + TQT_DBusProxy checkSystemD(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn); + if( checkSystemD.canSend() ) { + TQValueList<TQT_DBusData> params; + params << TQT_DBusData::fromString(SYSTEMD_LOGIN1_SERVICE); + TQT_DBusMessage reply = checkSystemD.sendWithReply("NameHasOwner", params); + if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 && reply[0].toBool() ) { + onDBusServiceRegistered(SYSTEMD_LOGIN1_SERVICE); + } + } + return true; +} + +/*! + * This function handles D-Bus service registering + */ +void SaverEngine::onDBusServiceRegistered(const TQString& service) { + if( service == SYSTEMD_LOGIN1_SERVICE ) { + // get current systemd session + TQT_DBusProxy managerIface(SYSTEMD_LOGIN1_SERVICE, SYSTEMD_LOGIN1_PATH, SYSTEMD_LOGIN1_MANAGER_IFACE, dBusConn); + TQT_DBusObjectPath systemdSessionPath = TQT_DBusObjectPath(); + if( managerIface.canSend() ) { + TQValueList<TQT_DBusData> params; + params << TQT_DBusData::fromUInt32( getpid() ); + TQT_DBusMessage reply = managerIface.sendWithReply("GetSessionByPID", params); + if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) { + systemdSessionPath = reply[0].toObjectPath(); + } + } + // wather for systemd session signals + if( systemdSessionPath.isValid() ) { + systemdSession = new TQT_DBusProxy(SYSTEMD_LOGIN1_SERVICE, systemdSessionPath, SYSTEMD_LOGIN1_SESSION_IFACE, dBusConn); + TQObject::connect(systemdSession, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)), + this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&))); + } + return; + } +} + +/*! + * This function handles D-Bus service unregistering + */ +void SaverEngine::onDBusServiceUnregistered(const TQString& service) { + if( service == SYSTEMD_LOGIN1_SERVICE ) { + if( systemdSession ) { + delete systemdSession; + systemdSession = 0; + } + return; + } +} + +/*! + * This function handles signals from the D-Bus daemon. + */ +void SaverEngine::handleDBusSignal(const TQT_DBusMessage& msg) { + // dbus terminated + if( msg.path() == DBUS_PATH_LOCAL + && msg.interface() == DBUS_INTERFACE_LOCAL + && msg.member() == "Disconnected" ) { + dBusClose(); + TQTimer::singleShot(1000, this, TQT_SLOT(dBusReconnect())); + return; + } + + // service registered / unregistered + if( msg.path() == DBUS_PATH_DBUS + && msg.interface() == DBUS_INTERFACE_DBUS + && msg.member() == "NameOwnerChanged" ) { + if( msg[1].toString().isEmpty() ) { + // old-owner is empty + onDBusServiceRegistered(msg[0].toString()); + } + if( msg[2].toString().isEmpty() ) { + // new-owner is empty + onDBusServiceUnregistered(msg[0].toString()); + } + return; + } + + // systemd signal Lock() + if( systemdSession && systemdSession->canSend() + && msg.path() == systemdSession->path() + && msg.interface() == SYSTEMD_LOGIN1_SESSION_IFACE + && msg.member() == "Lock") { + lockScreen(); + return; + } + + // systemd signal Unlock() + if( systemdSession && systemdSession->canSend() + && msg.path() == systemdSession->path() + && msg.interface() == SYSTEMD_LOGIN1_SESSION_IFACE + && msg.member() == "Unlock") { + // unlock? + return; + } +} + +bool SaverEngine::waitForLockProcessStart() { + sigset_t new_mask; + sigset_t empty_mask; + sigemptyset(&empty_mask); + + // ensure that SIGCHLD is not subject to a race condition + sigemptyset(&new_mask); + sigaddset(&new_mask, SIGCHLD); + + pthread_sigmask(SIG_BLOCK, &new_mask, NULL); + while ((mLockProcess.isRunning()) && (!mSaverProcessReady)) { + // wait for any signal(s) to arrive + sigsuspend(&empty_mask); + } + pthread_sigmask(SIG_UNBLOCK, &new_mask, NULL); + + return mLockProcess.isRunning(); +} + +bool SaverEngine::waitForLockEngage() { + sigset_t empty_mask; + sigemptyset(&empty_mask); + + // wait for SIGUSR1, SIGUSR2, SIGTTIN + while ((mLockProcess.isRunning()) && (mState != Waiting) && (mState != Saving)) { + // wait for any signal(s) to arrive + sigsuspend(&empty_mask); + } + + return mLockProcess.isRunning(); +} + +void SaverEngine::lockScreenAndDoNewSession() { + mNewVTAfterLockEngage = true; + lockScreen(); +} + +void SaverEngine::lockScreenAndSwitchSession(int vt) { + mSwitchVTAfterLockEngage = vt; + lockScreen(); +} + +void SaverEngineThreadHelperObject::terminateThread() { + TQEventLoop* eventLoop = TQApplication::eventLoop(); + if (eventLoop) { + eventLoop->exit(0); + } +} |