path: root/kdesktop/lock/main.cc

/* This file is part of the KDE project
   Copyright (C) 1999 David Faure
   Copyright (c) 2003 Oswald Buddenhagen <ossi@kde.org>
   Copyright (c) 2010-2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include "lockprocess.h"
#include "main.h"
#include "kdesktopsettings.h"

#include <kcmdlineargs.h>
#include <klocale.h>
#include <kglobal.h>
#include <kdebug.h>
#include <kglobalsettings.h>
#include <dcopref.h>
#include <ksimpleconfig.h>

#include <tdmtsak.h>

#include <stdlib.h>

#include <X11/Xlib.h>
#include <fixx11h.h>

// [FIXME] Add GUI configuration checkboxes for these three settings (see kdesktoprc [ScreenSaver] UseUnmanagedLockWindows, DelaySaverStart, and UseTDESAK)
bool trinity_desktop_lock_use_system_modal_dialogs = FALSE;
bool trinity_desktop_lock_delay_screensaver_start = FALSE;
bool trinity_desktop_lock_use_sak = FALSE;

bool trinity_desktop_lock_forced = FALSE;

bool signalled_forcelock;
bool signalled_dontlock;
bool signalled_securedialog;
bool signalled_blank;
bool signalled_run;
bool in_internal_mode = FALSE;

bool MyApp::x11EventFilter( XEvent *ev )
{
    if (ev->type == ButtonPress || ev->type == ButtonRelease || ev->type == MotionNotify) {
        emit mouseInteraction(ev);
    }
    if (ev->type == XKeyPress || ev->type == ButtonPress) {
        emit activity();
    }
    else if (ev->type == MotionNotify) {
        time_t tick = time( 0 );
        if (tick != lastTick) {
            lastTick = tick;
            emit activity();
        }
    }
    return KApplication::x11EventFilter( ev );
}


static KCmdLineOptions options[] =
{
   { "forcelock", I18N_NOOP("Force session locking"), 0 },
   { "dontlock", I18N_NOOP("Only start screensaver"), 0 },
   { "securedialog", I18N_NOOP("Launch the secure dialog"), 0 },
   { "blank", I18N_NOOP("Only use the blank screensaver"), 0 },
   { "internal <pid>", I18N_NOOP("TDE internal command for background process loading"), 0 },
   KCmdLineLastOption
};

static void sigusr1_handler(int)
{
    signalled_forcelock = TRUE;
}

static void sigusr2_handler(int)
{
    signalled_dontlock = TRUE;
}

static void sigusr3_handler(int)
{
    signalled_securedialog = TRUE;
}

static void sigusr4_handler(int)
{
    signalled_blank = TRUE;
}

static void sigusr5_handler(int)
{
    signalled_run = TRUE;
}

// -----------------------------------------------------------------------------

int main( int argc, char **argv )
{
    KLocale::setMainCatalogue("kdesktop");

    KCmdLineArgs::init( argc, argv, "kdesktop_lock", I18N_NOOP("KDesktop Locker"), I18N_NOOP("Session Locker for KDesktop"), "2.1" );
    KCmdLineArgs::addCmdLineOptions( options );
    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();

    putenv(strdup("SESSION_MANAGER="));

    KApplication::disableAutoDcopRegistration(); // not needed

    while (1 == 1) {
        signalled_forcelock = FALSE;
        signalled_dontlock = FALSE;
        signalled_securedialog = FALSE;
        signalled_blank = FALSE;
        signalled_run = FALSE;

        int kdesktop_screen_number = 0;
        int starting_screen = 0;

        bool child = false;
        int parent_connection = 0; // socket to the parent saver
        TQValueList<int> child_sockets;

        if (KGlobalSettings::isMultiHead())
        {
            Display *dpy = XOpenDisplay(NULL);
            if (! dpy) {
                fprintf(stderr,
                        "%s: FATAL ERROR: couldn't open display '%s'\n",
                        argv[0], XDisplayName(NULL));
                exit(1);
            }

            int number_of_screens = ScreenCount(dpy);
            starting_screen = kdesktop_screen_number = DefaultScreen(dpy);
            int pos;
            TQCString display_name = XDisplayString(dpy);
            XCloseDisplay(dpy);
            kdDebug() << "screen " << number_of_screens << " " << kdesktop_screen_number << " " << display_name << " " << starting_screen << endl;
            dpy = 0;

            if ((pos = display_name.findRev('.')) != -1)
                display_name.remove(pos, 10);

            TQCString env;
            if (number_of_screens != 1) {
                for (int i = 0; i < number_of_screens; i++) {
                    if (i != starting_screen) {
                        int fd[2];
                        if (pipe(fd)) {
                            perror("pipe");
                            break;
                        }
                        if (fork() == 0) {
                            child = true;
                            kdesktop_screen_number = i;
                            parent_connection = fd[0];
                            // break here because we are the child process, we don't
                            // want to fork() anymore
                            break;
                        } else {
                            child_sockets.append(fd[1]);
                        }
                    }
                }

                env.sprintf("DISPLAY=%s.%d", display_name.data(),
                            kdesktop_screen_number);
                kdDebug() << "env " << env << endl;

                if (putenv(strdup(env.data()))) {
                    fprintf(stderr,
                            "%s: WARNING: unable to set DISPLAY environment variable\n",
                            argv[0]);
                    perror("putenv()");
                }
            }
        }

        MyApp app;
        kdDebug() << "app " << kdesktop_screen_number << " " << starting_screen << " " << child << " " << child_sockets.count() << " " << parent_connection << endl;
        app.disableSessionManagement();
        KGlobal::locale()->insertCatalogue("libdmctl");

        // we need to read from the right rc file - possibly taking screen number in account
        KDesktopSettings::instance("kdesktoprc");

        trinity_desktop_lock_use_system_modal_dialogs = !KDesktopSettings::useUnmanagedLockWindows();
        trinity_desktop_lock_delay_screensaver_start = KDesktopSettings::delaySaverStart();

        struct stat st;
        KSimpleConfig* tdmconfig;
        if( stat( KDE_CONFDIR "/tdm/tdmdistrc" , &st ) == 0) {
            tdmconfig = new KSimpleConfig( TQString::fromLatin1( KDE_CONFDIR "/tdm/tdmdistrc" ));
        }
        else {
            tdmconfig = new KSimpleConfig( TQString::fromLatin1( KDE_CONFDIR "/tdm/tdmrc" ));
        }
        tdmconfig->setGroup("X-*-Greeter");
        trinity_desktop_lock_use_sak = tdmconfig->readBoolEntry("UseSAK", true);

        LockProcess process;

        // Start loading core functions, such as the desktop wallpaper interface
        app.processEvents();

        if (args->isSet( "internal" )) {
            while (signalled_run == FALSE) {
                sigset_t new_mask;
                struct sigaction act;

                in_internal_mode = TRUE;

                // handle SIGUSR1
                act.sa_handler= sigusr1_handler;
                sigemptyset(&(act.sa_mask));
                sigaddset(&(act.sa_mask), SIGUSR1);
                act.sa_flags = 0;
                sigaction(SIGUSR1, &act, 0L);
                // handle SIGUSR2
                act.sa_handler= sigusr2_handler;
                sigemptyset(&(act.sa_mask));
                sigaddset(&(act.sa_mask), SIGUSR2);
                act.sa_flags = 0;
                sigaction(SIGUSR2, &act, 0L);
                // handle SIGWINCH (an ersatz SIGUSR3)
                act.sa_handler= sigusr3_handler;
                sigemptyset(&(act.sa_mask));
                sigaddset(&(act.sa_mask), SIGWINCH);
                act.sa_flags = 0;
                sigaction(SIGWINCH, &act, 0L);
                // handle SIGTTIN (an ersatz SIGUSR4)
                act.sa_handler= sigusr4_handler;
                sigemptyset(&(act.sa_mask));
                sigaddset(&(act.sa_mask), SIGTTIN);
                act.sa_flags = 0;
                sigaction(SIGTTIN, &act, 0L);
                // handle SIGTTOU (an ersatz SIGUSR5)
                act.sa_handler= sigusr5_handler;
                sigemptyset(&(act.sa_mask));
                sigaddset(&(act.sa_mask), SIGTTOU);
                act.sa_flags = 0;
                sigaction(SIGTTOU, &act, 0L);

                // initialize the signal masks
                sigfillset(&new_mask);
                sigdelset(&new_mask,SIGUSR1);
                sigdelset(&new_mask,SIGUSR2);
                sigdelset(&new_mask,SIGWINCH);
                sigdelset(&new_mask,SIGTTIN);
                sigdelset(&new_mask,SIGTTOU);

                // wait for SIGUSR1, SIGUSR2, SIGWINCH, SIGTTIN, or SIGTTOU
                sigsuspend(&new_mask);
            }
        }

        // Reload settings to make sure they reflect reality
        KDesktopSettings::self()->readConfig();
        tdmconfig->reparseConfiguration();
        trinity_desktop_lock_use_system_modal_dialogs = !KDesktopSettings::useUnmanagedLockWindows();
        trinity_desktop_lock_delay_screensaver_start = KDesktopSettings::delaySaverStart();
        if (trinity_desktop_lock_use_system_modal_dialogs) {
            trinity_desktop_lock_use_sak = tdmconfig->readBoolEntry("UseSAK", true);
        }
        else {
            trinity_desktop_lock_use_sak = false; // If SAK is enabled with unmanaged windows, the SAK dialog will never close and will "burn in" the screen
        }

        delete tdmconfig;

        if (args->isSet( "forcelock" ) || (signalled_forcelock == TRUE)) {
            trinity_desktop_lock_forced = TRUE;
        }

        process.init(child, (args->isSet( "blank" ) || (signalled_blank == TRUE)));
        if (!child) {
            process.setChildren(child_sockets);
        }
        else {
            process.setParent(parent_connection);
        }

        bool rt;
        bool sig = false;
        if( (((!child) && (args->isSet( "forcelock" ))) || (signalled_forcelock == TRUE))) {
            rt = process.lock();
            sig = true;
        }
        else if( child || (args->isSet( "dontlock" ) || (signalled_dontlock == TRUE))) {
            rt = process.dontLock();
        }
        else if( child || (args->isSet( "securedialog" ) || (signalled_securedialog == TRUE))) {
            int retcode = tde_sak_verify_calling_process();
            if (retcode == 0) {
                rt = process.runSecureDialog();
            }
            else {
                return 1;
            }
        }
        else {
            rt = process.defaultSave();
        }
        if (!rt) {
            return 0;
        }

        if( sig )
        {
            DCOPRef ref( "kdesktop", "KScreensaverIface");
            ref.send( "saverLockReady" );
        }

        if (in_internal_mode == FALSE) {
            return app.exec();
        }
        else {
            pid_t kdesktop_pid = atoi(args->getOption( "internal" ));
            app.exec();
            if (kill(kdesktop_pid, SIGUSR1) < 0) {
                // The controlling kdesktop process probably died.  Commit suicide...
                return 12;
            }

            // FIXME
            // We should not have to return (restart) at all,
            // but it seems that some X11 connections are left active,
            // preventing the lock process from restarting properly in the while() loop above.
            return 0;
        }
    }
}

#include "main.moc"