comparison src/helper.cpp @ 40:40c6936c2fc9 errorcode

Return numerical error codes, so the caller can apply i18n on display; distinguish explicitly the common win32 architecture problems

  *
  * Output line for successful load of library libname.so:
  * SUCCESS|/path/to/libname.so|
  * 
  * Output line for failed load of library libname.so:
- * FAILURE|/path/to/libname.so|Reason for failure if available
+ * FAILURE|/path/to/libname.so|Error message [failureCode]
+ *
+ * or:
+ * FAILURE|/path/to/libname.so|[failureCode]
+ *
+ * where the error message is an optional system-level message, such
+ * as may be returned from strerror or similar (which should be in the
+ * native language for the system ready to show the user), and the
+ * failureCode in square brackets is a mandatory number corresponding
+ * to one of the PluginCandidates::FailureCode values (requiring
+ * conversion to a translated string by the client).
  *
  * Although this program was written for use with Vamp audio analysis
  * plugins, it also works with other plugin formats. The program has
  * some hardcoded knowledge of Vamp, LADSPA, and DSSI plugins, but it
  * can be used with any plugins that involve loading DLLs and looking

     dealings in this Software without prior written authorization.
 */
 
 #include "../version.h"
 
+#include "../checker/checkcode.h"
+
 static const char programName[] = "vamp-plugin-load-checker";
 
 #ifdef _WIN32
 #include <windows.h>
 #include <process.h>

 
 #ifdef _WIN32
 #ifndef UNICODE
 #error "This must be compiled with UNICODE defined"
 #endif
+
 static std::string lastLibraryName = "";
+
 static HMODULE LoadLibraryUTF8(std::string name) {
     lastLibraryName = name;
     int n = name.size();
     int wn = MultiByteToWideChar(CP_UTF8, 0, name.c_str(), n, 0, 0);
     wchar_t *wname = new wchar_t[wn+1];

     wname[wn] = L'\0';
     HMODULE h = LoadLibraryW(wname);
     delete[] wname;
     return h;
 }
+
 static std::string GetErrorText() {
     DWORD err = GetLastError();
     wchar_t *buffer;
     FormatMessageW(
         FORMAT_MESSAGE_ALLOCATE_BUFFER |
         FORMAT_MESSAGE_FROM_SYSTEM |
         FORMAT_MESSAGE_IGNORE_INSERTS,
         NULL,
         err,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        MAKELANGID(LANG_USER_DEFAULT, SUBLANG_USER_DEFAULT),
         (LPWSTR) &buffer,
         0, NULL );
     int wn = wcslen(buffer);
     int n = WideCharToMultiByte(CP_UTF8, 0, buffer, wn, 0, 0, 0, 0);
     if (n < 0) {

     if (pos != std::string::npos && lastLibraryName != "") {
         s.replace(pos, 2, lastLibraryName);
     }
     return s;
 }
+
 #define DLOPEN(a,b)  LoadLibraryUTF8(a)
 #define DLSYM(a,b)   (void *)GetProcAddress((HINSTANCE)(a),(b).c_str())
 #define DLCLOSE(a)   (!FreeLibrary((HINSTANCE)(a)))
 #define DLERROR()    (GetErrorText())
+
 #else
+
 #include <dlfcn.h>
 #define DLOPEN(a,b)  dlopen((a).c_str(),(b))
 #define DLSYM(a,b)   dlsym((a),(b).c_str())
 #define DLCLOSE(a)   dlclose((a))
 #define DLERROR()    dlerror()
+
 #endif
 
 //#include <unistd.h>
 
 using namespace std;
 
 string error()
 {
-    string e = DLERROR();
-    if (e == "") return "(unknown error)";
-    else return e;
-}
-
-string checkLADSPAStyleDescriptorFn(void *f)
+    return DLERROR();
+}
+
+struct Result {
+    PluginCheckCode code;
+    string message;
+};
+
+Result checkLADSPAStyleDescriptorFn(void *f)
 {
     typedef const void *(*DFn)(unsigned long);
     DFn fn = DFn(f);
     unsigned long index = 0;
     while (fn(index)) ++index;
-    if (index == 0) return "Library contains no plugins";
-    return "";
-}
-
-string checkVampDescriptorFn(void *f)
+    if (index == 0) return { PluginCheckCode::FAIL_NO_PLUGINS, "" };
+    return { PluginCheckCode::SUCCESS, "" };
+}
+
+Result checkVampDescriptorFn(void *f)
 {
     typedef const void *(*DFn)(unsigned int, unsigned int);
     DFn fn = DFn(f);
     unsigned int index = 0;
     while (fn(2, index)) ++index;
-    if (index == 0) return "Library contains no plugins";
-    return "";
-}
-
-string check(string soname, string descriptor)
+    if (index == 0) return { PluginCheckCode::FAIL_NO_PLUGINS, "" };
+    return { PluginCheckCode::SUCCESS, "" };
+}
+
+Result check(string soname, string descriptor)
 {
     void *handle = DLOPEN(soname, RTLD_NOW | RTLD_LOCAL);
     if (!handle) {
-        return "Unable to open plugin library: " + error();
-    }
-
-    string msg = "";
+        PluginCheckCode code = PluginCheckCode::FAIL_NOT_LOADABLE;
+        string message = error();
+#ifdef _WIN32
+        DWORD err = GetLastError();
+        if (err == ERROR_BAD_EXE_FORMAT) {
+            code = PluginCheckCode::FAIL_WRONG_ARCHITECTURE;
+        } else if (err == ERROR_MOD_NOT_FOUND) {
+            code = PluginCheckCode::FAIL_DEPENDENCY_MISSING;
+        }
+#endif
+        return { code, message };
+    }
+
+    Result result { PluginCheckCode::SUCCESS, "" };
     
     void *fn = DLSYM(handle, descriptor);
     if (!fn) {
-        msg = "Failed to find plugin descriptor " + descriptor +
-            " in library: " + error();
+        result = { PluginCheckCode::FAIL_DESCRIPTOR_MISSING, error() };
     } else if (descriptor == "ladspa_descriptor") {
-        msg = checkLADSPAStyleDescriptorFn(fn);
+        result = checkLADSPAStyleDescriptorFn(fn);
     } else if (descriptor == "dssi_descriptor") {
-        msg = checkLADSPAStyleDescriptorFn(fn);
+        result = checkLADSPAStyleDescriptorFn(fn);
     } else if (descriptor == "vampGetPluginDescriptor") {
-        msg = checkVampDescriptorFn(fn);
+        result = checkVampDescriptorFn(fn);
     } else {
         cerr << "Note: no descriptor logic known for descriptor function \""
              << descriptor << "\"; not actually calling it" << endl;
     }
 
     DLCLOSE(handle);
     
-    return msg;
+    return result;
 }
 
 int main(int argc, char **argv)
 {
     bool allGood = true;

     if (argc > 1) {
         string opt = argv[1];
         if (opt == "-?" || opt == "-h" || opt == "--help") {
             showUsage = true;
         } else if (opt == "-v" || opt == "--version") {
-            cout << CHECKER_VERSION << endl;
+            cout << CHECKER_COMPATIBILITY_VERSION << endl;
             return 0;
         }
     } 
     
     if (argc != 2 || showUsage) {

     // fail anyway.
     SetErrorMode(SEM_FAILCRITICALERRORS);
 #endif
 
     while (getline(cin, soname)) {
-        string report = check(soname, descriptor);
-        if (report != "") {
-            cout << "FAILURE|" << soname << "|" << report << endl;
+        Result result = check(soname, descriptor);
+        if (result.code == PluginCheckCode::SUCCESS) {
+            cout << "SUCCESS|" << soname << "|" << endl;
+        } else {
+            if (result.message == "") {
+                cout << "FAILURE|" << soname
+                     << "|[" << int(result.code) << "]" << endl;
+            } else {
+                cout << "FAILURE|" << soname
+                     << "|" << result.message << " ["
+                     << int(result.code) << "]" << endl;
+            }
             allGood = false;
-        } else {
-            cout << "SUCCESS|" << soname << "|" << endl;
         }
     }
     
     return allGood ? 0 : 1;
 }