How to unblock a QThread running a pcsc call?

Question

I have a Qt application that connects to a card reader using various pcsc implementations under GNU/Linux, MacOS, and Windows. All communication with the card runs in a worker thread.

In one scenario, the user starts an operation requiring communication with the card via a card reader. The card reader has a keyboard and during the authentication procedure the user must enter their PIN on the reader's keyboard.

This operation is implemented by a call to SCardControl() (see e.g. the Microsoft documentation). As long as the user is working with the reader, the call to SCardControl() does not terminate and the worker thread is blocked by it.

At this point, the user might decide to close the application while the operation is still pending. Closing the application at this point causes the application to crash (on Linux with signal SIGABRT) because:

1. The worker thread is blocked waiting for SCardControl() to return.
2. The main thread cannot stop the blocked thread: neither quit() nor terminate() cause the thread to finish.
3. When the application is exited, the QThread object for the worker thread is destroyed and, since the thread is still running state, it throws a signal to indicate an error.

I have tried several solutions.

1. Subclass QThread and create a worker thread which calls setTerminationEnabled(true); to allow termination through QThread::terminate(). This does not work on MacOS: when QThread is destroyed, the thread is still in a running state and the signal SIGABRT is emitted.
2. Handle signal SIGABRT on shutdown and ignore it. This did not seem to be a good idea but I wanted to try it out before discarding it. After ignoring signal SIGABRT, a signal SIGSEGV is received and the application crashes. I had adapted the approach described here.
3. Try to unblock the thread by sending a command to the card reader from the main thread. I tried SCardCancel(), SCardDisconnect() and SCardReleaseContext() but none of these commands has any effect on the blocked thread.

I find it quite strange that it is not possible to cleanly shutdown an application when a thread is blocked on some function call, but all the solutions I have tried have not worked and I have run out of ideas. Did I overlook something? Does anybody have any useful hint?

EDIT

I looked into the Qt source code for QThread and found out that on Unix-like platforms QThread::terminate() uses pthread_cancel() internally. But apparently pthread_cancel() does not work / does nothing on Darwin, see e.g. here and here.

So, maybe I will really have to go with the option of showing a dialog to the user asking to remove the card from the reader.

Answer 1

Cleanly shutting down a thread is not possible from outside if it is blocked in a call. You can, however, prevent user from quitting the application before the operation has completed.

void MainWindow::closeEvent(QCloseEvent *closeEvent) {
     if (workerBlocked) closeEvent->ignore();
}

In addition, you can show a dialog telling the user the operation has to be completed first.

Also, if possible, you can let the window close but keep the application alive until the operation is complete by setting qApp->setQuitOnLastWindowClosed(false);

Answer 2

The problem boils down to the fact that a QThread object isn't destructible while the associated thread is running. Usually, it would a print statement like this to the debug output:

QThread: Destroyed while thread is still running

Don't agonize over trying to get SCardControl to return so that the worker thread can be quit safely (since it doesn't return as long as the user is interacting with the reader). Instead, You can follow this answer to destruct the QThread object in a safe manner with a minimum amount of changes to your current implementation.

Here is an example that shows what I mean:

#include <QtWidgets>

//a thread that can be destroyed at any time
//see http://stackoverflow.com/a/25230470
class SafeThread : public QThread{
    using QThread::run;
public:
    explicit SafeThread(QObject* parent= nullptr):QThread(parent){}
    ~SafeThread(){ quit(); wait(); }
};

//worker QObject class
class Worker : public QObject {
    Q_OBJECT
public:
    explicit Worker(QObject* parent = nullptr):QObject(parent){}
    ~Worker(){}

    Q_SLOT void doBlockingWork() {
        emit started();
        //the sleep call blocks the worker thread for 10 seconds!
        //consider it a mock call to the SCardControl function
        QThread::sleep(10);
        emit finished();
    }

    Q_SIGNAL void started();
    Q_SIGNAL void finished();
};


int main(int argc, char* argv[]) {
    QApplication a(argc, argv);

    //setup worker thread and QObject
    Worker worker;
    SafeThread thread;
    worker.moveToThread(&thread);
    thread.start();

    //setup GUI components
    QWidget w;
    QVBoxLayout layout(&w);
    QPushButton button("start working");
    QLabel status("idle");
    layout.addWidget(&button);
    layout.addWidget(&status);

    //connect signals/slots
    QObject::connect(&worker, &Worker::started, &status,
                     [&status]{ status.setText("working. . .");} );
    QObject::connect(&worker, &Worker::finished, &status,
                     [&status]{ status.setText("idle");} );
    QObject::connect(&button, &QPushButton::clicked, &worker, &Worker::doBlockingWork);

    w.show();
    return a.exec();
}

#include "main.moc"

Notice that the SafeThread's destructor makes sure to wait() until the associated thread has finished execution. And only afterwards, the main thread can proceed to call QThread's destructor.