c++ wrapper for libusb, add try/catch to prevent app crashes

CMakeLists.txt

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # With additions of Luxonis
 
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.3)
 
 include("cmake/HunterGate.cmake")
 HunterGate(
@@ -82,7 +82,7 @@ else()
 endif()
 
 if(WIN32)
-    target_compile_definitions(${TARGET_NAME} PRIVATE WIN32_LEAN_AND_MEAN)
+    target_compile_definitions(${TARGET_NAME} PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX)
 else()
     find_package(Threads REQUIRED)
     target_link_libraries(${TARGET_NAME} PRIVATE Threads::Threads)
@@ -140,18 +140,19 @@ endif()
 
 # Set C99 standard
 set_property(TARGET ${TARGET_NAME} PROPERTY C_STANDARD 99)
-# Set compiler features (c++11), and disables extensions (g++11)
-set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD 11)
+# Set compiler features (c++14), and disables extensions (g++14)
+set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD 14)
 set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
 set_property(TARGET ${TARGET_NAME} PROPERTY CXX_EXTENSIONS OFF)
-# Add interface transitive property (C++11) to public library
+# Add interface transitive property (C++14) to public library
 if(${CMAKE_VERSION} VERSION_LESS "3.8.0")
-    target_compile_features(${TARGET_PUBLIC_NAME} INTERFACE cxx_range_for)
+    target_compile_features(${TARGET_PUBLIC_NAME} INTERFACE cxx_generic_lambdas)
 else()
-    target_compile_features(${TARGET_PUBLIC_NAME} INTERFACE cxx_std_11)
+    target_compile_features(${TARGET_PUBLIC_NAME} INTERFACE cxx_std_14)
 endif()
 
 # Add flags
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 add_default_flags(${TARGET_NAME})
 
 # Check if pthread_getname_np exists

cmake/Flags.cmake

@@ -1,13 +1,19 @@
 ## setup compilation flags
 # conditionally applies flag. If flag is supported by current compiler, it will be added to compile options.
 include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
 function(add_flag target flag)
     check_c_compiler_flag(${flag} FLAG_${flag})
     if (FLAG_${flag} EQUAL 1)
         target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:C>:${flag}>)
     endif ()
+    check_cxx_compiler_flag(${flag} FLAGXX_${flag})
+    if (FLAGXX_${flag} EQUAL 1)
+        target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${flag}>)
+    endif ()
 endfunction()
 
+# only works for C source files
 function(add_flag_source source flag)
     check_c_compiler_flag(${flag} FLAG_${flag})
     if (FLAG_${flag} EQUAL 1)

examples/CMakeLists.txt

@@ -2,7 +2,7 @@
 macro(add_example example_name example_src)
     add_executable(${example_name} ${example_src})
     target_link_libraries(${example_name} ${TARGET_NAME})
-    set_property(TARGET ${example_name} PROPERTY CXX_STANDARD 11)
+    set_property(TARGET ${example_name} PROPERTY CXX_STANDARD 14)
     set_property(TARGET ${example_name} PROPERTY CXX_STANDARD_REQUIRED ON)
     set_property(TARGET ${example_name} PROPERTY CXX_EXTENSIONS OFF)
 

include/XLink/XLinkErrorUtils.h

@@ -15,7 +15,7 @@ extern "C"
     #ifndef ASSERT_XLINK
     #define ASSERT_XLINK(condition) do { \
             if(!(condition)) { \
-                mvLog(MVLOG_ERROR, "Assertion Failed: %s \n", #condition); \
+                mvLog(MVLOG_ERROR, "Assertion Failed: %s", #condition); \
                 return X_LINK_ERROR; \
             } \
         } while(0)
@@ -26,7 +26,7 @@ extern "C"
     #ifndef ASSERT_XLINK
     #define ASSERT_XLINK(condition) do { \
             if(!(condition)) { \
-                mvLog(MVLOG_ERROR, "Assertion Failed: %s \n", #condition); \
+                mvLog(MVLOG_ERROR, "Assertion Failed: %s", #condition); \
                 exit(EXIT_FAILURE); \
             } \
         } while(0)
@@ -88,7 +88,7 @@ extern "C"
 #define XLINK_OUT_IF(condition) do { \
         \
         XLINK_OUT_WITH_LOG_IF((condition), \
-            mvLog(MVLOG_ERROR, "Condition failed: %s \n", #condition));\
+            mvLog(MVLOG_ERROR, "Condition failed: %s", #condition));\
         \
     } while(0)
 #endif  // XLINK_OUT_IF

include/XLink/XLinkLog.h

@@ -44,12 +44,18 @@ typedef enum mvLog_t{
     MVLOG_LAST,
 } mvLog_t;
 
-// Windows-only
-#if (defined (WINNT) || defined(_WIN32) || defined(_WIN64) )
-#define __attribute__(x)
-#define FUNCATTR_WEAK static
+// attribute directive support test
+#if defined(__has_attribute)
+#  define MVLOG_ATTRIBUTE(x) __attribute__(x)
+// weak function support test
+#  if __has_attribute(weak)
+#    define FUNCATTR_WEAK
+#  else
+#    define FUNCATTR_WEAK static
+#  endif
 #else
-#define FUNCATTR_WEAK
+#  define MVLOG_ATTRIBUTE(x)
+#  define FUNCATTR_WEAK static
 #endif
 
 #define _MVLOGLEVEL(UNIT_NAME)  mvLogLevel_ ## UNIT_NAME
@@ -61,7 +67,7 @@ typedef enum mvLog_t{
 #ifndef MVLOG_UNIT_NAME
 #define MVLOG_UNIT_NAME global
 #else
-FUNCATTR_WEAK mvLog_t __attribute__ ((weak)) MVLOGLEVEL(MVLOG_UNIT_NAME) = MVLOG_LAST;
+FUNCATTR_WEAK mvLog_t MVLOG_ATTRIBUTE((weak)) MVLOGLEVEL(MVLOG_UNIT_NAME) = MVLOG_LAST;
 #endif
 
 
@@ -75,7 +81,7 @@ FUNCATTR_WEAK mvLog_t __attribute__ ((weak)) MVLOGLEVEL(MVLOG_UNIT_NAME) = MVLOG
 extern mvLog_t MVLOGLEVEL(global);
 extern mvLog_t MVLOGLEVEL(default);
 
-int __attribute__ ((unused)) logprintf(mvLog_t curLogLvl, mvLog_t lvl, const char * func, const int line, const char * format, ...);
+int MVLOG_ATTRIBUTE((unused)) logprintf(mvLog_t curLogLvl, mvLog_t lvl, const char * func, const int line, const char * format, ...);
 
 #define mvLog(lvl, format, ...)                              \
     logprintf(MVLOGLEVEL(MVLOG_UNIT_NAME), lvl, __func__, __LINE__, format, ##__VA_ARGS__)

include/XLink/XLinkPlatformErrorUtils.h

@@ -15,7 +15,7 @@ extern "C"
     #ifndef ASSERT_XLINK_PLATFORM_R
     #define ASSERT_XLINK_PLATFORM_R(condition, err) do { \
             if(!(condition)) { \
-                mvLog(MVLOG_ERROR, "Assertion Failed: %s \n", #condition); \
+                mvLog(MVLOG_ERROR, "Assertion Failed: %s", #condition); \
                 return (err); \
             } \
         } while(0)
@@ -34,7 +34,7 @@ extern "C"
     #ifndef ASSERT_XLINK_PLATFORM_R
     #define ASSERT_XLINK_PLATFORM_R(condition, err) do { \
                 if(!(condition)) { \
-                    mvLog(MVLOG_ERROR, "Assertion Failed: %s \n", #condition); \
+                    mvLog(MVLOG_ERROR, "Assertion Failed: %s", #condition); \
                     exit(EXIT_FAILURE); \
                 } \
             } while(0)

src/pc/PlatformDeviceControl.c

@@ -30,7 +30,7 @@ int usbFdRead = -1;
 #include "XLinkPublicDefines.h"
 
 #define USB_LINK_SOCKET_PORT 5678
-#define UNUSED __attribute__((unused))
+#define UNUSED MVLOG_ATTRIBUTE((unused))
 
 
 static UsbSpeed_t usb_speed_enum = X_LINK_USB_SPEED_UNKNOWN;

src/pc/PlatformDeviceFd.cpp

@@ -1,44 +1,102 @@
+#define MVLOG_UNIT_NAME xLinkUsb
+
 #include "PlatformDeviceFd.h"
+#include "XLink/XLinkLog.h"
 
-#include <unordered_map>
 #include <atomic>
-#include <mutex>
 #include <cstdint>
+#include <mutex>
+#include <unordered_map>
 
 static std::mutex mutex;
 static std::unordered_map<std::uintptr_t, void*> map;
 static std::uintptr_t uniqueFdKey{0x55};
 
-int getPlatformDeviceFdFromKey(void* fdKeyRaw, void** fd){
-    if(fd == nullptr) return -1;
-    std::unique_lock<std::mutex> lock(mutex);
-
-    std::uintptr_t fdKey = reinterpret_cast<std::uintptr_t>(fdKeyRaw);
-    if(map.count(fdKey) > 0){
-        *fd = map.at(fdKey);
+// Returns the mapped fd value of the element with key equivalent to fdKeyRaw
+// Non-zero return value indicates failure
+int getPlatformDeviceFdFromKey(void* const fdKeyRaw, void** const fd) noexcept {
+    if(fd == nullptr) {
+        mvLog(MVLOG_ERROR, "getPlatformDeviceFdFromKey/Simple(%p) failed", fdKeyRaw);
+        return -1;
+    }
+    try {
+        const std::lock_guard<std::mutex> lock(mutex);
+        const auto result = map.find(reinterpret_cast<std::uintptr_t>(fdKeyRaw));
+        if(result == map.end()) {
+            mvLog(MVLOG_ERROR, "getPlatformDeviceFdFromKey/Simple(%p) failed", fdKeyRaw);
+            return 1;
+        }
+        *fd = result->second;
+        //mvLog(MVLOG_DEBUG, "getPlatformDeviceFdFromKey(%p) result %p", fdKeyRaw, *fd);
         return 0;
-    } else {
-        return 1;
+    } catch(std::exception&) {
+        mvLog(MVLOG_ERROR, "getPlatformDeviceFdFromKey/Simple(%p) failed", fdKeyRaw);
+        return -1;
     }
 }
 
-void* createPlatformDeviceFdKey(void* fd){
-    std::unique_lock<std::mutex> lock(mutex);
-
-    // Get uniqueFdKey
-    std::uintptr_t fdKey = uniqueFdKey++;
-    map[fdKey] = fd;
-    return reinterpret_cast<void*>(fdKey);
+// Returns the mapped fd value of the element with key equivalent to fdKeyRaw
+// returns nullptr when not found, failure, or createPlatformDeviceFdKey(nullptr) was used
+void* getPlatformDeviceFdFromKeySimple(void* const fdKeyRaw) noexcept {
+    void* fd = nullptr;
+    getPlatformDeviceFdFromKey(fdKeyRaw, &fd);
+    return fd;
 }
 
-int destroyPlatformDeviceFdKey(void* fdKeyRaw){
-    std::unique_lock<std::mutex> lock(mutex);
+// Inserts a copy of value fd into an associative container with key fdKeyRaw
+// nullptr return value indicates failure
+void* createPlatformDeviceFdKey(void* const fd) noexcept {
+    try {
+        const std::lock_guard<std::mutex> lock(mutex);
+        const std::uintptr_t fdKey = uniqueFdKey++; // Get a unique key
+        map[fdKey] = fd;
+        mvLog(MVLOG_DEBUG, "createPlatformDeviceFdKey(%p) result %p", fd, reinterpret_cast<void*>(fdKey));
+        return reinterpret_cast<void*>(fdKey);
+    } catch(std::exception&) {
+        mvLog(MVLOG_ERROR, "createPlatformDeviceFdKey(%p) failed", fd);
+        return nullptr;
+    }
+}
 
-    std::uintptr_t fdKey = reinterpret_cast<std::uintptr_t>(fdKeyRaw);
-    if(map.count(fdKey) > 0){
-        map.erase(fdKey);
-        return 0;
-    } else {
+// Removes the element (if one exists) with the key equivalent to fdKeyRaw
+// Non-zero return value indicates failure
+int destroyPlatformDeviceFdKey(void* const fdKeyRaw) noexcept {
+    try {
+        std::lock_guard<std::mutex> lock(mutex);
+        const auto result = map.erase(reinterpret_cast<std::uintptr_t>(fdKeyRaw));
+        if (result == 0)
+            mvLog(MVLOG_ERROR, "destroyPlatformDeviceFdKey(%p) failed", fdKeyRaw);
+        else
+            mvLog(MVLOG_DEBUG, "destroyPlatformDeviceFdKey(%p) success", fdKeyRaw);
+        return !result;
+    } catch(std::exception&) {
+        mvLog(MVLOG_ERROR, "destroyPlatformDeviceFdKey(%p) failed", fdKeyRaw);
         return -1;
     }
 }
+
+// Extracts (finds and removes) the element (if one exists) with the key equivalent to fdKeyRaw
+// nullptr return value indicates failure
+// Only one mutex lock is taken compared to separate getPlatformDeviceFdFromKey() then destroyPlatformDeviceFdKey().
+// Additionally, this atomic operation prevents a set of race conditions of two threads when
+// each get() and/or destroy() keys in unpredictable orders.
+void* extractPlatformDeviceFdKey(void* const fdKeyRaw) noexcept {
+    try {
+        std::lock_guard<std::mutex> lock(mutex);
+        const auto result = map.find(reinterpret_cast<std::uintptr_t>(fdKeyRaw));
+        if(result == map.end()) {
+            mvLog(MVLOG_ERROR, "extractPlatformDeviceFdKey(%p) failed", fdKeyRaw);
+            return nullptr;
+        }
+        const auto fd = result->second;
+        map.erase(result);
+        mvLog(MVLOG_DEBUG, "extractPlatformDeviceFdKey(%p) success", fdKeyRaw);
+        return fd;
+    } catch(std::exception&) {
+        mvLog(MVLOG_ERROR, "extractPlatformDeviceFdKey(%p) failed", fdKeyRaw);
+        return nullptr;
+    }
+}
+
+// TODO consider storing the device_handle in the fdKey store with std::map<device_handle> so that
+// it can automatically handle refcounting, interfaces, and closing

src/pc/PlatformDeviceFd.h

@@ -2,13 +2,17 @@
 #define _PLATFORM_DEVICE_FD_H_
 
 #ifdef __cplusplus
-extern "C"
-{
+#define NOEXCEPT noexcept
+extern "C" {
+#else
+#define NOEXCEPT
 #endif
 
-int getPlatformDeviceFdFromKey(void* fdKeyRaw, void** fd);
-void* createPlatformDeviceFdKey(void* fd);
-int destroyPlatformDeviceFdKey(void* fdKeyRaw);
+int getPlatformDeviceFdFromKey(void* fdKeyRaw, void** fd) NOEXCEPT;
+void* getPlatformDeviceFdFromKeySimple(void* fdKeyRaw) NOEXCEPT;
+void* createPlatformDeviceFdKey(void* fd) NOEXCEPT;
+int destroyPlatformDeviceFdKey(void* fdKeyRaw) NOEXCEPT;
+void* extractPlatformDeviceFdKey(void* fdKeyRaw) NOEXCEPT;
 
 #ifdef __cplusplus
 }

src/pc/PlatformDeviceSearchDynamic.cpp

@@ -19,7 +19,7 @@
 
 extern "C" xLinkPlatformErrorCode_t getUSBDevices(const deviceDesc_t in_deviceRequirements,
                                                      deviceDesc_t* out_foundDevices, int sizeFoundDevices,
-                                                     unsigned int *out_amountOfFoundDevices);
+                                                     unsigned int *out_amountOfFoundDevices) noexcept;
 
 xLinkPlatformErrorCode_t XLinkPlatformFindDevicesDynamic(const deviceDesc_t in_deviceRequirements,
                                                      deviceDesc_t* out_foundDevices, unsigned sizeFoundDevices,
@@ -138,9 +138,9 @@ xLinkPlatformErrorCode_t XLinkPlatformFindDevicesDynamic(const deviceDesc_t in_d
         {
             deviceDesc_t* devices = out_foundDevices;
             int write_index = 0;
-            for(int i = 0; i < *out_amountOfFoundDevices; i++){
+            for(int i = 0, amountBound = static_cast<int>(*out_amountOfFoundDevices); i < amountBound; ++i){
                 bool duplicate = false;
-                for(int j = i - 1; j >= 0; j--){
+                for(int j = i - 1; j >= 0; --j){
                     // Check if duplicate
                     if(devices[i].protocol == devices[j].protocol && strcmp(devices[i].name, devices[j].name) == 0 && strcmp(devices[i].mxid, devices[j].mxid) == 0){
                         duplicate = true;

src/pc/Win/src/win_usb_host.cpp

@@ -18,7 +18,8 @@
 #include <array>
 #include <pathcch.h>
 
-int usbInitialize_customdir(void** hContext) {
+// support Visual C++ compiler for Windows to load libusb DLL from the same directory as the XLink code
+libusb_error usbInitializeCustomdir(libusb_context ** hContext) noexcept {
     // get handle to the module containing a XLink static function/var
     // can not use GetModuleFileNameW(nullptr) because when the main depthai app is a DLL (e.g. plugin),
     // then it returns the main EXE which is usually wrong
@@ -57,9 +58,9 @@ int usbInitialize_customdir(void** hContext) {
     }
 
     // initialize libusb
-    int initResult = LIBUSB_SUCCESS;
+    libusb_error initResult = LIBUSB_SUCCESS;
     __try {
-        initResult = libusb_init((libusb_context**)hContext);
+        initResult = static_cast<libusb_error>(libusb_init(hContext));
     }
     __except (EXCEPTION_EXECUTE_HANDLER) {
         initResult = LIBUSB_ERROR_OVERFLOW;