Finally the app-killer in the launcher works. TT solution was calling

ps with some special options, that busybox ps didn't provide. I'm now
scanning /proc/<pid>/stat for the right process.

2 files changed, 82 insertions, 51 deletions

diff --git a/core/launcher/runningappbar.cpp b/core/launcher/runningappbar.cpp
index c8f45d5..3ac66f2 100644
--- a/core/launcher/runningappbar.cpp
+++ b/core/launcher/runningappbar.cpp
@@ -15,135 +15,157 @@
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************
 */
 
 #define QTOPIA_INTERNAL_PRELOADACCESS
 
 // For "kill"
 #include <sys/types.h>
 #include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
 
+#include <qdir.h>
 #include <qtimer.h>
 #include <qpopupmenu.h>
 #include <qmessagebox.h>
 #include <qpainter.h>
-#include "qprocess.h"
+#include <opie/oprocess.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/applnk.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/global.h>
 #include <qwindowsystem_qws.h>
 #include "runningappbar.h"
 
 RunningAppBar::RunningAppBar(QWidget* parent)
   : QFrame(parent), m_AppLnkSet(0L), m_SelectedAppIndex(-1)
 {
     setBackgroundMode( PaletteBackground );
 
     m_AppLnkSet = new AppLnkSet( QPEApplication::qpeDir() + "apps" );
 
 #ifdef QWS
+
     connect(qwsServer, SIGNAL(newChannel(const QString&)), this, SLOT(newQcopChannel(const QString&)));
     connect(qwsServer, SIGNAL(removedChannel(const QString&)), this, SLOT(removedQcopChannel(const QString&)));
 #endif
+
     QCopChannel* channel = new QCopChannel( "QPE/System", this );
     connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
 	     this, SLOT(received(const QCString&, const QByteArray&)) );
 
     spacing = AppLnk::smallIconSize()+3;
 }
 
-RunningAppBar::~RunningAppBar() {
-}
+RunningAppBar::~RunningAppBar()
+{}
 
-void RunningAppBar::newQcopChannel(const QString& channelName) {
+void RunningAppBar::newQcopChannel(const QString& channelName)
+{
   QString prefix("QPE/Application/");
   if (channelName.startsWith(prefix)) {
     QString appName = channelName.mid(prefix.length());
 //     qDebug("App %s just connected!", appName.latin1());
     const AppLnk* newGuy = m_AppLnkSet->findExec(appName);
     if (newGuy && !newGuy->isPreloaded()) {
       addTask(*newGuy);
     }
   }
 }
 
-void RunningAppBar::removedQcopChannel(const QString& channelName) {
+void RunningAppBar::removedQcopChannel(const QString& channelName)
+{
   QString prefix("QPE/Application/");
   if (channelName.startsWith(prefix)) {
     QString appName = channelName.mid(prefix.length());
     qDebug("App %s just disconnected!", appName.latin1());
     const AppLnk* newGuy = m_AppLnkSet->findExec(appName);
     if (newGuy) {
       removeTask(*newGuy);
     }
   }
 }
 
-void RunningAppBar::received(const QCString& msg, const QByteArray& data) {
+void RunningAppBar::received(const QCString& msg, const QByteArray& data)
+{
   // Since fast apps appear and disappear without disconnecting from their
   // channel we need to watch for the showing/hiding events and update according.
   QDataStream stream( data, IO_ReadOnly );
   if ( msg == "fastAppShowing(QString)") {
     QString appName;
     stream >> appName;
     addTask(*m_AppLnkSet->findExec(appName));
-  } else if ( msg == "fastAppHiding(QString)") {
+	}
+	else if ( msg == "fastAppHiding(QString)") {
     QString appName;
     stream >> appName;
     removeTask(*m_AppLnkSet->findExec(appName));
   }
 }
 
-void RunningAppBar::addTask(const AppLnk& appLnk) {
+void RunningAppBar::addTask(const AppLnk& appLnk)
+{
 //   qDebug("Added %s to app list.", appLnk.name().latin1());
   AppLnk* newApp = new AppLnk(appLnk);
   newApp->setExec(appLnk.exec());
   m_AppList.prepend(newApp);
   update();
 }
 
-void RunningAppBar::removeTask(const AppLnk& appLnk) {
+void RunningAppBar::removeTask(const AppLnk& appLnk)
+{
   unsigned int i = 0;
   for (; i < m_AppList.count() ; i++) {
     AppLnk* target = m_AppList.at(i);
     if (target->exec() == appLnk.exec()) {
         qDebug("Removing %s from app list.", appLnk.name().latin1());
         m_AppList.remove();
+
+			// grab the keyboard back, in case the app crashed/forgot
+
+			QPEApplication *qpeapp = (QPEApplication *) qApp;
+
+			if ( appLnk.exec() == qpeapp-> keyboardGrabbedBy ( )) {
+				qDebug ( "grabbing keyboard back from %s", appLnk.name().latin1());
+				qpeapp-> grabKeyboard ( );
+			}
+
       delete target;
     }
   }
   update();
 }
 
 void RunningAppBar::mousePressEvent(QMouseEvent *e)
 {
   // Find out if the user is clicking on an app icon...
   // If so, snag the index so when we repaint we show it
   // as highlighed.
   m_SelectedAppIndex = 0;
   int x=0;
   QListIterator<AppLnk> it( m_AppList );
   for ( ; it.current(); ++it,++m_SelectedAppIndex,x+=spacing ) {
     if ( x + spacing <= width() ) {
       if ( e->x() >= x && e->x() < x+spacing ) {
 	if ( m_SelectedAppIndex < (int)m_AppList.count() ) {
 	  repaint(FALSE);
 	  return;
 	}
       }
-    } else {
+		}
+		else {
       break;
     }
   }
   m_SelectedAppIndex = -1;
   repaint( FALSE );
 }
 
 void RunningAppBar::mouseReleaseEvent(QMouseEvent *e)
 {
   if (e->button() == QMouseEvent::RightButton) {
     return;
   }
@@ -188,104 +210,113 @@ void RunningAppBar::paintEvent( QPaintEvent * )
       }
     }
 }
 
 QSize RunningAppBar::sizeHint() const
 {
     return QSize( frameWidth(), AppLnk::smallIconSize()+frameWidth()*2+3 );
 }
 
 const int AppMonitor::RAISE_TIMEOUT_MS = 500;
 
 AppMonitor::AppMonitor(const AppLnk& app, RunningAppBar& owner)
-  : QObject(0L), m_Owner(owner), m_App(app), m_PsProc(0L), m_AppKillerBox(0L) {
+		: QObject(0L), m_Owner(owner), m_App(app), m_AppKillerBox(0L)
+{
   QCopChannel* channel = new QCopChannel( "QPE/System", this );
   connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
 	   this, SLOT(received(const QCString&, const QByteArray&)) );
   connect(&m_Timer, SIGNAL(timeout()), this, SLOT(timerExpired()));
   m_Timer.start(RAISE_TIMEOUT_MS, TRUE);
 }
 
-AppMonitor::~AppMonitor() {
+AppMonitor::~AppMonitor()
+{
   if (m_AppKillerBox) {
     delete m_AppKillerBox;
     m_AppKillerBox = 0L;
   }
 }
 
-void AppMonitor::received(const QCString& msg, const QByteArray& data) {
+void AppMonitor::received(const QCString& msg, const QByteArray& data)
+{
   QDataStream stream( data, IO_ReadOnly );
 
   if (msg == "appRaised(QString)") {
     QString appName;
     stream >> appName;
     if (appName == m_App.exec()) {
       // qDebug("Got a heartbeat from %s", appName.latin1());
       m_Timer.stop();
       // Check to make sure we're not waiting on user input...
       if (m_AppKillerBox) {
 	// If we are, we kill the dialog box, and the code waiting on the result
 	// will clean us up (basically the user said "no").
 	delete m_AppKillerBox;
 	m_AppKillerBox = 0L;
       }
       else {
 	// Ok, we're not waiting on user input, so clean us up now.
 	// WE DELETE OURSELVES HERE!  Don't do anything else!!
 	delete this;
       }
     }
   }
 }
 
-void AppMonitor::timerExpired() {
-  //   qDebug("Checking in on %s", m_App.name().latin1());
+void AppMonitor::timerExpired()
+{
   // We store this incase the application responds while we're
   // waiting for user input so we know not to delete ourselves.  This
   // will be cleaned up in the destructor.
   m_AppKillerBox = new QMessageBox(tr("Application Problem"),
 				   tr("<p>%1 is not responding.</p>").arg(m_App.name()) +
 				   tr("<p>Would you like to force the application to exit?</p>"),
 				   QMessageBox::Warning, QMessageBox::Yes,
 				   QMessageBox::No | QMessageBox::Default,
 				   QMessageBox::NoButton);
   if (m_AppKillerBox->exec()  == QMessageBox::Yes) {
-    // qDebug("Killing the app!!! Bwuhahahaha!");
-    m_PsProc = new  QProcess(QString("ps"));
-    m_PsProc->addArgument("h");
-    m_PsProc->addArgument("-C");
-    m_PsProc->addArgument(m_App.exec());
-    m_PsProc->addArgument("-o");
-    m_PsProc->addArgument("pid");
-    connect(m_PsProc, SIGNAL(processExited()), this, SLOT(psProcFinished()));
-    m_PsProc->start();
-  }
-  else {
-    // qDebug("Wuss..");
-    // WE DELETE OURSELVES HERE!  Don't do anything else!!
-    delete this;
-  }
-}
+		QDir proc ( "/proc/", "[0-9]*", QDir::Name | QDir::Reversed, QDir::Dirs );
+		QStringList allprocs = proc. entryList ( );
 
-void AppMonitor::psProcFinished() {
-  QString pid = m_PsProc->readLineStdout();
-  delete m_PsProc;
-  m_PsProc = 0L;
+		pid_t mypid = ::getpid ( );
 
-  // qDebug("Killing app %s", pid.latin1());
-  if (pid.isEmpty()) {
-    // Hmm.. did the application bail before we got there?
-    qDebug("AppMonitor: Tried to kill application %s but ps couldn't find it.", m_App.exec().latin1());
-  }
-  else {
-    int success = kill(pid.toUInt(), SIGKILL);
-    if (success == 0) {
+		for ( QStringList::Iterator it = allprocs. begin ( ); it != allprocs. end ( ); ++it ) {
+			if (( *it ). toInt ( ) <= mypid ) // only interested in children
+				continue;
+
+			QCString s = QString ( "/proc/" + *it + "/stat" ). local8Bit ( );
+
+			FILE *fp = ::fopen ( s. data ( ), "r" );
+			if ( fp ) {
+				pid_t pid, ppid;
+				char *execptr, *exec = 0;
+
+				if ( ::fscanf ( fp, "%d %as %*c %d ", &pid, &execptr, &ppid ) == 3 ) {
+					exec = execptr [0] ? execptr + 1 : execptr;
+					if ( exec [0] )
+						exec [::strlen ( exec ) - 1] = 0;
+
+					if (( ppid == ::getpid ( )) && ( m_App. exec ( ). local8Bit ( ) == exec )) {
+						bool success = false;
+
+						qDebug ( "trying to kill pid=%d, exec=%s, ppid=%d", pid, exec, ppid );
+
+
+						success |= ( ::kill ( pid, SIGTERM ) == 0 );
+						::usleep ( 1000 * 500 );
+						success |= ( ::kill ( pid, SIGKILL ) == 0 );
+
+						if ( success )
       m_Owner.removeTask(m_App);
+
+						::free ( execptr );
+						break;
+					}
+					::free ( execptr );
+				}
+				::fclose ( fp );
     }
-    else {
-      qWarning("Could not kill task %s", m_App.exec().latin1());
     }
   }
-
-  // WE DELETE OURSELVES HERE!  Don't do anything else!!
   delete this;
 }
+
diff --git a/core/launcher/runningappbar.h b/core/launcher/runningappbar.h
index 880bb69..eb5880e 100644
--- a/core/launcher/runningappbar.h
+++ b/core/launcher/runningappbar.h
@@ -22,25 +22,26 @@
 #define RUNNING_APP_BAR_H
 
 #include <qframe.h>
 #include <qlist.h>
 #include <qtimer.h>
 
 class AppLnk;
 class AppLnkSet;
 class QCString;
 class QProcess;
 class QMessageBox;
 
-class RunningAppBar : public QFrame {
+class RunningAppBar : public QFrame
+{
   Q_OBJECT
 
  public:
   RunningAppBar(QWidget* parent);
   ~RunningAppBar();
   
   void addTask(const AppLnk& appLnk);
   void removeTask(const AppLnk& appLnk);
   void paintEvent(QPaintEvent* event);
   void mousePressEvent(QMouseEvent*);
   void mouseReleaseEvent(QMouseEvent*);
   QSize sizeHint() const;
@@ -53,36 +54,35 @@ class RunningAppBar : public QFrame {
  private:
   AppLnkSet* m_AppLnkSet;
   QList<AppLnk> m_AppList;
   int m_SelectedAppIndex;
   int spacing;
 };
 
 /**
  * Internal class that checks back in on the process when timerExpired is called
  * to make sure the process is on top.  If it's not it displays a dialog
  * box asking permission to kill it.
  */
-class AppMonitor : public QObject {
+class AppMonitor : public QObject
+{
   Q_OBJECT
     
  public:
   static const int RAISE_TIMEOUT_MS;
 
   AppMonitor(const AppLnk& app, RunningAppBar& owner);
   ~AppMonitor();
   
   private slots:
     void timerExpired();
     void received(const QCString& msg, const QByteArray& data);
-    void psProcFinished();
 
  private:
   RunningAppBar& m_Owner;
   const AppLnk& m_App;
   QTimer m_Timer;
-  QProcess* m_PsProc;
   QMessageBox* m_AppKillerBox;
 };
 
 #endif