Wt

Hello everyone

I am relatively new to Wt and C overall and I have reached a dead end for me:

I depend on a library that has a C function pointer callback API, and Wt crashes when I use that API. (Using Wt 3.3.4, which comes with my Linux distribution.)

To point out my problem, I have created a minimal example. Instead of my library, it uses a C-Style callback for SIGUSR1, which should be more readily available and suffices to reproduce the error.

The code consists of three classes:

CallbackWrapper (attempts to make a callback available to Wt via Signal/Slot-mechanism based on the information given in the Signal Slot System Description),

MyWidget (displays number of received callbacks on a Website) and

DisplayApplication, the seemingly obligatory Application class where things are being put in motion.

Expected behavior: The Website content text counts +1 for every received SIGUSR1

Actual behavior: Segmentation Fault as soon as the SIGUSR1-Signal is being sent to the Wt-Application

The example works when the callback for SIGUSR1 is replaced with a WTimer.

Any hint towards which part of my thinking/code is erroneous would be greatly appreciated.

If I forgot to mention anything crucial, please let me know.

The code:

#include <Wt/WApplication>
#include <Wt/WObject>
#include <Wt/WSignal>
#include <Wt/WContainerWidget>
#include <Wt/WText>

#include <csignal>


extern "C" {
        void interrupt_func(int signum);
}

class CallbackWrapper;
static CallbackWrapper * device;

class CallbackWrapper : public Wt::WObject {
        public:
                CallbackWrapper(Wt::WObject *parent=0)
                        : Wt::WObject(parent),
                        sig(this)
                {
                        device=this;
                        signal(SIGUSR1, interrupt_func);
                }

                Wt::Signal<>& intReceived() { return sig; }
                void interrupt() { sig.emit(); }

        private:
                Wt::Signal<> sig;
};

void interrupt_func(int signum) {
        device->interrupt();
}



class MyWidget : public Wt::WContainerWidget {
        public:
                MyWidget(Wt::WContainerWidget * parent=0)
                        : Wt::WContainerWidget(parent),
                        callback_wrapper(new CallbackWrapper()),
                        int_nr(0)
        {
                int_nr_text=new Wt::WText("interrupts: 0");
                addWidget(int_nr_text);
                addWidget(new Wt::WBreak());

                callback_wrapper->intReceived().connect(this, &MyWidget::increment_int_nr);
        }

        void increment_int_nr() {
                int_nr_text->setText(Wt::WString::fromUTF8("interrupts: {1}").arg(++int_nr));
        }

        private:
                CallbackWrapper * callback_wrapper;
                int int_nr;
                Wt::WText * int_nr_text;
};

class DisplayApplication : public Wt::WApplication {
        public:
                DisplayApplication(const Wt::WEnvironment& env)
                        : Wt::WApplication(env)
                {
        root()->addWidget(new MyWidget());
                }
};

Wt::WApplication *createApplication(const Wt::WEnvironment& env) {

        return new DisplayApplication(env);
}

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

        return Wt::WRun(argc, argv, &createApplication);
}

Compiled with g++ minimal_example.cpp -lwthttp -lwt -o application

Started with ./application --docroot . --http-address 0.0.0.0 --http-port 8065

The USR1-Signal is sent to the running program with kill -USR1 $(pidof "application")