DynamicLoader.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// DynamicLoader.cpp: implementation of the DynamicLoader class.
//
//////////////////////////////////////////////////////////////////////

#include "DynamicLoader.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

DynamicLoader::DynamicLoader() {
        clearErrors();
}

DynamicLoader::~DynamicLoader() {
        closeAllHandles();
}


bool DynamicLoader::clearErrors() {
        #ifdef WIN32
        #else // WIN32
                dlerror();
                dlopen("test", RTLD_NOW);
                dlerror();
        #endif // WIN32
        return true;
}

DLLHandle DynamicLoader::openHandle(JString libname) {


        if (libname.length() == 0)
                return NULL;

        lastErrorMessage = "";
        DLLHandle handle = NULL;

        #ifdef WIN32
                LPVOID lpMsgBuf; //Message Buffer
                handle = LoadLibrary(libname);
                if (handle == NULL) {
                        FormatMessage(
                                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                            (LPTSTR) &lpMsgBuf, 0, NULL);
                        lastErrorMessage = JString::format("Could not load library '%s': %s\n", (char*) libname, (char*) lpMsgBuf);
                        LocalFree(lpMsgBuf);

                        if (!libname.endsWithIgnoreCase(".dll"))
                                libname += ".dll";

                        handle = LoadLibrary(libname);
                        if (handle == NULL) {
                                FormatMessage(
                                        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                        NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                                        (LPTSTR) &lpMsgBuf, 0, NULL);
                                lastErrorMessage += JString::format("Could not load library '%s': %s\n", (char*) libname, (char*) lpMsgBuf);
                                LocalFree(lpMsgBuf);

                                libname = JString::format("../%s", (char*) libname);
                                handle = LoadLibrary(libname);
                                if (handle == NULL) {
                                        FormatMessage(
                                                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                                NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                                                (LPTSTR) &lpMsgBuf, 0, NULL);
                                        lastErrorMessage += JString::format("Could not load library '%s': %s\n", (char*) libname, (char*) lpMsgBuf);
                                        LocalFree(lpMsgBuf);
                                }
                                else
                                        lastErrorMessage = "";
                        }
                        else
                                lastErrorMessage = "";
                }
        #else // WIN32

                const char* errmsg;

                JString realLibName;
                // Here we need to look for a lot of things.
                if (libname.endsWith(".so")) {
                        realLibName = libname;
                }
                else {
                        realLibName = libname + ".so";
                        if (DEBUGLEVEL(DEBUG)) {
                                printf("Info: Adding .so to filename: %s\n", (char*)realLibName);
                        }
                }

                // Try to open it now...
                dlerror();
                handle = dlopen(realLibName, RTLD_NOW | RTLD_GLOBAL);
                if (handle != NULL)
                        return handle;
                errmsg = dlerror();
                lastErrorMessage = JString::format("Could not load library '%s': %s\n", (char*) realLibName, (char*) errmsg);
                if (DEBUGLEVEL(DEBUG)) {
                        printf("Info: First dlopen failed with: %s\n", errmsg);
                }

                Collection path = realLibName.split("/");
                JString rawname = path.getLast();
                if (!rawname.startsWith("lib")) {
                        rawname = JString("lib") + rawname;
                        path.removeLast();
                        path.addLast(rawname);
                        realLibName = path.printListLine("/");
                        if (DEBUGLEVEL(DEBUG)) {
                                printf("Info: Adding lib to filename: %s\n", (char*)realLibName);
                        }
                }

                // Try to open it now...
                dlerror();
                handle = dlopen(realLibName, RTLD_NOW);
                if (handle != NULL) {
                        lastErrorMessage = "";
                        return handle;
                }
                errmsg = dlerror();
                lastErrorMessage += JString::format("Could not load library '%s': %s\n", (char*) realLibName, (char*) errmsg);
                if (DEBUGLEVEL(DEBUG)) {
                        printf("Info: Second dlopen failed with: %s\n", errmsg);
                }

                // We might not have the current dir in the LD_LIBRARY_PATH
                realLibName = JString("./") + realLibName;
                if (DEBUGLEVEL(DEBUG)) {
                        printf("Info: Adding ./ to filename: %s\n", (char*)realLibName);
                }
                dlerror();
                handle = dlopen(realLibName, RTLD_NOW);
                if (handle != NULL) {
                        lastErrorMessage = "";
                        if (DEBUGLEVEL(STATUS)) {
                                printf("Info: Fetched %s locally by adding ./\n", (char*)realLibName);
                        }
                        return handle;
                }
                errmsg = dlerror();
                lastErrorMessage += JString::format("Could not load library '%s': %s\n", (char*) realLibName, (char*) errmsg);
                // lastErrorMessage = JString::format("Error: dlopen(%s) failed with: %s", (char*) libname, errmsg);
                if (DEBUGLEVEL(STATUS)) {
                        printf("%s\n", (char*) lastErrorMessage);
                }
                if (handle != NULL)
                        lastErrorMessage = "";

        #endif // WIN32

        return handle;
}

bool DynamicLoader::closeHandle(DLLHandle handle) {

        if (handle == NULL)
                return false;

        lastErrorMessage = "";

        #ifdef WIN32
                FreeLibrary(handle);
        #else // WIN32
                // dlclose() bug: https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=28625
                // __dso_handle unreferenced
                // if there are any globally desclared objects in the library!!!
                dlclose(handle);
        #endif // WIN32

        return true;
}

DLLFunction DynamicLoader::getFunction(DLLHandle handle, JString funcname) {

        lastErrorMessage = "";

        if (handle == NULL)
                return NULL;
        if (funcname.length() == 0)
                return NULL;

        DLLFunction func;

        #ifdef WIN32
                func = (DLLFunction)GetProcAddress(handle, funcname);
                if (func == NULL) {
                        LPVOID lpMsgBuf; //Message Buffer
                        //Generate Error Message from GetLastError
                        FormatMessage(
                                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                            (LPTSTR) &lpMsgBuf, 0, NULL);
                        lastErrorMessage = JString::format("Could not find function: %s: %s", (char*) funcname, (char*) lpMsgBuf);
                        // Free the buffer.
                        LocalFree(lpMsgBuf);
                        return NULL;
                }
        #else // WIN32
                const char* errmsg;
                dlerror();
                func = (DLLFunction)dlsym(handle, funcname);
                errmsg = dlerror();
                if (errmsg != NULL) {
                        lastErrorMessage = JString::format("Could not find function: %s: %s", (char*) funcname, (char*) errmsg);
                        return NULL;
                }
        #endif // WIN32

        return func;
}

bool DynamicLoader::didErrorHappen() {
        return (lastErrorMessage.length() > 0);
}

JString DynamicLoader::getLastErrorMessage() {
        return lastErrorMessage;
}

bool DynamicLoader::closeAllHandles() {
        
        if (!libMutex.EnterMutex(2000))
                return false;

        JString key;
        LibHandle* lh;
        for (int n=0; n<libHandles.getCount(); n++) {
                key = libHandles.getKey(n);
                lh = (LibHandle*) libHandles.get(key);
                if (lh != NULL) {
                        closeHandle(lh->handle);
                }
        }
        libHandles.removeAll();
        libMutex.LeaveMutex();
        return true;
}

bool DynamicLoader::loadLibrary(JString libname) {

        if (libname.length() == 0)
                return false;

        if (libHandles.contains(libname)) {
                libMutex.LeaveMutex();
                return true;
        }

        if (!libMutex.EnterMutex(2000))
                return false;

        DLLHandle handle = openHandle(libname);

        if (handle == NULL) {
                printf("Error: Could not load library '%s' even with advanced name search:\n%s\n", (char*) libname, (char*) lastErrorMessage);
                libMutex.LeaveMutex();
                return false;
        }

        LibHandle* lh = new LibHandle();
        lh->name = libname;
        lh->handle = handle;

        libHandles.put(libname, lh);
        libMutex.LeaveMutex();
        checkLibraryVersion(libname);
        return true;
}

bool DynamicLoader::unloadLibrary(JString libname) {

        if (libname.length() == 0)
                return false;

        if (!libMutex.EnterMutex(2000))
                return false;

        LibHandle* lh = (LibHandle*) libHandles.get(libname);
        if (lh == NULL) {
                libMutex.LeaveMutex();
                return false;
        }

        closeHandle(lh->handle);
        libHandles.remove(libname);
        libMutex.LeaveMutex();
        return true;
}

bool DynamicLoader::checkLibraryVersion(const JString& libname) {

        DLLCheckFunction checkFunc = (DLLCheckFunction)getFunction(libname, "GetLibraryVersion");
        JString localVersion = Object::getCoreLibraryVersion();
        JString warning;
        char* str = NULL;

        if (checkFunc == NULL) {
                warning = JString::format("Loaded Library CoreLibrary version\ndoes not match the local version: %s\nand is older than version: 1.2.0",
                        (char*) localVersion);
        }
        else {
                str = checkFunc();
                if ((str == NULL) || (strlen(str) == 0)) {
                        warning = JString::format("Loaded Library CoreLibrary version\ndoes not match the local version: %s\nand is older than version: 1.2.0",
                                (char*) localVersion);
                }
                else {
                        JString version = str;
                        if (!version.equalsIgnoreCase(localVersion)) {
                                warning = JString::format("Loaded Library CoreLibrary version: %s\ndoes not match the local version: %s",
                                        (char*) version, (char*) localVersion);
                        }
                }
        }
        delete [] str;
        if (warning.length() > 0) {
                printf("\n%s\n\n", (char*) JString::asciiMessage(JString::format("CoreLibrary Version Mismatch: Library '%s'", (char*) libname), warning));
                return false;
        }
        else
                return true;
}


DLLFunction DynamicLoader::getFunction(JString libname, JString funcname) {

        if (libname.length() == 0)
                return NULL;

        if (!libMutex.EnterMutex(2000))
                return false;
        LibHandle* lh = (LibHandle*) libHandles.get(libname);
        libMutex.LeaveMutex();
        if (lh == NULL) {
                loadLibrary(libname);
                lh = (LibHandle*) libHandles.get(libname);
                if (lh == NULL)
                        return NULL;
        }
        return getFunction(lh->handle, funcname);
}

DLLFunction DynamicLoader::getFunction(JString funcname) {

        JString libName;

        if (funcname.contains("::")) {
                Collection oc = funcname.split("::");
                libName = oc.get(0);
                funcname = oc.get(1);
                return getFunction(libName, funcname);
        }

        DLLFunction func = NULL;
        JString key;
        for (int n=0; n<libHandles.getCount(); n++) {
                key = libHandles.getKey(n);
                func = getFunction(key, funcname);
                if (func != NULL)
                        return func;
        }
        return NULL;
}















LibHandle::LibHandle() : Object() {
        handle = NULL;
}

LibHandle::~LibHandle() {
}




bool DynamicLoader::setTestLib(JString lib) {
        testlib = lib;
        return true;
}

bool DynamicLoader::unitTest() {

        DynamicLoader loader;
        if (!loader.loadLibrary(testlib)) {
                this->addUnitTestLog(JString("Could not load library ") + testlib);
                return false;
        }

        DLLUnitTestFunction func;
        func = (DLLUnitTestFunction) loader.getFunction(testlib, "nonexistingfunction");
        if (func != NULL) {
                this->addUnitTestLog(JString("Could load non-existing function from library ") + testlib);
                return false;
        }

        func = (DLLUnitTestFunction) loader.getFunction(testlib, "unitTest");
        if (func == NULL) {
                this->addUnitTestLog(JString("Could not load function unittest from library ") + testlib);
                return false;
        }

        ObjectCollection* testCol = new ObjectCollection();
        testCol->add(new Message("From", "To", "Type", new TCPLocation("Test", 10000, "Test")));
        int ret = func(testCol);
        if (ret < 0) {
                this->addUnitTestLog(JString("Could not run function unittest from library ") + testlib);
                return false;
        }

        delete(testCol);
        testCol = new ObjectCollection();
        testCol->add(new Message("From", "To", "Type", new TCPLocation("Test", 10000, "Test")));

        for (int n=0; n<100; n++) {
                ret = func(testCol);
                if (ret < 0) {
                        this->addUnitTestLog(JString("Could not run function unittest from library ") + testlib);
                        return false;
                }
                delete(testCol);
                testCol = new ObjectCollection();
                testCol->add(new Message("From", "To", "Type", new TCPLocation("Test", 10000, "Test")));
        }

        delete(testCol);
        return true;
}




} // namespace cmlabs

---