Use safe thread class instead of std::thread

src/logid/backend/dj/Receiver.cpp

@@ -20,6 +20,7 @@
 #include "Report.h"
 #include "Receiver.h"
 #include "Error.h"
+#include "../../util/thread.h"
 
 using namespace logid::backend::dj;
 using namespace logid::backend;
@@ -214,13 +215,14 @@ std::string Receiver::getDeviceName(hidpp::DeviceIndex index)
     return name;
 }
 
-hidpp::DeviceIndex Receiver::deviceDisconnectionEvent(hidpp::Report& report)
+hidpp::DeviceIndex Receiver::deviceDisconnectionEvent(const hidpp::Report&
+report)
 {
     assert(report.subId() == DeviceDisconnection);
     return report.deviceIndex();
 }
 
-hidpp::DeviceConnectionEvent Receiver::deviceConnectionEvent(
+hidpp::DeviceConnectionEvent Receiver::deviceConnectionEvent(const
         hidpp::Report &report)
 {
     assert(report.subId() == DeviceConnection);
@@ -322,7 +324,10 @@ Receiver::ConnectionStatusEvent Receiver::connectionStatusEvent(Report& report)
 void Receiver::listen()
 {
     if(!_raw_device->isListening())
-        std::thread{[this]() { this->_raw_device->listen(); }}.detach();
+        ///TODO: Kill RawDevice?
+        thread::spawn({[raw=this->_raw_device]() {
+            raw->listen();
+        }});
 
     if(_raw_device->eventHandlers().find("RECV_HIDPP") ==
         _raw_device->eventHandlers().end()) {

src/logid/backend/dj/Receiver.h

@@ -140,9 +140,9 @@ namespace dj
         std::string getDeviceName(hidpp::DeviceIndex index);
 
         static hidpp::DeviceIndex deviceDisconnectionEvent(
-                hidpp::Report& report);
+                const hidpp::Report& report);
         static hidpp::DeviceConnectionEvent deviceConnectionEvent(
-                hidpp::Report& report);
+                const hidpp::Report& report);
 
         void listen();
         void stopListening();

src/logid/backend/dj/ReceiverMonitor.cpp

@@ -17,6 +17,8 @@
  */
 
 #include "ReceiverMonitor.h"
+#include "../../util/thread.h"
+#include "../../util.h"
 
 #include <utility>
 #include <cassert>
@@ -55,14 +57,24 @@ void ReceiverMonitor::run()
             /* Running in a new thread prevents deadlocks since the
              * receiver may be enumerating.
              */
-            std::thread{[this](hidpp::Report report) {
+            thread::spawn({[this, report]() {
                 if (report.subId() == Receiver::DeviceConnection)
-                    this->addDevice(this->_receiver->deviceConnectionEvent(
-                            report));
+                    this->addDevice(this->_receiver->deviceConnectionEvent
+                    (report));
                 else if (report.subId() == Receiver::DeviceDisconnection)
                     this->removeDevice(this->_receiver->
                             deviceDisconnectionEvent(report));
-            }, report}.detach();
+            }}, {[report, path=this->_receiver->rawDevice()->hidrawPath()]
+            (std::exception& e) {
+                if(report.subId() == Receiver::DeviceConnection)
+                    log_printf(ERROR, "Failed to add device %d to receiver "
+                                      "on %s: %s", report.deviceIndex(),
+                                      path.c_str(), e.what());
+                else if(report.subId() == Receiver::DeviceDisconnection)
+                    log_printf(ERROR, "Failed to remove device %d from "
+                                      "receiver on %s: %s", report.deviceIndex()
+                                      ,path.c_str(), e.what());
+            }});
         };
 
         _receiver->addHidppEventHandler("RECVMON", event_handler);

src/logid/backend/hidpp/Device.cpp

@@ -18,6 +18,7 @@
 
 #include <cassert>
 #include <utility>
+#include "../../util/thread.h"
 #include "Device.h"
 #include "Report.h"
 #include "../hidpp20/features/Root.h"
@@ -182,7 +183,10 @@ Report Device::sendReport(Report& report)
 void Device::listen()
 {
     if(!_raw_device->isListening())
-        std::thread{[=]() { _raw_device->listen(); }}.detach();
+        ///TODO: Kill RawDevice?
+        thread::spawn({[raw=this->_raw_device]() {
+            raw->listen();
+        }});
 
     // Pass all HID++ events with device index to this device.
     std::shared_ptr<raw::RawEventHandler> handler;

src/logid/backend/hidpp/Report.cpp

@@ -199,7 +199,7 @@ void Report::setType(Report::Type type)
     _data[Offset::Type] = type;
 }
 
-hidpp::DeviceIndex Report::deviceIndex()
+hidpp::DeviceIndex Report::deviceIndex() const
 {
     return static_cast<hidpp::DeviceIndex>(_data[Offset::DeviceIndex]);
 }
@@ -261,6 +261,26 @@ void Report::setAddress(uint8_t address)
     _data[Offset::Address] = address;
 }
 
+std::vector<uint8_t>::iterator Report::paramBegin()
+{
+    return _data.begin() + Offset::Parameters;
+}
+
+std::vector<uint8_t>::iterator Report::paramEnd()
+{
+    return _data.end();
+}
+
+std::vector<uint8_t>::const_iterator Report::paramBegin() const
+{
+    return _data.begin() + Offset::Parameters;
+}
+
+std::vector<uint8_t>::const_iterator Report::paramEnd() const
+{
+    return _data.end();
+}
+
 void Report::setParams(const std::vector<uint8_t>& _params)
 {
     assert(_params.size() <= _data.size()-HeaderLength);

src/logid/backend/hidpp/Report.h

@@ -78,7 +78,7 @@ namespace hidpp
         Report::Type type() const;
         void setType(Report::Type type);
 
-        logid::backend::hidpp::DeviceIndex deviceIndex();
+        logid::backend::hidpp::DeviceIndex deviceIndex() const;
         void setDeviceIndex(hidpp::DeviceIndex index);
 
         uint8_t feature() const;
@@ -96,11 +96,10 @@ namespace hidpp
         uint8_t address() const;
         void setAddress(uint8_t address);
 
-        std::vector<uint8_t>::iterator paramBegin()
-        {
-            return _data.begin() + Offset::Parameters;
-        }
-        std::vector<uint8_t>::iterator paramEnd() { return _data.end(); }
+        std::vector<uint8_t>::iterator paramBegin();
+        std::vector<uint8_t>::iterator paramEnd();
+        std::vector<uint8_t>::const_iterator paramBegin() const;
+        std::vector<uint8_t>::const_iterator paramEnd() const;
         void setParams(const std::vector<uint8_t>& _params);
 
         struct Hidpp10Error

src/logid/backend/raw/DeviceMonitor.cpp

@@ -17,6 +17,8 @@
  */
 
 #include "DeviceMonitor.h"
+#include "../../util/thread.h"
+#include "../../util.h"
 
 #include <thread>
 #include <system_error>
@@ -96,13 +98,19 @@ void DeviceMonitor::run()
             std::string devnode = udev_device_get_devnode(device);
 
             if (action == "add")
-                std::thread([this](const std::string name) {
+                thread::spawn([this, name=devnode]() {
                     this->addDevice(name);
-                }, devnode).detach();
+                }, [name=devnode](std::exception& e){
+                    log_printf(WARN, "Error adding device %s: %s",
+                            name.c_str(), e.what());
+                });
             else if (action == "remove")
-                std::thread([this](const std::string name) {
+                thread::spawn([this, name=devnode]() {
                     this->removeDevice(name);
-                }, devnode).detach();
+                }, [name=devnode](std::exception& e){
+                    log_printf(WARN, "Error removing device %s: %s",
+                               name.c_str(), e.what());
+                });
 
             udev_device_unref (device);
         }
@@ -149,9 +157,12 @@ void DeviceMonitor::enumerate()
         std::string devnode = udev_device_get_devnode(device);
         udev_device_unref(device);
 
-        std::thread([this](const std::string& name) {
+        thread::spawn([this, name=devnode]() {
             this->addDevice(name);
-        }, devnode).detach();
+        }, [name=devnode](std::exception& e){
+            log_printf(ERROR, "Error adding device %s: %s",
+                       name.c_str(), e.what());
+        });
     }
 
     udev_enumerate_unref(udev_enum);