TDE
/
tdebase
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdebase
0
0
Fork 0
Code Issues Releases Wiki Activity

Fix lockeng file formatting

Browse Source 
(cherry picked from commit a17bfb0b96)
pull/182/head
Timothy Pearson 9 years ago committed by Slávek Banko
parent d9fe0f0bf3
commit 6dd6500446
2 changed files with 499 additions and 512 deletions
Show Stats Download Patch File Download Diff File

791
kdesktop/lockeng.cc
Unescape View File

@ -48,21 +48,21 @@ bool trinity_lockeng_sak_available = TRUE;
SaverEngine* m_masterSaverEngine = NULL; SaverEngine* m_masterSaverEngine = NULL;
static void sigusr1_handler(int) static void sigusr1_handler(int)
{ {
if (m_masterSaverEngine) { if (m_masterSaverEngine) {
m_masterSaverEngine->slotLockProcessWaiting(); m_masterSaverEngine->slotLockProcessWaiting();
} }
} }
static void sigusr2_handler(int) static void sigusr2_handler(int)
{ {
if (m_masterSaverEngine) { if (m_masterSaverEngine) {
m_masterSaverEngine->slotLockProcessFullyActivated(); m_masterSaverEngine->slotLockProcessFullyActivated();
} }
} }
static void sigttin_handler(int) static void sigttin_handler(int)
{ {
if (m_masterSaverEngine) { if (m_masterSaverEngine) {
m_masterSaverEngine->slotLockProcessReady(); m_masterSaverEngine->slotLockProcessReady();
} }
} }
//=========================================================================== //===========================================================================
@ -72,73 +72,73 @@ static void sigttin_handler(int)
// a newly started process. // a newly started process.
// //
SaverEngine::SaverEngine() SaverEngine::SaverEngine()
: TQWidget(), : TQWidget(),
KScreensaverIface(), KScreensaverIface(),
mBlankOnly(false), mBlankOnly(false),
mSAKProcess(NULL), mSAKProcess(NULL),
mTerminationRequested(false), mTerminationRequested(false),
mSaverProcessReady(false), mSaverProcessReady(false),
dBusLocal(0), dBusLocal(0),
dBusWatch(0), dBusWatch(0),
systemdSession(0) systemdSession(0)
{ {
// handle SIGUSR1 // handle SIGUSR1
m_masterSaverEngine = this; m_masterSaverEngine = this;
mSignalAction.sa_handler= sigusr1_handler; mSignalAction.sa_handler= sigusr1_handler;
sigemptyset(&(mSignalAction.sa_mask)); sigemptyset(&(mSignalAction.sa_mask));
sigaddset(&(mSignalAction.sa_mask), SIGUSR1); sigaddset(&(mSignalAction.sa_mask), SIGUSR1);
mSignalAction.sa_flags = 0; mSignalAction.sa_flags = 0;
sigaction(SIGUSR1, &mSignalAction, 0L); sigaction(SIGUSR1, &mSignalAction, 0L);
// handle SIGUSR2 // handle SIGUSR2
m_masterSaverEngine = this; m_masterSaverEngine = this;
mSignalAction.sa_handler= sigusr2_handler; mSignalAction.sa_handler= sigusr2_handler;
sigemptyset(&(mSignalAction.sa_mask)); sigemptyset(&(mSignalAction.sa_mask));
sigaddset(&(mSignalAction.sa_mask), SIGUSR2); sigaddset(&(mSignalAction.sa_mask), SIGUSR2);
mSignalAction.sa_flags = 0; mSignalAction.sa_flags = 0;
sigaction(SIGUSR2, &mSignalAction, 0L); sigaction(SIGUSR2, &mSignalAction, 0L);
// handle SIGTTIN // handle SIGTTIN
m_masterSaverEngine = this; m_masterSaverEngine = this;
mSignalAction.sa_handler= sigttin_handler; mSignalAction.sa_handler= sigttin_handler;
sigemptyset(&(mSignalAction.sa_mask)); sigemptyset(&(mSignalAction.sa_mask));
sigaddset(&(mSignalAction.sa_mask), SIGTTIN); sigaddset(&(mSignalAction.sa_mask), SIGTTIN);
mSignalAction.sa_flags = 0; mSignalAction.sa_flags = 0;
sigaction(SIGTTIN, &mSignalAction, 0L); sigaction(SIGTTIN, &mSignalAction, 0L);
// Save X screensaver parameters // Save X screensaver parameters
XGetScreenSaver(tqt_xdisplay(), &mXTimeout, &mXInterval, XGetScreenSaver(tqt_xdisplay(), &mXTimeout, &mXInterval,
&mXBlanking, &mXExposures); &mXBlanking, &mXExposures);
mState = Waiting; mState = Waiting;
mXAutoLock = 0; mXAutoLock = 0;
mEnabled = false; mEnabled = false;
connect(&mLockProcess, TQT_SIGNAL(processExited(TDEProcess *)), connect(&mLockProcess, TQT_SIGNAL(processExited(TDEProcess *)),
TQT_SLOT(lockProcessExited())); TQT_SLOT(lockProcessExited()));
mSAKProcess = new TDEProcess; mSAKProcess = new TDEProcess;
*mSAKProcess << "tdmtsak"; *mSAKProcess << "tdmtsak";
connect(mSAKProcess, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotSAKProcessExited())); connect(mSAKProcess, TQT_SIGNAL(processExited(TDEProcess*)), this, TQT_SLOT(slotSAKProcessExited()));
TQTimer::singleShot( 0, this, TQT_SLOT(handleSecureDialog()) ); TQTimer::singleShot( 0, this, TQT_SLOT(handleSecureDialog()) );
configure(); configure();
mLockProcess.clearArguments(); mLockProcess.clearArguments();
TQString path = TDEStandardDirs::findExe( "kdesktop_lock" ); TQString path = TDEStandardDirs::findExe( "kdesktop_lock" );
if( path.isEmpty()) if( path.isEmpty())
{ {
kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl; kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl;
} }
mLockProcess << path; mLockProcess << path;
mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid()); mLockProcess << TQString( "--internal" ) << TQString( "%1" ).arg(getpid());
if (mLockProcess.start() == false ) if (mLockProcess.start() == false )
{ {
kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl; kdDebug( 1204 ) << "Failed to start kdesktop_lock!" << endl;
} }
dBusConnect(); dBusConnect();
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -147,18 +147,18 @@ SaverEngine::SaverEngine()
// //
SaverEngine::~SaverEngine() SaverEngine::~SaverEngine()
{ {
if (mState == Waiting) { if (mState == Waiting) {
kill(mLockProcess.pid(), SIGKILL); kill(mLockProcess.pid(), SIGKILL);
} }
mLockProcess.detach(); // don't kill it if we crash mLockProcess.detach(); // don't kill it if we crash
delete mXAutoLock; delete mXAutoLock;
dBusClose(); dBusClose();
// Restore X screensaver parameters // Restore X screensaver parameters
XSetScreenSaver(tqt_xdisplay(), mXTimeout, mXInterval, mXBlanking, XSetScreenSaver(tqt_xdisplay(), mXTimeout, mXInterval, mXBlanking,
mXExposures); mXExposures);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -167,7 +167,7 @@ SaverEngine::~SaverEngine()
// //
void SaverEngine::lock() void SaverEngine::lock()
{ {
lockScreen(true); lockScreen(true);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -176,126 +176,126 @@ void SaverEngine::lock()
// //
void SaverEngine::lockScreen(bool DCOP) void SaverEngine::lockScreen(bool DCOP)
{ {
bool ok = true; bool ok = true;
if (mState != Saving) if (mState != Saving)
{ {
ok = startLockProcess( ForceLock ); ok = startLockProcess( ForceLock );
// It takes a while for kdesktop_lock to start and lock the screen. // 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. // Therefore delay the DCOP call until it tells kdesktop that the locking is in effect.
// This is done only for --forcelock . // This is done only for --forcelock .
if( ok && mState != Saving ) if( ok && mState != Saving )
{ {
if (DCOP) { if (DCOP) {
DCOPClientTransaction* trans = kapp->dcopClient()->beginTransaction(); DCOPClientTransaction* trans = kapp->dcopClient()->beginTransaction();
if (trans) { if (trans) {
mLockTransactions.append( trans ); mLockTransactions.append( trans );
} }
} }
} }
} }
else else
{ {
mLockProcess.kill( SIGHUP ); mLockProcess.kill( SIGHUP );
} }
} }
void SaverEngine::processLockTransactions() void SaverEngine::processLockTransactions()
{ {
for( TQValueVector< DCOPClientTransaction* >::ConstIterator it = mLockTransactions.begin(); for( TQValueVector< DCOPClientTransaction* >::ConstIterator it = mLockTransactions.begin();
it != mLockTransactions.end(); it != mLockTransactions.end();
++it ) ++it )
{ {
TQCString replyType = "void"; TQCString replyType = "void";
TQByteArray arr; TQByteArray arr;
kapp->dcopClient()->endTransaction( *it, replyType, arr ); kapp->dcopClient()->endTransaction( *it, replyType, arr );
} }
mLockTransactions.clear(); mLockTransactions.clear();
} }
void SaverEngine::saverLockReady() void SaverEngine::saverLockReady()
{ {
if( mState != Engaging ) if( mState != Engaging )
{ {
kdDebug( 1204 ) << "Got unexpected saverReady()" << endl; kdDebug( 1204 ) << "Got unexpected saverReady()" << endl;
} }
kdDebug( 1204 ) << "Saver Lock Ready" << endl; kdDebug( 1204 ) << "Saver Lock Ready" << endl;
processLockTransactions(); processLockTransactions();
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SaverEngine::save() void SaverEngine::save()
{ {
if (mState == Waiting) if (mState == Waiting)
{ {
startLockProcess( DefaultLock ); startLockProcess( DefaultLock );
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SaverEngine::quit() void SaverEngine::quit()
{ {
if (mState == Saving || mState == Engaging) if (mState == Saving || mState == Engaging)
{ {
stopLockProcess(); stopLockProcess();
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool SaverEngine::isEnabled() bool SaverEngine::isEnabled()
{ {
return mEnabled; return mEnabled;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool SaverEngine::enable( bool e ) bool SaverEngine::enable( bool e )
{ {
if ( e == mEnabled ) if ( e == mEnabled )
return true; return true;
// If we aren't in a suitable state, we will not reconfigure. // If we aren't in a suitable state, we will not reconfigure.
if (mState != Waiting) if (mState != Waiting)
return false; return false;
mEnabled = e; mEnabled = e;
if (mEnabled) if (mEnabled)
{ {
if ( !mXAutoLock ) { if ( !mXAutoLock ) {
mXAutoLock = new XAutoLock(); mXAutoLock = new XAutoLock();
connect(mXAutoLock, TQT_SIGNAL(timeout()), TQT_SLOT(idleTimeout())); 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;
} }
mXAutoLock->setTimeout(mTimeout); else
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; if (mXAutoLock)
mXAutoLock = 0; {
delete mXAutoLock;
mXAutoLock = 0;
}
XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset );
XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures);
kdDebug(1204) << "Saver Engine disabled" << endl;
} }
XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); return true;
XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures);
kdDebug(1204) << "Saver Engine disabled" << endl;
}
return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool SaverEngine::isBlanked() bool SaverEngine::isBlanked()
{ {
return (mState != Waiting); return (mState != Waiting);
} }
void SaverEngine::enableExports() void SaverEngine::enableExports()
@ -312,8 +312,9 @@ void SaverEngine::enableExports()
TQCString appname( "kdesktop" ); TQCString appname( "kdesktop" );
int screen_number = DefaultScreen(tqt_xdisplay()); int screen_number = DefaultScreen(tqt_xdisplay());
if ( screen_number ) if ( screen_number ) {
appname.sprintf("kdesktop-screen-%d", screen_number ); appname.sprintf("kdesktop-screen-%d", screen_number );
}
client->send( appname, "KBackgroundIface", "setExport(int)", data ); client->send( appname, "KBackgroundIface", "setExport(int)", data );
#endif #endif
@ -322,36 +323,36 @@ void SaverEngine::enableExports()
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void SaverEngine::handleSecureDialog() void SaverEngine::handleSecureDialog()
{ {
// Wait for SAK press // Wait for SAK press
if (!mSAKProcess->isRunning()) mSAKProcess->start(); if (!mSAKProcess->isRunning()) mSAKProcess->start();
} }
void SaverEngine::slotSAKProcessExited() void SaverEngine::slotSAKProcessExited()
{ {
int retcode = mSAKProcess->exitStatus(); int retcode = mSAKProcess->exitStatus();
if ((retcode != 0) && (mSAKProcess->normalExit())) { if ((retcode != 0) && (mSAKProcess->normalExit())) {
trinity_lockeng_sak_available = FALSE; 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); 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) { if (mState == Preparing) {
return; return;
} }
if ((mSAKProcess->normalExit()) && (trinity_lockeng_sak_available == TRUE)) { if ((mSAKProcess->normalExit()) && (trinity_lockeng_sak_available == TRUE)) {
bool ok = true; bool ok = true;
if (mState == Waiting) if (mState == Waiting)
{ {
ok = startLockProcess( SecureDialog ); ok = startLockProcess( SecureDialog );
if( ok && mState != Saving ) if( ok && mState != Saving )
{ {
} }
} }
else else
{ {
mLockProcess.kill( SIGHUP ); mLockProcess.kill( SIGHUP );
} }
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -360,29 +361,30 @@ void SaverEngine::slotSAKProcessExited()
// //
void SaverEngine::configure() void SaverEngine::configure()
{ {
// If we aren't in a suitable state, we will not reconfigure. // If we aren't in a suitable state, we will not reconfigure.
if (mState != Waiting) if (mState != Waiting) {
return; return;
}
// create a new config obj to ensure we read the latest options // create a new config obj to ensure we read the latest options
KDesktopSettings::self()->readConfig(); KDesktopSettings::self()->readConfig();
bool e = KDesktopSettings::screenSaverEnabled(); bool e = KDesktopSettings::screenSaverEnabled();
mTimeout = KDesktopSettings::timeout(); mTimeout = KDesktopSettings::timeout();
mEnabled = !e; // force the enable() mEnabled = !e; // force the enable()
int action; int action;
action = KDesktopSettings::actionTopLeft(); action = KDesktopSettings::actionTopLeft();
xautolock_corners[0] = applyManualSettings(action); xautolock_corners[0] = applyManualSettings(action);
action = KDesktopSettings::actionTopRight(); action = KDesktopSettings::actionTopRight();
xautolock_corners[1] = applyManualSettings(action); xautolock_corners[1] = applyManualSettings(action);
action = KDesktopSettings::actionBottomLeft(); action = KDesktopSettings::actionBottomLeft();
xautolock_corners[2] = applyManualSettings(action); xautolock_corners[2] = applyManualSettings(action);
action = KDesktopSettings::actionBottomRight(); action = KDesktopSettings::actionBottomRight();
xautolock_corners[3] = applyManualSettings(action); xautolock_corners[3] = applyManualSettings(action);
enable( e ); enable( e );
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -398,33 +400,31 @@ void SaverEngine::setBlankOnly( bool blankOnly )
bool SaverEngine::restartDesktopLockProcess() bool SaverEngine::restartDesktopLockProcess()
{ {
if (!mLockProcess.isRunning()) { if (!mLockProcess.isRunning()) {
mSaverProcessReady = false; mSaverProcessReady = false;
mLockProcess.clearArguments(); mLockProcess.clearArguments();
TQString path = TDEStandardDirs::findExe( "kdesktop_lock" ); TQString path = TDEStandardDirs::findExe( "kdesktop_lock" );
if( path.isEmpty()) if (path.isEmpty()) {
{ kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl;
kdDebug( 1204 ) << "Can't find kdesktop_lock!" << endl; return false;
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...
int count = 0;
while (!mSaverProcessReady) {
count++;
usleep(100);
if (count > 100) {
return false;
}
}
} }
mLockProcess << path; return true;
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...
int count = 0;
while (!mSaverProcessReady) {
count++;
usleep(100);
if (count > 100) {
return false;
}
}
}
return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -433,56 +433,55 @@ bool SaverEngine::restartDesktopLockProcess()
// //
bool SaverEngine::startLockProcess( LockType lock_type ) bool SaverEngine::startLockProcess( LockType lock_type )
{ {
int ret; int ret;
if (mState == Saving) { if (mState == Saving) {
return true; return true;
} }
mState = Preparing; mState = Preparing;
mSAKProcess->kill(SIGTERM); mSAKProcess->kill(SIGTERM);
enableExports(); enableExports();
kdDebug(1204) << "SaverEngine: starting saver" << endl; kdDebug(1204) << "SaverEngine: starting saver" << endl;
emitDCOPSignal("KDE_start_screensaver()", TQByteArray()); emitDCOPSignal("KDE_start_screensaver()", TQByteArray());
if (!restartDesktopLockProcess()) { if (!restartDesktopLockProcess()) {
mState = Waiting; mState = Waiting;
return false; return false;
} }
switch( lock_type ) switch( lock_type )
{ {
case ForceLock: case ForceLock:
mLockProcess.kill(SIGUSR1); // Request forcelock mLockProcess.kill(SIGUSR1); // Request forcelock
break; break;
case DontLock: case DontLock:
mLockProcess.kill(SIGUSR2); // Request dontlock mLockProcess.kill(SIGUSR2); // Request dontlock
break; break;
case SecureDialog: case SecureDialog:
mLockProcess.kill(SIGWINCH); // Request secure dialog mLockProcess.kill(SIGWINCH); // Request secure dialog
break; break;
default: default:
break; break;
} }
if (mBlankOnly) { if (mBlankOnly) {
mLockProcess.kill(SIGTTIN); // Request blanking mLockProcess.kill(SIGTTIN); // Request blanking
} }
ret = mLockProcess.kill(SIGTTOU); // Start lock ret = mLockProcess.kill(SIGTTOU); // Start lock
if (!ret) { if (!ret) {
mState = Waiting; mState = Waiting;
return false; return false;
} }
XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, mXExposures); XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, mXExposures);
mState = Engaging; mState = Engaging;
if (mXAutoLock) if (mXAutoLock) {
{ mXAutoLock->stop();
mXAutoLock->stop(); }
} return true;
return true;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -491,129 +490,125 @@ bool SaverEngine::startLockProcess( LockType lock_type )
// //
void SaverEngine::stopLockProcess() void SaverEngine::stopLockProcess()
{ {
if (mState == Waiting) if (mState == Waiting) {
{ kdWarning(1204) << "SaverEngine::stopSaver() saver not active" << endl;
kdWarning(1204) << "SaverEngine::stopSaver() saver not active" << endl; return;
return; }
} kdDebug(1204) << "SaverEngine: stopping lock" << endl;
kdDebug(1204) << "SaverEngine: stopping lock" << endl; emitDCOPSignal("KDE_stop_screensaver()", TQByteArray());
emitDCOPSignal("KDE_stop_screensaver()", TQByteArray());
mTerminationRequested = true;
mTerminationRequested=true; mLockProcess.kill();
mLockProcess.kill();
if (mEnabled) {
if (mEnabled) if (mXAutoLock) {
{ mXAutoLock->start();
if (mXAutoLock) }
{ XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset );
mXAutoLock->start(); XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures);
} }
XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); processLockTransactions();
XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures); mState = Waiting;
}
processLockTransactions(); if( systemdSession && systemdSession->canSend() ) {
mState = Waiting; TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromBool(false);
if( systemdSession && systemdSession->canSend() ) { TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params);
TQValueList<TQT_DBusData> params; }
params << TQT_DBusData::fromBool(false);
TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params);
}
} }
void SaverEngine::recoverFromHackingAttempt() void SaverEngine::recoverFromHackingAttempt()
{ {
// Try to relaunch saver with forcelock // Try to relaunch saver with forcelock
if (!startLockProcess( ForceLock )) { if (!startLockProcess(ForceLock)) {
// Terminate the TDE session ASAP! // Terminate the TDE session ASAP!
// Values are explained at http://lists.kde.org/?l=kde-linux&m=115770988603387 // Values are explained at http://lists.kde.org/?l=kde-linux&m=115770988603387
TQByteArray data; TQByteArray data;
TQDataStream arg(data, IO_WriteOnly); TQDataStream arg(data, IO_WriteOnly);
arg << (int)0 << (int)0 << (int)2; arg << (int)0 << (int)0 << (int)2;
if ( ! kapp->dcopClient()->send("ksmserver", "default", "logout(int,int,int)", data) ) { if (!kapp->dcopClient()->send("ksmserver", "default", "logout(int,int,int)", data)) {
// Someone got to DCOP before we did // Someone got to DCOP before we did
// Try an emergency system logout // Try an emergency system logout
system("logout"); system("logout");
} }
} }
} }
void SaverEngine::lockProcessExited() void SaverEngine::lockProcessExited()
{ {
bool abnormalExit = false; bool abnormalExit = false;
if (mLockProcess.normalExit() == false) { if (mLockProcess.normalExit() == false) {
abnormalExit = true; abnormalExit = true;
} }
else { else {
if (mLockProcess.exitStatus() != 0) { if (mLockProcess.exitStatus() != 0) {
abnormalExit = true; abnormalExit = true;
} }
} }
if (mTerminationRequested == true) { if (mTerminationRequested == true) {
abnormalExit = false; abnormalExit = false;
mTerminationRequested = false; mTerminationRequested = false;
} }
if (abnormalExit == true) { if (abnormalExit == true) {
// PROBABLE HACKING ATTEMPT DETECTED // PROBABLE HACKING ATTEMPT DETECTED
restartDesktopLockProcess(); restartDesktopLockProcess();
mState = Waiting; mState = Waiting;
TQTimer::singleShot( 100, this, SLOT(recoverFromHackingAttempt()) ); TQTimer::singleShot( 100, this, SLOT(recoverFromHackingAttempt()) );
} }
else { else {
// Restart the lock process // Restart the lock process
restartDesktopLockProcess(); restartDesktopLockProcess();
} }
} }
void SaverEngine::slotLockProcessWaiting() void SaverEngine::slotLockProcessWaiting()
{ {
// lockProcessWaiting cannot be called directly from a signal handler, as it will hang in certain obscure circumstances // 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 // Instead we use a single-shot timer to immediately call lockProcessWaiting once control has returned to the Qt main loop
TQTimer::singleShot(0, this, SLOT(lockProcessWaiting())); TQTimer::singleShot(0, this, SLOT(lockProcessWaiting()));
} }
void SaverEngine::slotLockProcessFullyActivated() void SaverEngine::slotLockProcessFullyActivated()
{ {
mState = Saving; mState = Saving;
if( systemdSession && systemdSession->canSend() ) { if( systemdSession && systemdSession->canSend() ) {
TQValueList<TQT_DBusData> params; TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromBool(true); params << TQT_DBusData::fromBool(true);
TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params); TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params);
} }
} }
void SaverEngine::slotLockProcessReady() void SaverEngine::slotLockProcessReady()
{ {
mSaverProcessReady = true; mSaverProcessReady = true;
} }
void SaverEngine::lockProcessWaiting() void SaverEngine::lockProcessWaiting()
{ {
kdDebug(1204) << "SaverEngine: lock exited" << endl; kdDebug(1204) << "SaverEngine: lock exited" << endl;
if (trinity_lockeng_sak_available == TRUE) { if (trinity_lockeng_sak_available == TRUE) {
handleSecureDialog(); handleSecureDialog();
} }
if( mState == Waiting ) if( mState == Waiting ) {
return; return;
emitDCOPSignal("KDE_stop_screensaver()", TQByteArray()); }
if (mEnabled) emitDCOPSignal("KDE_stop_screensaver()", TQByteArray());
{ if (mEnabled) {
if (mXAutoLock) if (mXAutoLock) {
{ mXAutoLock->start();
mXAutoLock->start(); }
} XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset );
XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures);
XSetScreenSaver(tqt_xdisplay(), mTimeout + 10, mXInterval, PreferBlanking, mXExposures); }
} processLockTransactions();
processLockTransactions(); mState = Waiting;
mState = Waiting;
if( systemdSession && systemdSession->canSend() ) {
if( systemdSession && systemdSession->canSend() ) { TQValueList<TQT_DBusData> params;
TQValueList<TQT_DBusData> params; params << TQT_DBusData::fromBool(false);
params << TQT_DBusData::fromBool(false); TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params);
TQT_DBusMessage reply = systemdSession->sendWithReply("SetIdleHint", params); }
}
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@ -622,33 +617,27 @@ void SaverEngine::lockProcessWaiting()
// //
void SaverEngine::idleTimeout() void SaverEngine::idleTimeout()
{ {
// disable X screensaver // disable X screensaver
XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset ); XForceScreenSaver(tqt_xdisplay(), ScreenSaverReset );
XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures); XSetScreenSaver(tqt_xdisplay(), 0, mXInterval, PreferBlanking, DontAllowExposures);
startLockProcess( DefaultLock ); startLockProcess( DefaultLock );
} }
xautolock_corner_t SaverEngine::applyManualSettings(int action) xautolock_corner_t SaverEngine::applyManualSettings(int action)
{ {
if (action == 0) if (action == 0) {
{
kdDebug() << "no lock" << endl; kdDebug() << "no lock" << endl;
return ca_nothing; return ca_nothing;
} }
else else if (action == 1) {
if (action == 1)
{
kdDebug() << "lock screen" << endl; kdDebug() << "lock screen" << endl;
return ca_forceLock; return ca_forceLock;
} }
else else if (action == 2) {
if (action == 2)
{
kdDebug() << "prevent lock" << endl; kdDebug() << "prevent lock" << endl;
return ca_dontLock; return ca_dontLock;
} }
else else{
{
kdDebug() << "no lock nothing" << endl; kdDebug() << "no lock nothing" << endl;
return ca_nothing; return ca_nothing;
} }
@ -694,9 +683,9 @@ void SaverEngine::dBusClose() {
bool SaverEngine::dBusConnect() { bool SaverEngine::dBusConnect() {
dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME); dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME);
if( !dBusConn.isConnected() ) { if( !dBusConn.isConnected() ) {
kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl; kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl;
TQTimer::singleShot(4000, this, TQT_SLOT(dBusReconnect())); TQTimer::singleShot(4000, this, TQT_SLOT(dBusReconnect()));
return false; return false;
} }
// watcher for Disconnect signal // watcher for Disconnect signal

220
kdesktop/lockeng.h
Unescape View File

@ -26,138 +26,136 @@ class TQT_DBusProxy;
* Screen saver engine. Handles screensaver window, starting screensaver * Screen saver engine. Handles screensaver window, starting screensaver
* hacks, and password entry. * hacks, and password entry.
*/ */
class SaverEngine class SaverEngine : public TQWidget, public KScreensaverIface
: public TQWidget,
public KScreensaverIface
{ {
Q_OBJECT Q_OBJECT
public: public:
SaverEngine(); SaverEngine();
~SaverEngine(); ~SaverEngine();
/** /**
* Lock the screen * Lock the screen
*/ */
virtual void lock(); virtual void lock();
/** /**
* Save the screen * Save the screen
*/ */
virtual void save(); virtual void save();
/** /**
* Quit the screensaver if running * Quit the screensaver if running
*/ */
virtual void quit(); virtual void quit();
/** /**
* return true if the screensaver is enabled * return true if the screensaver is enabled
*/ */
virtual bool isEnabled(); virtual bool isEnabled();
/** /**
* enable/disable the screensaver * enable/disable the screensaver
*/ */
virtual bool enable( bool e ); virtual bool enable( bool e );
/** /**
* return true if the screen is currently blanked * return true if the screen is currently blanked
*/ */
virtual bool isBlanked(); virtual bool isBlanked();
/** /**
* Read and apply configuration. * Read and apply configuration.
*/ */
virtual void configure(); virtual void configure();
/** /**
* Enable or disable "blank only" mode. This is useful for * Enable or disable "blank only" mode. This is useful for
* laptops where one might not want a cpu thirsty screensaver * laptops where one might not want a cpu thirsty screensaver
* draining the battery. * draining the battery.
*/ */
virtual void setBlankOnly( bool blankOnly ); virtual void setBlankOnly( bool blankOnly );
/** /**
* Called by kdesktop_lock when locking is in effect. * Called by kdesktop_lock when locking is in effect.
*/ */
virtual void saverLockReady(); virtual void saverLockReady();
/** /**
* @internal * @internal
*/ */
void lockScreen(bool DCOP = false); void lockScreen(bool DCOP = false);
/** /**
* Called by KDesktop to wait for saver engage * Called by KDesktop to wait for saver engage
* @internal * @internal
*/ */
void waitForLockEngage(); void waitForLockEngage();
public slots: public slots:
void slotLockProcessWaiting(); void slotLockProcessWaiting();
void slotLockProcessFullyActivated(); void slotLockProcessFullyActivated();
void slotLockProcessReady(); void slotLockProcessReady();
void handleDBusSignal(const TQT_DBusMessage&); void handleDBusSignal(const TQT_DBusMessage&);
protected slots: protected slots:
void idleTimeout(); void idleTimeout();
void lockProcessExited(); void lockProcessExited();
void lockProcessWaiting(); void lockProcessWaiting();
private slots: private slots:
void handleSecureDialog(); void handleSecureDialog();
void slotSAKProcessExited(); void slotSAKProcessExited();
/** /**
* Enable wallpaper exports * Enable wallpaper exports
*/ */
void enableExports(); void enableExports();
void recoverFromHackingAttempt(); void recoverFromHackingAttempt();
bool dBusReconnect(); bool dBusReconnect();
private: private:
bool restartDesktopLockProcess(); bool restartDesktopLockProcess();
void dBusClose(); void dBusClose();
bool dBusConnect(); bool dBusConnect();
void onDBusServiceRegistered(const TQString&); void onDBusServiceRegistered(const TQString&);
void onDBusServiceUnregistered(const TQString&); void onDBusServiceUnregistered(const TQString&);
protected: protected:
enum SaverState { Waiting, Preparing, Engaging, Saving }; enum SaverState { Waiting, Preparing, Engaging, Saving };
enum LockType { DontLock, DefaultLock, ForceLock, SecureDialog }; enum LockType { DontLock, DefaultLock, ForceLock, SecureDialog };
bool startLockProcess( LockType lock_type ); bool startLockProcess( LockType lock_type );
void stopLockProcess(); void stopLockProcess();
bool handleKeyPress(XKeyEvent *xke); bool handleKeyPress(XKeyEvent *xke);
void processLockTransactions(); void processLockTransactions();
xautolock_corner_t applyManualSettings(int); xautolock_corner_t applyManualSettings(int);
protected: protected:
bool mEnabled; bool mEnabled;
SaverState mState; SaverState mState;
XAutoLock *mXAutoLock; XAutoLock *mXAutoLock;
TDEProcess mLockProcess; TDEProcess mLockProcess;
int mTimeout; int mTimeout;
// the original X screensaver parameters // the original X screensaver parameters
int mXTimeout; int mXTimeout;
int mXInterval; int mXInterval;
int mXBlanking; int mXBlanking;
int mXExposures; int mXExposures;
bool mBlankOnly; // only use the blanker, not the defined saver bool mBlankOnly; // only use the blanker, not the defined saver
TQValueVector< DCOPClientTransaction* > mLockTransactions; TQValueVector< DCOPClientTransaction* > mLockTransactions;
private: private:
TDEProcess* mSAKProcess; TDEProcess* mSAKProcess;
bool mTerminationRequested; bool mTerminationRequested;
bool mSaverProcessReady; bool mSaverProcessReady;
struct sigaction mSignalAction; struct sigaction mSignalAction;
TQT_DBusConnection dBusConn; TQT_DBusConnection dBusConn;
TQT_DBusProxy* dBusLocal; TQT_DBusProxy* dBusLocal;
TQT_DBusProxy* dBusWatch; TQT_DBusProxy* dBusWatch;
TQT_DBusProxy* systemdSession; TQT_DBusProxy* systemdSession;
}; };
#endif #endif

Write Preview
Loading…
Cancel
Save