summaryrefslogtreecommitdiffstats
path: root/kdesktop/lockeng.cpp
diff options
context:
space:
mode:
authorMichele Calgaro <michele.calgaro@yahoo.it>2020-12-07 22:58:44 +0900
committerMichele Calgaro <michele.calgaro@yahoo.it>2020-12-07 23:22:36 +0900
commitad6f3f6402df4bdf88672d511e21ab1e9b88d978 (patch)
treebacd0af440aa1a0671045d431406cda36d4df618 /kdesktop/lockeng.cpp
parent6ab96d20b89c0e1d86abc00513c7cec304d85800 (diff)
downloadtdebase-ad6f3f6402df4bdf88672d511e21ab1e9b88d978.tar.gz
tdebase-ad6f3f6402df4bdf88672d511e21ab1e9b88d978.zip
Renaming of files in preparation for code style tools.
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it> (cherry picked from commit 145abc15d57fb29701a12e8a14dcb9c1fd72e9be)
Diffstat (limited to 'kdesktop/lockeng.cpp')
-rw-r--r--kdesktop/lockeng.cpp923
1 files changed, 923 insertions, 0 deletions
diff --git a/kdesktop/lockeng.cpp b/kdesktop/lockeng.cpp
new file mode 100644
index 000000000..52826bf24
--- /dev/null
+++ b/kdesktop/lockeng.cpp
@@ -0,0 +1,923 @@
+//===========================================================================
+//
+// 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 <kstandarddirs.h>
+#include <tdeapplication.h>
+#include <kservicegroup.h>
+#include <ksimpleconfig.h>
+#include <kdebug.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),
+ 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;
+
+ 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;
+}
+
+//---------------------------------------------------------------------------
+//
+// This should be called only using DCOP.
+//
+void SaverEngine::lock()
+{
+ lockScreen(true);
+}
+
+//---------------------------------------------------------------------------
+//
+// Lock the screen
+//
+void SaverEngine::lockScreen(bool DCOP)
+{
+ 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 (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()
+{
+ // 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);
+ }
+}