1 files changed, 122 insertions, 0 deletions
diff --git a/meta-app-framework/recipes-security/security-manager/security-manager/0012-Avoid-casting-from-const-T-to-void.patch b/meta-app-framework/recipes-security/security-manager/security-manager/0012-Avoid-casting-from-const-T-to-void.patch
new file mode 100644
index 000000000..91ccf9ee2
--- /dev/null
+++ b/meta-app-framework/recipes-security/security-manager/security-manager/0012-Avoid-casting-from-const-T-to-void.patch
@@ -0,0 +1,122 @@
+From 5ee51d38575f289c2bf37ed817ef680ed47bb320 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Jos=C3=A9=20Bollo?= <jose.bollo@iot.bzh>
+Date: Fri, 1 Feb 2019 15:37:44 +0100
+Subject: [PATCH 12/14] Avoid casting from "const T&" to "void*"
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Latest version of g++ refuse the cast
+
+     reinterpret_cast<void (Service::*)(void*)>(serviceFunction)
+
+I made no investigation to know if the problem
+is coming from the const or not.
+
+Signed-off-by: José Bollo <jose.bollo@iot.bzh>
+---
+ src/server/main/include/service-thread.h | 42 ++++++++++--------------
+ 1 file changed, 18 insertions(+), 24 deletions(-)
+
+diff --git a/src/server/main/include/service-thread.h b/src/server/main/include/service-thread.h
+index 964d168..61fdda8 100644
+--- a/src/server/main/include/service-thread.h
++++ b/src/server/main/include/service-thread.h
+@@ -94,7 +94,7 @@ public:
+             Join();
+         while (!m_eventQueue.empty()){
+             auto front = m_eventQueue.front();
+-            delete front.eventPtr;
++            delete front;
+             m_eventQueue.pop();
+         }
+     }
+@@ -104,34 +104,28 @@ public:
+                Service *servicePtr,
+                void (Service::*serviceFunction)(const T &))
+     {
+-        EventDescription description;
+-        description.serviceFunctionPtr =
+-            reinterpret_cast<void (Service::*)(void*)>(serviceFunction);
+-        description.servicePtr = servicePtr;
+-        description.eventFunctionPtr = &ServiceThread::EventCall<T>;
+-        description.eventPtr = new T(event);
++        EventCallerBase *ec = new EventCaller<T>(event, servicePtr, serviceFunction);
+         {
+             std::lock_guard<std::mutex> lock(m_eventQueueMutex);
+-            m_eventQueue.push(description);
++            m_eventQueue.push(ec);
+         }
+         m_waitCondition.notify_one();
+     }
+ 
+ protected:
+ 
+-    struct EventDescription {
+-        void (Service::*serviceFunctionPtr)(void *);
+-        Service *servicePtr;
+-        void (ServiceThread::*eventFunctionPtr)(const EventDescription &event);
+-        GenericEvent* eventPtr;
++    struct EventCallerBase {
++       virtual void fire() = 0;
++       virtual ~EventCallerBase() {}
+     };
+ 
+     template <class T>
+-    void EventCall(const EventDescription &desc) {
+-        auto fun = reinterpret_cast<void (Service::*)(const T&)>(desc.serviceFunctionPtr);
+-        const T& eventLocale = *(static_cast<T*>(desc.eventPtr));
+-        (desc.servicePtr->*fun)(eventLocale);
+-    }
++    struct EventCaller : public EventCallerBase {
++        T *event; Service *target; void (Service::*function)(const T&);
++        EventCaller(const T &e, Service *c, void (Service::*f)(const T&)) : event(new T(e)), target(c), function(f) {}
++	~EventCaller() { delete event; }
++	void fire() { (target->*function)(*event); }
++    };
+ 
+     static void ThreadLoopStatic(ServiceThread *ptr) {
+         ptr->ThreadLoop();
+@@ -139,33 +133,33 @@ protected:
+ 
+     void ThreadLoop(){
+         for (;;) {
+-            EventDescription description = {NULL, NULL, NULL, NULL};
++            EventCallerBase *ec = NULL;
+             {
+                 std::unique_lock<std::mutex> ulock(m_eventQueueMutex);
+                 if (m_quit)
+                     return;
+                 if (!m_eventQueue.empty()) {
+-                    description = m_eventQueue.front();
++                    ec = m_eventQueue.front();
+                     m_eventQueue.pop();
+                 } else {
+                     m_waitCondition.wait(ulock);
+                 }
+             }
+ 
+-            if (description.eventPtr != NULL) {
++            if (ec != NULL) {
+                 UNHANDLED_EXCEPTION_HANDLER_BEGIN
+                 {
+-                    (this->*description.eventFunctionPtr)(description);
+-                    delete description.eventPtr;
++                    ec->fire();
+                 }
+                 UNHANDLED_EXCEPTION_HANDLER_END
++                delete ec;
+             }
+         }
+     }
+ 
+     std::thread m_thread;
+     std::mutex m_eventQueueMutex;
+-    std::queue<EventDescription> m_eventQueue;
++    std::queue<EventCallerBase*> m_eventQueue;
+     std::condition_variable m_waitCondition;
+ 
+     State m_state;
+-- 
+2.21.0
+