hbaapi/common/HBAAPILIB.c

/*************************************************************************
 * Description
 *  HBAAPILIB.c - Implements a sample common (wrapper) HBA API library
 *
 * License:
 *  The contents of this file are subject to the SNIA Public License
 *  Version 1.0 (the "License"); you may not use this file except in
 *  compliance with the License. You may obtain a copy of the License at
 *
 *  /http://www.snia.org/English/Resources/Code/OpenSource.html
 *
 *  Software distributed under the License is distributed on an "AS IS"
 *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 *  the License for the specific language governing rights and limitations
 *  under the License.
 *
 * The Original Code is  SNIA HBA API Wrapper Library
 *
 * The Initial Developer of the Original Code is:
 *  Benjamin F. Kuo, Troika Networks, Inc. (benk@troikanetworks.com)
 *
 * Contributor(s):
 *  Tuan Lam, QLogic Corp. (t_lam@qlc.com)
 *  Dan Willie, Emulex Corp. (Dan.Willie@emulex.com)
 *  Dixon Hutchinson, Legato Systems, Inc. (dhutchin@legato.com)
 *  David Dillard, VERITAS Software Corp. (david.dillard@veritas.com)
 *
 *************************************************************************
 */

#ifdef WIN32
#include <windows.h>
#include <string.h>
/*
 * Next define forces entry points in the dll to be exported
 * See hbaapi.h to see what it does.
 */
#define HBAAPI_EXPORTS
#else
#include <dlfcn.h>
#include <strings.h>
#endif
#include <stdio.h>
#include <time.h>
#include "hbaapi.h"
#include "vendorhbaapi.h"
#include <stdlib.h>
#ifdef USESYSLOG
#include <syslog.h>
#endif

/*
 * LIBRARY_NUM is a shortcut to figure out which library we need to call.
 *  The top 16 bits of handle are the library index
 */
#define LIBRARY_NUM(handle) ((handle)>>16)

/*
 * VENDOR_HANDLE turns a global library handle into a vendor specific handle,
 * with all upper 16 bits set to 0
 */
#define VENDOR_HANDLE(handle)   ((handle)&0xFFFF)

#define HBA_HANDLE_FROM_LOCAL(library, vendor) \
                (((library)<<16) | ((vendor)&0x0000FFFF))

int _hbaapi_debuglevel = 0;
#define DEBUG(L, STR, A1, A2, A3)

#if defined(USESYSLOG) && defined(USELOGFILE)
FILE *_hbaapi_debug_fd = NULL;
int _hbaapi_sysloginit = 0;
#undef DEBUG
#ifdef WIN32
#define DEBUG(L, STR, A1, A2, A3)\
    if ((L) <= _hbaapi_debuglevel) {\
    if(_hbaapi_sysloginit == 0) {\
        openlog("HBAAPI", LOG_PID|LOG_ODELAY ,LOG_USER);\
        _hbaapi_sysloginit = 1;\
    }\
    syslog (LOG_INFO, (STR), (A1), (A2), (A3));\
    if(_hbaapi_debug_fd == NULL) {\
        char _logFile[MAX_PATH]; \
        GetTempPath(MAX_PATH, _logFile); \
        strcat(_logFile, "HBAAPI.log"); \
        _hbaapi_debug_fd = fopen(_logFile, "a");\
    }\
        if(_hbaapi_debug_fd != NULL) {\
        fprintf(_hbaapi_debug_fd, (STR ## "\n"), (A1), (A2), (A3));\
    }\
    }
#else /* WIN32*/
#define DEBUG(L, STR, A1, A2, A3)\
    if ((L) <= _hbaapi_debuglevel) {\
    if(_hbaapi_sysloginit == 0) {\
        openlog("HBAAPI", LOG_PID|LOG_ODELAY ,LOG_USER);\
        _hbaapi_sysloginit = 1;\
    }\
    syslog (LOG_INFO, (STR), (A1), (A2), (A3));\
    if(_hbaapi_debug_fd == NULL) {\
        _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
    }\
        if(_hbaapi_debug_fd != NULL) {\
        fprintf(_hbaapi_debug_fd, (STR ## "\n"), (A1), (A2), (A3));\
    }\
    }
#endif /* WIN32*/

#else /* Not both USESYSLOG and USELOGFILE */
#if defined(USESYSLOG)
int _hbaapi_sysloginit = 0;
#undef DEBUG
#define DEBUG(L, STR, A1, A2, A3) \
    if ((L) <= _hbaapi_debuglevel) {\
    if(_hbaapi_sysloginit == 0) {\
        openlog("HBAAPI", LOG_PID|LOG_ODELAY ,LOG_USER);\
        _hbaapi_sysloginit = 1;\
    }\
    syslog (LOG_INFO, (STR), (A1), (A2), (A3));\
    }
#endif /* USESYSLOG */
#if defined(USELOGFILE)
FILE *_hbaapi_debug_fd = NULL;
#undef DEBUG
#ifdef WIN32
#define DEBUG(L, STR, A1, A2, A3) \
    if((L) <= _hbaapi_debuglevel) {\
    if(_hbaapi_debug_fd == NULL) {\
        char _logFile[MAX_PATH]; \
        GetTempPath(MAX_PATH, _logFile); \
        strcat(_logFile, "HBAAPI.log"); \
        _hbaapi_debug_fd = fopen(_logFile, "a");\
        }\
    }
#else /* WIN32 */
#define DEBUG(L, STR, A1, A2, A3) \
    if((L) <= _hbaapi_debuglevel) {\
    if(_hbaapi_debug_fd == NULL) {\
        _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
    }\
    if(_hbaapi_debug_fd != NULL) { \
        fprintf(_hbaapi_debug_fd, (STR) ## "\n", (A1), (A2), (A3));\
    }\
    }
#endif /* WIN32 */
#endif /* USELOGFILE */
#endif /* Not both USELOGFILE and USESYSLOG */

#ifdef POSIX_THREADS
#include <pthread.h>
/*
 * When multiple mutex's are grabed, they must be always be grabbed in
 * the same order, or deadlock can result.  There are three levels
 * of mutex's involved in this API.  If LL_mutex is grabbed, always grap
 * it first.  If AL_mutex is grabbed, it may not be grabbed before
 * LL_mutex.  If grabbed in a multi grab sequence, the mutex's protecting
 * the callback lists must always be grabbed last and release before calling
 * a vendor specific library function that might invoke a callback function
 * on the same thread.
 */
#define GRAB_MUTEX(M)           grab_mutex(M)
#define RELEASE_MUTEX(M)        release_mutex(M)
#define RELEASE_MUTEX_RETURN(M,RET) release_mutex(M); return(RET)
#elif defined (WIN32)
#define GRAB_MUTEX(m)           EnterCriticalSection(m)
#define RELEASE_MUTEX(m)        LeaveCriticalSection(m)
#define RELEASE_MUTEX_RETURN(m, RET)    LeaveCriticalSection(m); return(RET)
#else
#define GRAB_MUTEX(M)
#define RELEASE_MUTEX(M)
#define RELEASE_MUTEX_RETURN(M,RET) return(RET)
#endif

/*
 * Vendor library information
 */
typedef enum {
    HBA_LIBRARY_UNKNOWN,
    HBA_LIBRARY_LOADED,
    HBA_LIBRARY_NOT_LOADED
} HBA_LIBRARY_STATUS;

typedef struct hba_library_info {
    struct hba_library_info
            *next;
#ifdef WIN32
    HINSTANCE       hLibrary;       /* Handle to a loaded DLL */
#else
    char        *LibraryName;
    void*       hLibrary;       /* Handle to a loaded DLL */
#endif
    char        *LibraryPath;
    HBA_ENTRYPOINTSV2   functionTable;      /* Function pointers */
    HBA_LIBRARY_STATUS  status;         /* info on this library */
    HBA_UINT32      index;
} HBA_LIBRARY_INFO, *PHBA_LIBRARY_INFO;

#define ARE_WE_INITED() \
    if (_hbaapi_librarylist == NULL) { \
        return(HBA_STATUS_ERROR_NOT_LOADED); \
    }
HBA_LIBRARY_INFO *_hbaapi_librarylist = NULL;
HBA_UINT32 _hbaapi_total_library_count = 0;
#ifdef POSIX_THREADS
pthread_mutex_t _hbaapi_LL_mutex = PTHREAD_MUTEX_INITIALIZER;
#elif defined(WIN32)
CRITICAL_SECTION _hbaapi_LL_mutex;
#endif

/*
 * Individual adapter (hba) information
 */
typedef struct hba_adapter_info {
    struct hba_adapter_info
            *next;
    HBA_STATUS      GNstatus;   /* status from GetAdapterNameFunc */
    char        *name;
    HBA_WWN     nodeWWN;
    HBA_LIBRARY_INFO    *library;
    HBA_UINT32      index;
} HBA_ADAPTER_INFO;

HBA_ADAPTER_INFO *_hbaapi_adapterlist = NULL;
HBA_UINT32 _hbaapi_total_adapter_count = 0;
#ifdef POSIX_THREADS
pthread_mutex_t _hbaapi_AL_mutex = PTHREAD_MUTEX_INITIALIZER;
#elif defined(WIN32)
CRITICAL_SECTION _hbaapi_AL_mutex;
#endif

/*
 * Call back registration
 */
typedef struct hba_vendorcallback_elem {
    struct hba_vendorcallback_elem
                *next;
    HBA_CALLBACKHANDLE      vendorcbhandle;
    HBA_LIBRARY_INFO        *lib_info;
} HBA_VENDORCALLBACK_ELEM;

/*
 * Each instance of HBA_ADAPTERCALLBACK_ELEM represents a call to one of
 * "register" functions that apply to a particular adapter.
 * HBA_ALLADAPTERSCALLBACK_ELEM is used just for HBA_RegisterForAdapterAddEvents
 */
typedef struct hba_adaptercallback_elem {
    struct hba_adaptercallback_elem
            *next;
    HBA_LIBRARY_INFO    *lib_info;
    void        *userdata;
    HBA_CALLBACKHANDLE  vendorcbhandle;
    void        (*callback)();
} HBA_ADAPTERCALLBACK_ELEM;

typedef struct hba_alladapterscallback_elem {
    struct hba_alladapterscallback_elem
                *next;
    void            *userdata;
    HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
    void            (*callback)();
} HBA_ALLADAPTERSCALLBACK_ELEM;

HBA_ALLADAPTERSCALLBACK_ELEM *_hbaapi_adapteraddevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportstatevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_targetevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_linkevents_callback_list = NULL;
HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterdeviceevents_callback_list = NULL;
#ifdef POSIX_THREADS
/* mutex's to protect each list */
pthread_mutex_t _hbaapi_AAE_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t _hbaapi_AE_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t _hbaapi_APE_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t _hbaapi_APSE_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t _hbaapi_TE_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t _hbaapi_LE_mutex = PTHREAD_MUTEX_INITIALIZER;
#elif defined(WIN32)
CRITICAL_SECTION _hbaapi_AAE_mutex;
CRITICAL_SECTION _hbaapi_AE_mutex;
CRITICAL_SECTION _hbaapi_APE_mutex;
CRITICAL_SECTION _hbaapi_APSE_mutex;
CRITICAL_SECTION _hbaapi_TE_mutex;
CRITICAL_SECTION _hbaapi_LE_mutex;
#endif

HBA_ADAPTERCALLBACK_ELEM **cb_lists_array[] = {
    &_hbaapi_adapterevents_callback_list,
    &_hbaapi_adapterportevents_callback_list,
    &_hbaapi_adapterportstatevents_callback_list,
    &_hbaapi_targetevents_callback_list,
    &_hbaapi_linkevents_callback_list,
    &_hbaapi_adapterdeviceevents_callback_list,
    NULL};

/*
 * Common library internal. Mutex handling
 */
#ifdef POSIX_THREADS
static void
grab_mutex(pthread_mutex_t *mp) {
    int ret;
    if((ret = pthread_mutex_lock(mp)) != 0) {
    perror("pthread_mutex_lock - HBAAPI:");
    DEBUG(0, "pthread_mutex_lock returned %d", ret, 0, 0);
    }
}

static void
release_mutex(pthread_mutex_t *mp) {
    int ret;
    if((ret = pthread_mutex_unlock(mp)) != 0) {
    perror("pthread_mutex_unlock - HBAAPI:");
    DEBUG(0, "pthread_mutex_unlock returned %d", ret, 0, 0);
    }
}
#endif

/*
 * Common library internal. Check library and return vendorhandle
 */
static HBA_STATUS
HBA_CheckLibrary(HBA_HANDLE handle,
         HBA_LIBRARY_INFO **lib_infopp,
         HBA_HANDLE *vendorhandle) {

    HBA_UINT32      libraryIndex;
    HBA_LIBRARY_INFO    *lib_infop;

    if (vendorhandle == NULL) {
    return(HBA_STATUS_ERROR_ARG);
    }
    if(_hbaapi_librarylist == NULL) {
    return(HBA_STATUS_ERROR);
    }
    libraryIndex = LIBRARY_NUM(handle);

    GRAB_MUTEX(&_hbaapi_LL_mutex);
    for(lib_infop = _hbaapi_librarylist;
    lib_infop != NULL;
    lib_infop = lib_infop->next) {
    if(lib_infop->index == libraryIndex) {
        if(lib_infop->status != HBA_LIBRARY_LOADED) {
        return HBA_STATUS_ERROR;
        }
        *lib_infopp = lib_infop;
        *vendorhandle = VENDOR_HANDLE(handle);
        /* caller will release the mutex */
        return HBA_STATUS_OK;
    }
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INVALID_HANDLE);
}
#define CHECKLIBRARY() \
    status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);\
    if(status != HBA_STATUS_OK) { \
        return(status); \
    }

/*
 *freevendorhandlelist is called with _hbaapi_LL_mutex already held
 */
static void
freevendorhandlelist(HBA_VENDORCALLBACK_ELEM *vhlist) {
    HBA_VENDORCALLBACK_ELEM *vhlp;
    HBA_VENDORCALLBACK_ELEM *vnext;
    HBARemoveCallbackFunc   registeredfunc;

    for(vhlp = vhlist; vhlp != NULL; vhlp = vnext) {
    vnext = vhlp->next;
    registeredfunc =
        vhlp->lib_info->functionTable.RemoveCallbackHandler;
    if(registeredfunc == NULL) {
        continue;
    }
    (registeredfunc)(vhlp->vendorcbhandle);
    free(vhlp);
    }
}

static
HBA_STATUS
local_remove_callback(HBA_CALLBACKHANDLE cbhandle) {
    HBA_ADAPTERCALLBACK_ELEM        ***listp;
    HBA_ADAPTERCALLBACK_ELEM        **lastp;
    HBA_ALLADAPTERSCALLBACK_ELEM    **lap;
    HBA_ALLADAPTERSCALLBACK_ELEM    *allcbp;
    HBA_ADAPTERCALLBACK_ELEM        *cbp;
    HBARemoveCallbackFunc       registeredfunc;
    HBA_VENDORCALLBACK_ELEM     *vhlp;
    HBA_VENDORCALLBACK_ELEM     *vnext;
    int                 found;
    HBA_STATUS              status = HBA_STATUS_ERROR_INVALID_HANDLE;


    /* search through the simple lists first */
    GRAB_MUTEX(&_hbaapi_AAE_mutex);
    GRAB_MUTEX(&_hbaapi_AE_mutex);
    GRAB_MUTEX(&_hbaapi_APE_mutex);
    GRAB_MUTEX(&_hbaapi_APSE_mutex);
    GRAB_MUTEX(&_hbaapi_TE_mutex);
    GRAB_MUTEX(&_hbaapi_LE_mutex);
    for(listp = cb_lists_array, found = 0; found == 0, *listp != NULL; listp++) {
    lastp = *listp;
    for(cbp=**listp; cbp != NULL; cbp = cbp->next) {
        if(cbhandle != (HBA_CALLBACKHANDLE)cbp) {
        lastp = &(cbp->next);
        continue;
        }
        found = 1;
        registeredfunc = cbp->lib_info->functionTable.RemoveCallbackHandler;
        if(registeredfunc == NULL) {
        break;
        }
        (registeredfunc)(cbp->vendorcbhandle);
        *lastp = cbp->next;
        free(cbp);
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_LE_mutex);
    RELEASE_MUTEX(&_hbaapi_TE_mutex);
    RELEASE_MUTEX(&_hbaapi_APSE_mutex);
    RELEASE_MUTEX(&_hbaapi_APE_mutex);
    RELEASE_MUTEX(&_hbaapi_AE_mutex);
    RELEASE_MUTEX(&_hbaapi_AAE_mutex);
    if(found != 0) {
    if(registeredfunc == NULL) {
        return HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    return HBA_STATUS_OK;
    }

    GRAB_MUTEX(&_hbaapi_AAE_mutex);
    /* if it wasnt in the simple lists, look in the list for adapteraddevents */
    lap = &_hbaapi_adapteraddevents_callback_list;
    for(allcbp = _hbaapi_adapteraddevents_callback_list;
    allcbp != NULL;
    allcbp = allcbp->next) {
    if(cbhandle != (HBA_CALLBACKHANDLE)allcbp) {
        lap = &allcbp->next;
        continue;
    }
    for(vhlp = allcbp->vendorhandlelist; vhlp != NULL; vhlp = vnext) {
        vnext = vhlp->next;
        registeredfunc =
        vhlp->lib_info->functionTable.RemoveCallbackHandler;
        if(registeredfunc == NULL) {
        continue;
        }
        (registeredfunc)(vhlp->vendorcbhandle);
        free(vhlp);
    }
    *lap = allcbp->next;
    free(allcbp);
    status = HBA_STATUS_OK;
    break;
    }
    RELEASE_MUTEX(&_hbaapi_AAE_mutex);
    return(status);
}

static char wwn_str1[17];
static char wwn_str2[17];
static char wwn_str3[17];
#define WWN2STR1(wwn) WWN2str(wwn_str1, (wwn))
#define WWN2STR2(wwn) WWN2str(wwn_str2, (wwn))
#define WWN2STR3(wwn) WWN2str(wwn_str3, (wwn))
static char *
WWN2str(char *buf, HBA_WWN *wwn) {
    int j;
    unsigned char *pc = (unsigned char *)&(wwn->wwn[0]);
    buf[0] = '\0';
    for (j=0; j<16; j+=2) {
        sprintf(&buf[j], "%02X", (int)*pc++);
    }
    return(buf);
}


#ifdef WIN32
BOOL APIENTRY
DllMain( HANDLE hModule,
     DWORD  ul_reason_for_call,
     LPVOID lpReserved
    )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    break;
    case DLL_PROCESS_DETACH:
    break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    break;
    }
    return TRUE;
}
#endif

/*
 * Read in the config file and load all the specified vendor specific
 * libraries and perform the function registration exercise
 */
HBA_STATUS
HBA_LoadLibrary(void) {
    HBARegisterLibraryFunc
            RegisterFunc;
    HBARegisterLibraryV2Func
            RegisterV2Func;
    HBALoadLibraryFunc  LoadLibraryFunc;
    HBAGetVersionFunc   GetVersionFunc;
#ifdef POSIX_THREADS
    int         ret;
#endif
    HBA_STATUS      status;
    HBA_UINT32      libversion;

    /* Open configuration file from known location */
#ifdef WIN32
    LONG        lStatus;
    HKEY        hkSniaHba, hkVendorLib;
    FILETIME        ftLastWriteTime;
    TCHAR       cSubKeyName[256];
    DWORD       i, dwSize, dwType;
    BYTE        byFileName[MAX_PATH];
    HBA_LIBRARY_INFO    *lib_infop;

    if(_hbaapi_librarylist != NULL) {
    /* this is an app programming error */
    return HBA_STATUS_ERROR;
    }

    lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\SNIA\\HBA",
               0, KEY_READ, &hkSniaHba);
    if (lStatus != ERROR_SUCCESS) {
    /* ???Opportunity to send error msg, configuration error */
    return HBA_STATUS_ERROR;
    }
    /*
     * Enumerate all the subkeys. These have the form:
     * HKLM\Software\SNIA\HBA\<Vendor id> - note that we don't care
     * what the vendor id is
     */
    for (i = 0; ; i++) {
    dwSize = 255;   /* how big the buffer is */
    lStatus = RegEnumKeyEx(hkSniaHba, i,
                   (char *)&cSubKeyName, &dwSize, NULL,
                   NULL, NULL, &ftLastWriteTime);
    if (lStatus == ERROR_NO_MORE_ITEMS) {
        break;  /* we're done */
    } else if (lStatus == ERROR_MORE_DATA) { /* buffer not big enough */
        /* do whatever */
        ;
    }
    /* Now open the subkey that pertains to this vendor's library */
    lStatus = RegOpenKeyEx(hkSniaHba, cSubKeyName, 0, KEY_READ,
                   &hkVendorLib);
    if (lStatus != ERROR_SUCCESS) {
        RegCloseKey(hkSniaHba);
        /* ???Opportunity to send error msg, installation error */
        return HBA_STATUS_ERROR; /* you may want to return something
                      * else or keep trying */
    }
    /* The name of the library is contained in a REG_SZ Value
     * keyed to "LibraryFile" */
    dwSize = MAX_PATH;
    lStatus = RegQueryValueEx(hkVendorLib, "LibraryFile", NULL, &dwType,
                  byFileName, &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        RegCloseKey(hkVendorLib);
        /* ???Opportunity to send error msg, installation error */
        continue;
    }
    lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof(HBA_LIBRARY_INFO));
    if(lib_infop == NULL) {
        /* what is the right thing to do in MS land??? */
        RegCloseKey(hkVendorLib);
        /* ???Opportunity to send error msg, installation error */
        return(HBA_STATUS_ERROR);
    }
    lib_infop->status = HBA_LIBRARY_NOT_LOADED;
    lib_infop->next = _hbaapi_librarylist;
    lib_infop->index = _hbaapi_total_library_count;
    _hbaapi_total_library_count++;
    _hbaapi_librarylist = lib_infop;

    /* Now I can try to load the library */
    lib_infop->hLibrary = LoadLibrary(byFileName);
    if (lib_infop->hLibrary == NULL){
        /* printf("unable to load library %s\n", librarypath); */
        /* ???Opportunity to send error msg, installation error */
        goto dud_library;
    }
    lib_infop->LibraryPath = strdup(byFileName);
    DEBUG(1, "HBAAPI loading: %s\n", byFileName, 0, 0);

    /* Call the registration function to get the list of pointers */
    RegisterV2Func = (HBARegisterLibraryV2Func)
        GetProcAddress(lib_infop->hLibrary, "HBA_RegisterLibraryV2");
    if (RegisterV2Func != NULL) {
        /* Load the function pointers directly into
         * the table of functions */
        status = ((RegisterV2Func)(&lib_infop->functionTable));
        if (status != HBA_STATUS_OK) {
        /* library not loaded */
        /* ???Opportunity to send error msg, library error? */
        goto dud_library;
        }
    } else {
        /* Maybe the vendor library is only Rev1 */
        RegisterFunc = (HBARegisterLibraryFunc)
        GetProcAddress(lib_infop->hLibrary, "HBA_RegisterLibrary");
        if(RegisterFunc == NULL) {
        /* ???Opportunity to send error msg, library error? */
        goto dud_library;
        }
        /* Load the function points directly into
         * the Rev 2 table of functions */
        status = ((RegisterFunc)(
        (HBA_ENTRYPOINTS *)(&lib_infop->functionTable)));
        if (status != HBA_STATUS_OK) {
        /* library not loaded */
        /* ???Opportunity to send error msg, library error? */
        goto dud_library;
        }
    }

    /* successfully loaded library */
    GetVersionFunc = lib_infop->functionTable.GetVersionHandler;
    if (GetVersionFunc == NULL) {
        /* ???Opportunity to send error msg, library error? */
        goto dud_library;
    }
    /* Check the version of this library before loading */
    /* Actually... This wrapper is compatible with version 1 */
    libversion = ((GetVersionFunc)());
#ifdef NOTDEF /* save for a later time... when it matters */
    if (libversion < HBA_LIBVERSION) {
        goto dud_library;
    }
#endif
    LoadLibraryFunc = lib_infop->functionTable.LoadLibraryHandler;
    if (LoadLibraryFunc == NULL) {
        /* Hmmm, dont we need to flag this in a realy big way??? */
        /* How about messages to the system event logger ??? */
        /* ???Opportunity to send error msg, library error? */
        goto dud_library;
    }
    /* Initialize this library */
    status = ((LoadLibraryFunc)());
    if (status != HBA_STATUS_OK) {
        /* ???Opportunity to send error msg, library error? */
        continue;
    }
    /* successfully loaded library */
    lib_infop->status = HBA_LIBRARY_LOADED;

    dud_library: /* its also just the end of the loop */
    RegCloseKey(hkVendorLib);
    }
    RegCloseKey(hkSniaHba);

#else /* Unix as opposed to Win32 */
    FILE        *hbaconf;
    char        fullline[512];      /* line read from HBA.conf */
    char        *libraryname;       /* Read in from file HBA.conf */
    char        *librarypath;       /* Read in from file HBA.conf */
    char        hbaConfFilePath[256];
    char        *charPtr;
    HBA_LIBRARY_INFO    *lib_infop;

    if(_hbaapi_librarylist != NULL) {
    fprintf(stderr,
        "HBA_LoadLibrary: previously unfreed "
        "libraries exist, call HBA_FreeLibrary().\n");
    return HBA_STATUS_ERROR_ALREADY_LOADED;
    }

    strcpy(hbaConfFilePath, "/etc/hba.conf");

    if ((hbaconf = fopen(hbaConfFilePath, "r")) == NULL) {
    printf("Cannot open %s\n", hbaConfFilePath);
    return HBA_STATUS_ERROR;
    }

    /* Read in each line and load library */
    while ((hbaconf != NULL) && (fgets(fullline, sizeof(fullline), hbaconf))) {
    /* Skip the comments... */
    if ((fullline[0] == '#') || (fullline[0] == '\n')) {
        continue;
    }

    /* grab first 'thing' in line (if its there)*/
    if((libraryname = strtok(fullline, " \t\n")) != NULL) {
        if(strlen(libraryname) >= 64) {
        fprintf(stderr, "Library name(%s) in %s is > 64 characters\n",
            libraryname, hbaConfFilePath);
        }
    }
    /* grab second 'thing' in line (if its there)*/
    if((librarypath = strtok(NULL, " \t\n")) != NULL) {
        if(strlen(librarypath) >= 256) {
        fprintf(stderr, "Library path(%s) in %s is > 256 characters\n",
            librarypath, hbaConfFilePath);
        }
    }

    /* there should be no more 'things' in the line */
    if((charPtr = strtok(NULL, " \n\t")) != NULL) {
        fprintf(stderr, "Extraneous characters (\"%s\") in %s\n",
            charPtr, hbaConfFilePath);
    }

    /* Continue to the next line if library name or path is invalid */
    if (libraryname == NULL ||
        strlen(libraryname) == 0 ||
        librarypath == NULL ||
        (strlen(librarypath) == 0)) {
        continue;
    }
    /*
     * Special case....
     * Look for loglevel
     */
    if(strcmp(libraryname, "debuglevel") == 0) {
        _hbaapi_debuglevel = strtol(librarypath, NULL, 10);
        /* error handling does the right thing automagically */
        continue;
    }

    lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof(HBA_LIBRARY_INFO));
    if(lib_infop == NULL) {
        fprintf(stderr, "HBA_LoadLibrary: out of memeory\n");
        return(HBA_STATUS_ERROR);
    }
    lib_infop->status = HBA_LIBRARY_NOT_LOADED;
    lib_infop->LibraryName = strdup(libraryname);
    lib_infop->LibraryPath = strdup(librarypath);
    lib_infop->index = _hbaapi_total_library_count;
    _hbaapi_total_library_count++;
    lib_infop->next = _hbaapi_librarylist;
    _hbaapi_librarylist = lib_infop;

    /* Load the DLL now */
    if((lib_infop->hLibrary = dlopen(librarypath,RTLD_LAZY)) == NULL) {
        /*printf("unable to load library %s\n", librarypath); */
        continue;
    }
    /* Call the registration function to get the list of pointers */
    RegisterV2Func = (HBARegisterLibraryV2Func)
        dlsym(lib_infop->hLibrary, "HBA_RegisterLibraryV2");
    if (RegisterV2Func != NULL) {
        /* Load the function points directly into
         * the table of functions */
        status = ((RegisterV2Func)(&lib_infop->functionTable));
        if (status != HBA_STATUS_OK) {
        /* library not loaded */
        continue;
        }
    } else {
        /* Maybe the vendor library is only Rev1 */
        RegisterFunc = (HBARegisterLibraryFunc)
        dlsym(lib_infop->hLibrary, "HBA_RegisterLibrary");
        if(RegisterFunc == NULL) {
        /* This function is required */
        fprintf(stderr,
            "HBA_LoadLibrary: vendor specific RegisterLibrary "
            "function not found.  lib: %s\n", librarypath);
        DEBUG(0, "HBA_LoadLibrary: vendor specific RegisterLibrary "
              "function not found.  lib: %s\n", librarypath, 0, 0);
        continue;
        }
        /* Load the function points directly into
         * the table of functions */
        status = ((RegisterFunc)
              ((HBA_ENTRYPOINTS *)(&lib_infop->functionTable)));
        if (status != HBA_STATUS_OK) {
        /* library not loaded */
        fprintf(stderr,
            "HBA_LoadLibrary: vendor specific RegisterLibrary "
            "function encountered an error.  lib: %s\n", librarypath);
        DEBUG(0, "HBA_LoadLibrary: vendor specific RegisterLibrary "
              "function encountered an error. lib: %s\n", librarypath, 0, 0);
        continue;
        }
    }

    /* successfully loaded library */
    if((GetVersionFunc = lib_infop->functionTable.GetVersionHandler)
       == NULL) {
        continue;
    }
    libversion = ((GetVersionFunc)());
    /* Check the version of this library before loading */
    /* Actually... This wrapper is compatible with version 1 */
#ifdef NOTDEF /* save for a later time... when it matters */
    if(libversion < HBA_LIBVERSION) {
        printf("Library version mismatch. Got %d expected %d.\n",
           libversion, HBA_LIBVERSION);
        continue;
    }
#endif
    DEBUG(1, "%s libversion = %d", librarypath, libversion, 0);
    LoadLibraryFunc = lib_infop->functionTable.LoadLibraryHandler;
    if (LoadLibraryFunc == NULL) {
        /* this function is required */
        fprintf(stderr,
            "HBA_LoadLibrary: vendor specific LoadLibrary "
            "function not found.  lib: %s\n", librarypath);
        DEBUG(0, "HBA_LoadLibrary: vendor specific LoadLibrary "
            "function not found.  lib: %s\n", librarypath, 0, 0);
        continue;
    }
    /* Initialize this library */
    if((status = ((LoadLibraryFunc)())) != HBA_STATUS_OK) {
        /* maybe this should be a printf so that we CANNOT miss it */
        fprintf(stderr,
            "HBA_LoadLibrary: Encounterd and error loading: %s",
            librarypath);
        DEBUG(0, "Encounterd and error loading: %s", librarypath, 0, 0);
        DEBUG(0, "  HBA_STATUS: %d", status, 0, 0);
        continue;
    }
    /* successfully loaded library */
    lib_infop->status = HBA_LIBRARY_LOADED;
    }

    fclose(hbaconf);
#endif /* WIN32 or UNIX */
#ifdef POSIX_THREADS
    ret = pthread_mutex_init(&_hbaapi_LL_mutex, NULL);
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_AL_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_AAE_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_AE_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_APE_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_APSE_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_TE_mutex, NULL);
    }
    if(ret == 0) {
    ret = pthread_mutex_init(&_hbaapi_LE_mutex, NULL);
    }
    if(ret != 0) {
    perror("pthread_mutec_init - HBA_LoadLibrary");
    return(HBA_STATUS_ERROR);
    }
#elif defined(WIN32)
    InitializeCriticalSection(&_hbaapi_LL_mutex);
    InitializeCriticalSection(&_hbaapi_AL_mutex);
    InitializeCriticalSection(&_hbaapi_AAE_mutex);
    InitializeCriticalSection(&_hbaapi_AE_mutex);
    InitializeCriticalSection(&_hbaapi_APE_mutex);
    InitializeCriticalSection(&_hbaapi_APSE_mutex);
    InitializeCriticalSection(&_hbaapi_TE_mutex);
    InitializeCriticalSection(&_hbaapi_LE_mutex);
#endif


    return HBA_STATUS_OK;
}

HBA_STATUS
HBA_FreeLibrary(void) {
    HBAFreeLibraryFunc  FreeLibraryFunc;
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_LIBRARY_INFO    *lib_next;
    HBA_ADAPTERCALLBACK_ELEM
            ***listp;
    HBA_ADAPTER_INFO    *adapt_infop;
    HBA_ADAPTER_INFO    *adapt_next;

    ARE_WE_INITED();
    GRAB_MUTEX(&_hbaapi_LL_mutex);
    GRAB_MUTEX(&_hbaapi_AL_mutex);

    DEBUG(1, "HBA_FreeLibrary()", 0, 0, 0);
    for(lib_infop = _hbaapi_librarylist; lib_infop != NULL; lib_infop = lib_next) {
    lib_next = lib_infop->next;
    if (lib_infop->status == HBA_LIBRARY_LOADED) {
        FreeLibraryFunc = lib_infop->functionTable.FreeLibraryHandler;
        if (FreeLibraryFunc != NULL) {
        /* Free this library */
        status = ((FreeLibraryFunc)());
        }
#ifdef WIN32
        FreeLibrary(lib_infop->hLibrary);   /* Unload DLL from memory */
#else
        dlclose(lib_infop->hLibrary);   /* Unload DLL from memory */
#endif
    }
#ifndef WIN32
    free(lib_infop->LibraryName);
#endif
    free(lib_infop->LibraryPath);
    free(lib_infop);

    }
    _hbaapi_librarylist = NULL;
    /* OK, now all functions are disabled except for LoadLibrary,
     * Hope no other thread calls it before we have returned */
    _hbaapi_total_library_count = 0;

    for(adapt_infop = _hbaapi_adapterlist;
    adapt_infop != NULL;
    adapt_infop = adapt_next) {
    adapt_next = adapt_infop->next;
    free(adapt_infop->name);
    free(adapt_infop);
    }
    _hbaapi_adapterlist = NULL;
    _hbaapi_total_adapter_count = 0;

    /* Free up the callbacks, this is not the most efficient, but it works */
    while((volatile HBA_ADAPTERCALLBACK_ELEM *)
      _hbaapi_adapteraddevents_callback_list
      != NULL) {
    local_remove_callback((HBA_CALLBACKHANDLE)
               _hbaapi_adapteraddevents_callback_list);
    }
    for(listp = cb_lists_array; *listp != NULL; listp++) {
    while((volatile HBA_ADAPTERCALLBACK_ELEM ***)**listp != NULL) {
        local_remove_callback((HBA_CALLBACKHANDLE)**listp);
    }
    }

    RELEASE_MUTEX(&_hbaapi_AL_mutex);
    RELEASE_MUTEX(&_hbaapi_LL_mutex);

#ifdef USESYSLOG
    closelog();
#endif
#ifdef USELOGFILE
    if(_hbaapi_debug_fd != NULL) {
    fclose(_hbaapi_debug_fd);
    }
    _hbaapi_debug_fd = NULL;
#endif
#ifdef POSIX_THREADS
    /* this will unlock them as well, but who cares */
    pthread_mutex_destroy(&_hbaapi_LE_mutex);
    pthread_mutex_destroy(&_hbaapi_TE_mutex);
    pthread_mutex_destroy(&_hbaapi_APSE_mutex);
    pthread_mutex_destroy(&_hbaapi_APE_mutex);
    pthread_mutex_destroy(&_hbaapi_AE_mutex);
    pthread_mutex_destroy(&_hbaapi_AAE_mutex);
    pthread_mutex_destroy(&_hbaapi_AL_mutex);
    pthread_mutex_destroy(&_hbaapi_LL_mutex);
#elif defined(WIN32)
    DeleteCriticalSection(&_hbaapi_LL_mutex);
    DeleteCriticalSection(&_hbaapi_AL_mutex);
    DeleteCriticalSection(&_hbaapi_AAE_mutex);
    DeleteCriticalSection(&_hbaapi_AE_mutex);
    DeleteCriticalSection(&_hbaapi_APE_mutex);
    DeleteCriticalSection(&_hbaapi_APSE_mutex);
    DeleteCriticalSection(&_hbaapi_TE_mutex);
    DeleteCriticalSection(&_hbaapi_LE_mutex);
#endif

    return HBA_STATUS_OK;
}

/*
 * The API used to use fixed size tables as its primary data structure.
 * Indexing from 1 to N identified each adapters.  Now the adapters are
 * on a linked list.  There is a unique "index" foreach each adapter.
 * Adapters always keep their index, even if they are removed from the
 * hardware.  The only time the indexing is reset is on HBA_FreeLibrary
 */
HBA_UINT32
HBA_GetNumberOfAdapters(void) {
    int j=0;
    HBA_LIBRARY_INFO    *lib_infop;
    HBAGetNumberOfAdaptersFunc
            GetNumberOfAdaptersFunc;
    HBAGetAdapterNameFunc
            GetAdapterNameFunc;
    HBA_BOOLEAN     found_name;
    HBA_ADAPTER_INFO    *adapt_infop;
    HBA_STATUS      status;

    char adaptername[256];
    int num_adapters; /* local */

    if(_hbaapi_librarylist == NULL) {
    return (0);
    }
    GRAB_MUTEX(&_hbaapi_LL_mutex); /* pay attention to order */
    GRAB_MUTEX(&_hbaapi_AL_mutex);

    for (lib_infop = _hbaapi_librarylist;
     lib_infop != NULL;
     lib_infop = lib_infop->next) {

    if (lib_infop->status != HBA_LIBRARY_LOADED) {
        continue;
    }

    GetNumberOfAdaptersFunc =
        lib_infop->functionTable.GetNumberOfAdaptersHandler;
    if (GetNumberOfAdaptersFunc == NULL)  {
        continue;
    }
    num_adapters = ((GetNumberOfAdaptersFunc)());
#ifndef WIN32
    DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
          lib_infop->LibraryName, num_adapters, 0);
#else
    DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
          lib_infop->LibraryPath, num_adapters, 0);
#endif

    /* Also get the names of all the adapters here and cache */
    GetAdapterNameFunc = lib_infop->functionTable.GetAdapterNameHandler;
    if(GetAdapterNameFunc == NULL) {
        continue;
    }

    for (j = 0; j < num_adapters; j++) {
        found_name = 0;
        status = (GetAdapterNameFunc)(j, (char *)&adaptername);
        if(status == HBA_STATUS_OK) {
        for(adapt_infop = _hbaapi_adapterlist;
            adapt_infop != NULL;
            adapt_infop = adapt_infop->next) {
            /*
             * check for duplicates, really, this may just be a second
             * call to this function
             * ??? how do we know when a name becomes stale?
             */
            if(strcmp(adaptername, adapt_infop->name) == 0) {
            /* already got this one */
            found_name++;
            break;
            }
        }
        if(found_name != 0) {
            continue;
        }
        }

        adapt_infop = (HBA_ADAPTER_INFO *)
        calloc(1, sizeof(HBA_ADAPTER_INFO));
        if(adapt_infop == NULL) {
#ifndef WIN32
        fprintf(stderr,
            "HBA_GetNumberOfAdapters: calloc failed on sizeof:%d\n",
            sizeof(HBA_ADAPTER_INFO));
#endif
        RELEASE_MUTEX(&_hbaapi_AL_mutex);
        RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
                     _hbaapi_total_adapter_count);
        }
        if((adapt_infop->GNstatus = status) == HBA_STATUS_OK) {
        adapt_infop->name = strdup(adaptername);
        } else {
        char dummyname[512];
        sprintf(dummyname, "NULLADAPTER-%s-%03d",
            lib_infop->LibraryPath, _hbaapi_total_adapter_count);
        dummyname[255] = '\0';
        adapt_infop->name = strdup(dummyname);
        }
        adapt_infop->library = lib_infop;
        adapt_infop->next = _hbaapi_adapterlist;
        adapt_infop->index = _hbaapi_total_adapter_count;
        _hbaapi_adapterlist = adapt_infop;
        _hbaapi_total_adapter_count++;
    }
    }
    RELEASE_MUTEX(&_hbaapi_AL_mutex);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, _hbaapi_total_adapter_count);
}

HBA_STATUS
HBA_GetAdapterName(
    HBA_UINT32 adapterindex,
    char *adaptername)
{
    HBA_ADAPTER_INFO    *adapt_infop;
    HBA_STATUS      ret = HBA_STATUS_ERROR_ILLEGAL_INDEX;

    if (adaptername == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }
    /*
     * The adapter index is from old code, but we have
     * to support it.  Go down the list looking for
     * the adapter
     */
    ARE_WE_INITED();
    GRAB_MUTEX(&_hbaapi_AL_mutex);
    *adaptername = '\0';
    for(adapt_infop = _hbaapi_adapterlist;
    adapt_infop != NULL;
    adapt_infop = adapt_infop->next) {

    if(adapt_infop->index == adapterindex) {
        if(adapt_infop->name != NULL &&
           adapt_infop->GNstatus == HBA_STATUS_OK) {
        strcpy(adaptername, adapt_infop->name);
        } else {
        *adaptername = '\0';
        }
        ret = adapt_infop->GNstatus;
        break;
    }
    }
    DEBUG(2, "GetAdapterName for index:%d ->%s", adapterindex, adaptername, 0);
    RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, ret);
}

HBA_HANDLE
HBA_OpenAdapter(char* adaptername) {
    HBA_HANDLE      handle;
    HBAOpenAdapterFunc  OpenAdapterFunc;
    HBA_ADAPTER_INFO    *adapt_infop;
    HBA_LIBRARY_INFO    *lib_infop;

    DEBUG(2, "OpenAdapter: %s", adaptername, 0, 0);

    if(_hbaapi_librarylist == NULL) {
    return(HBA_HANDLE_INVALID);
    }
    if (adaptername == NULL) {
    return(HBA_STATUS_ERROR_ARG);
    }
    handle = HBA_HANDLE_INVALID;
    GRAB_MUTEX(&_hbaapi_AL_mutex);
    for(adapt_infop = _hbaapi_adapterlist;
    adapt_infop != NULL;
    adapt_infop = adapt_infop->next) {
    if (strcmp(adaptername, adapt_infop->name) != 0) {
        continue;
    }
    lib_infop = adapt_infop->library;
    OpenAdapterFunc =
        lib_infop->functionTable.OpenAdapterHandler;
    if (OpenAdapterFunc != NULL) {
        /* retrieve the vendor handle */
        handle = (OpenAdapterFunc)(adaptername);
        if(handle != 0) {
        /* or this with the library index to get the common handle */
        handle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
        }
    }
    break;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, handle);
}
/*
 * This function ignores the list of known adapters and instead tries
 * each vendors open function to see if one of them
 * can open an adapter when referenced with a particular WWN
 */
HBA_STATUS
HBA_OpenAdapterByWWN(HBA_HANDLE *phandle, HBA_WWN nodeWWN) {
    HBA_HANDLE      handle;
    HBA_LIBRARY_INFO    *lib_infop;
    HBAGetNumberOfAdaptersFunc
            GetNumberOfAdaptersFunc;
    HBAOpenAdapterByWWNFunc
            OpenAdapterFunc;
    HBA_STATUS      status;

    DEBUG(2, "OpenAdapterByWWN: %s", WWN2STR1(&nodeWWN), 0, 0);

    if (phandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    ARE_WE_INITED();

    *phandle = HBA_HANDLE_INVALID;

    GRAB_MUTEX(&_hbaapi_LL_mutex);
    for (lib_infop = _hbaapi_librarylist;
     lib_infop != NULL;
     lib_infop = lib_infop->next) {

    status = HBA_STATUS_ERROR_ILLEGAL_WWN;

    if (lib_infop->status != HBA_LIBRARY_LOADED) {
        continue;
    }

    GetNumberOfAdaptersFunc =
        lib_infop->functionTable.GetNumberOfAdaptersHandler;
    if (GetNumberOfAdaptersFunc == NULL)  {
        continue;
    }

    /* look for new hardware */
    (void) ((GetNumberOfAdaptersFunc)());

    OpenAdapterFunc = lib_infop->functionTable.OpenAdapterByWWNHandler;
    if (OpenAdapterFunc == NULL) {
        continue;
    }
    /*
     * We do not know if the WWN is known by this vendor,
     * just try it
     */
    if((status = (OpenAdapterFunc)(&handle, nodeWWN)) != HBA_STATUS_OK) {
        continue;
    }
    /* OK, make a vendor non-specific handle */
    *phandle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
    status = HBA_STATUS_OK;
    break;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

void
HBA_RefreshAdapterConfiguration() {
    DEBUG(2, "HBA_RefreshAdapterConfiguration", 0, 0, 0);
    (void)HBA_GetNumberOfAdapters();
    return;
}

HBA_UINT32
HBA_GetVersion() {
    DEBUG(2, "HBA_GetVersion", 0, 0, 0);
    return HBA_LIBVERSION;
}

/*
 * This function is VERY OS dependent.  Wing it as best you can.
 */
HBA_UINT32
HBA_GetWrapperLibraryAttributes (
    HBA_LIBRARYATTRIBUTES *attributes)
{

    DEBUG(2, "HBA_GetWrapperLibraryAttributes", 0, 0, 0);

    if (attributes == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    memset(attributes, 0, sizeof(HBA_LIBRARYATTRIBUTES));

#if defined(SOLARIS)
    if((handle = dlopen("libHBAAPI.so", RTLD_NOW)) != NULL) {
    if(dlinfo(handle, RTLD_DI_LINKMAP, &map) >= 0) {
        for(mp = map; mp != NULL; mp = mp->l_next) {
        if(strlen(map->l_name) < 256) {
            strcpy(attributes->LibPath, map->l_lname);
        }
        }
    }
    }
#elif defined(WIN32)
    {
    HMODULE module;

    /* No need to do anything with the module handle */
    /* It wasn't alloocated so it doesn't need to be freed */
    module = GetModuleHandle("HBAAPI");
    if ( module != NULL ) {
        if ( GetModuleFileName(module, attributes->LibPath,
                sizeof(attributes->LibPath)) == 0 ) {
            attributes->LibPath[0] = '\0';
        }
    }
    }
#endif
#if defined(VENDOR)
    strcpy(attributes->VName, VENDOR);
#else
    attributes->VName[0] = '\0';
#endif
#if defined(VERSION)
    strcpy(attributes->VVersion, VERSION);
#else
    attributes->VVersion[0] = '\0';
#endif
#if defined(BUILD_DATE)
#if defined(WIN32)
    {
    int matchCount;
    matchCount = sscanf(BUILD_DATE, "%u/%u/%u %u:%u:%u",
        &attributes->build_date.tm_year,
        &attributes->build_date.tm_mon,
        &attributes->build_date.tm_mday,
        &attributes->build_date.tm_hour,
        &attributes->build_date.tm_min,
        &attributes->build_date.tm_sec
    );

    if ( matchCount != 6 ) {
        memset(&attributes->build_date, 0, sizeof(struct tm));
    } else {
        attributes->build_date.tm_year -= 1900;
        attributes->build_date.tm_isdst = -1;
    }

    }
#else
    if(strptime(BUILD_DATE, "%Y/%m/%d %T %Z", &(attributes->build_date)) == NULL) {
    memset(&attributes->build_date, 0, sizeof(struct tm));
    }
#endif
#else
    memset(&attributes->build_date, 0, sizeof(struct tm));
#endif
    return 2;
}

/*
 * Callback registation and handling
 */
HBA_STATUS
HBA_RemoveCallback (HBA_CALLBACKHANDLE cbhandle) {
    HBA_STATUS  status;

    DEBUG(2, "HBA_RemoveCallback", 0, 0, 0);
    ARE_WE_INITED();

    GRAB_MUTEX(&_hbaapi_LL_mutex);
    status = local_remove_callback(cbhandle);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

/* Adapter Add Events *********************************************************/
static void
adapteraddevents_callback (void *data, HBA_WWN PortWWN, HBA_UINT32 eventType) {
    HBA_ALLADAPTERSCALLBACK_ELEM    *cbp;

    DEBUG(3, "AddAdapterEvent, port:%s", WWN2STR1(&PortWWN), 0, 0);

    GRAB_MUTEX(&_hbaapi_AAE_mutex);
    for(cbp = _hbaapi_adapteraddevents_callback_list;
    cbp != NULL;
    cbp = cbp->next) {
    (*cbp->callback)(data, PortWWN, HBA_EVENT_ADAPTER_ADD);
    }
    RELEASE_MUTEX(&_hbaapi_AAE_mutex);

}
HBA_STATUS
HBA_RegisterForAdapterAddEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     PortWWN,
    HBA_UINT32  eventType
    ),
    void        *userData,
    HBA_CALLBACKHANDLE *callbackHandle) {

    HBA_ALLADAPTERSCALLBACK_ELEM    *cbp;
    HBA_VENDORCALLBACK_ELEM     *vcbp;
    HBA_VENDORCALLBACK_ELEM     *vendorhandlelist;
    HBARegisterForAdapterAddEventsFunc  registeredfunc;
    HBA_STATUS              status = HBA_STATUS_OK;
    HBA_STATUS              failure = HBA_STATUS_OK;
    HBA_LIBRARY_INFO            *lib_infop;
    int                 registered_cnt = 0;
    int                 vendor_cnt = 0;
    int                 not_supported_cnt = 0;
    int                 status_OK_bar_cnt = 0;
    int                 status_OK_cnt = 0;

    DEBUG(2, "HBA_RegisterForAdapterAddEvents", 0, 0, 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }
    ARE_WE_INITED();

    cbp = (HBA_ALLADAPTERSCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ALLADAPTERSCALLBACK_ELEM));
    *callbackHandle = (HBA_CALLBACKHANDLE) cbp;
    if(cbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForAdapterAddEvents: calloc failed for %d bytes\n",
        sizeof(HBA_ALLADAPTERSCALLBACK_ELEM));
#endif
    return HBA_STATUS_ERROR;
    }

    GRAB_MUTEX(&_hbaapi_LL_mutex);
    GRAB_MUTEX(&_hbaapi_AAE_mutex);
    cbp->callback = callback;
    cbp->next = _hbaapi_adapteraddevents_callback_list;
    _hbaapi_adapteraddevents_callback_list = cbp;
    /* Need to release the mutex now incase the vendor function invokes the
     * callback.  We will grap the mutex later to attach the vendor handle list
     * to the callback structure */
    RELEASE_MUTEX(&_hbaapi_AAE_mutex);


    /*
     * now create a list of vendors (vendor libraryies, NOT ADAPTERS) that have
     * successfully registerred
     */
    vendorhandlelist = NULL;
    for(lib_infop = _hbaapi_librarylist;
    lib_infop != NULL;
    lib_infop = lib_infop->next) {

    vendor_cnt++;

    registeredfunc =
        lib_infop->functionTable.RegisterForAdapterAddEventsHandler;
    if(registeredfunc == NULL) {
        continue;
    }

    vcbp = (HBA_VENDORCALLBACK_ELEM *)
        calloc(1, sizeof(HBA_VENDORCALLBACK_ELEM));
    if(vcbp == NULL) {
#ifndef WIN32
        fprintf(stderr,
            "HBA_RegisterForAdapterAddEvents: "
            "calloc failed for %d bytes\n",
            sizeof(HBA_VENDORCALLBACK_ELEM));
#endif
        freevendorhandlelist(vendorhandlelist);
        status = HBA_STATUS_ERROR;
        break;
    }

    registered_cnt++;
    status = (registeredfunc)(adapteraddevents_callback,
                  userData, &vcbp->vendorcbhandle);
    if(status == HBA_STATUS_ERROR_NOT_SUPPORTED) {
        not_supported_cnt++;
        free(vcbp);
        continue;
    } else if (status != HBA_STATUS_OK) {
        status_OK_bar_cnt++;
        DEBUG(0,
          "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
          lib_infop->LibraryPath, status, 0);
#ifndef WIN32
        fprintf(stderr,
            "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
            lib_infop->LibraryPath, status);
#endif
        failure = status;
        free(vcbp);
        continue;
    } else {
        status_OK_cnt++;
    }
    vcbp->lib_info = lib_infop;
    vcbp->next = vendorhandlelist;
    vendorhandlelist = vcbp;
    }
    if(registered_cnt == 0) {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    freevendorhandlelist(vendorhandlelist);
    local_remove_callback((HBA_CALLBACKHANDLE) cbp);
    } else if (status_OK_cnt == 0 && not_supported_cnt != 0) {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    } else if (status_OK_cnt == 0) {
    /* At least one vendor library registered this function, but no
     * vendor call succeeded */
    local_remove_callback((HBA_CALLBACKHANDLE) cbp);
    status = failure;
    } else {
    /* we have had atleast some success, now finish up */
    GRAB_MUTEX(&_hbaapi_AAE_mutex);
    /* this seems silly, but what if another thread called
     * the callback remove */
    for(cbp = _hbaapi_adapteraddevents_callback_list;
        cbp != NULL; cbp = cbp->next) {
        if((HBA_CALLBACKHANDLE)cbp == *callbackHandle) {
        /* yup, its still there, hooray */
        cbp->vendorhandlelist = vendorhandlelist;
        vendorhandlelist = NULL;
        break;
        }
    }
    RELEASE_MUTEX(&_hbaapi_AAE_mutex);
    if(vendorhandlelist != NULL) {
        /* bummer, somebody removed the callback before we finished
         * registration, probably will never happen */
        freevendorhandlelist(vendorhandlelist);
        DEBUG(0,
          "HBA_RegisterForAdapterAddEvents: HBA_RemoveCallback was "
          "called for a handle before registration was finished.",
          0, 0, 0);
        status = HBA_STATUS_ERROR;
    } else {
        status = HBA_STATUS_OK;
    }
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

/* Adapter Events (other than add) ********************************************/
static void
adapterevents_callback (void *data,
            HBA_WWN PortWWN,
            HBA_UINT32 eventType) {
    HBA_ADAPTERCALLBACK_ELEM    *acbp;

    DEBUG(3, "AdapterEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
      eventType, 0);

    GRAB_MUTEX(&_hbaapi_AE_mutex);
    for(acbp = _hbaapi_adapterevents_callback_list;
    acbp != NULL;
    acbp = acbp->next) {
    if(data == (void *)acbp) {
        (*acbp->callback)(acbp->userdata, PortWWN, eventType);
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_AE_mutex);
}
HBA_STATUS
HBA_RegisterForAdapterEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     PortWWN,
    HBA_UINT32  eventType
    ),
    void        *userData,
    HBA_HANDLE      handle,
    HBA_CALLBACKHANDLE  *callbackHandle) {

    HBA_ADAPTERCALLBACK_ELEM        *acbp;
    HBARegisterForAdapterEventsFunc registeredfunc;
    HBA_STATUS              status;
    HBA_LIBRARY_INFO            *lib_infop;
    HBA_HANDLE              vendorHandle;

    DEBUG(2, "HBA_RegisterForAdapterEvents", 0, 0, 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    CHECKLIBRARY();

    /* we now have the _hbaapi_LL_mutex */

    registeredfunc = lib_infop->functionTable.RegisterForAdapterEventsHandler;
    if(registeredfunc == NULL) {
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
    }

    /*
     * that allocated memory is used both as the handle for the
     * caller, and as userdata to the vendor call so that on
     * callback the specific registration may be recalled
     */
    acbp = (HBA_ADAPTERCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ADAPTERCALLBACK_ELEM));
    if(acbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForAdapterEvents: calloc failed for %d bytes\n",
        sizeof(HBA_ADAPTERCALLBACK_ELEM));
#endif
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
    }
    *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
    acbp->callback = callback;
    acbp->userdata = userData;
    acbp->lib_info = lib_infop;

    status = (registeredfunc)(adapterevents_callback,
                  (void *)acbp,
                  vendorHandle,
                  &acbp->vendorcbhandle);
    if(status != HBA_STATUS_OK) {
    free(acbp);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
    }

    GRAB_MUTEX(&_hbaapi_AE_mutex);
    acbp->next = _hbaapi_adapterevents_callback_list;
    _hbaapi_adapterevents_callback_list = acbp;
    RELEASE_MUTEX(&_hbaapi_AE_mutex);

    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
}

/* Adapter Port Events ********************************************************/
static void
adapterportevents_callback (void *data,
                HBA_WWN PortWWN,
                HBA_UINT32 eventType,
                HBA_UINT32 fabricPortID) {
    HBA_ADAPTERCALLBACK_ELEM    *acbp;

    DEBUG(3, "AdapterPortEvent, port:%s, eventType:%d fabricPortID:0X%06x",
      WWN2STR1(&PortWWN), eventType, fabricPortID);

    GRAB_MUTEX(&_hbaapi_APE_mutex);

    for(acbp = _hbaapi_adapterportevents_callback_list;
    acbp != NULL;
    acbp = acbp->next) {
    if(data == (void *)acbp) {
        (*acbp->callback)(acbp->userdata, PortWWN, eventType, fabricPortID);
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_APE_mutex);
}
HBA_STATUS
HBA_RegisterForAdapterPortEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     PortWWN,
    HBA_UINT32  eventType,
    HBA_UINT32  fabricPortID
    ),
    void        *userData,
    HBA_HANDLE      handle,
    HBA_WWN     PortWWN,
    HBA_CALLBACKHANDLE  *callbackHandle) {

    HBA_ADAPTERCALLBACK_ELEM        *acbp;
    HBARegisterForAdapterPortEventsFunc registeredfunc;
    HBA_STATUS              status;
    HBA_LIBRARY_INFO            *lib_infop;
    HBA_HANDLE              vendorHandle;

    DEBUG(2, "HBA_RegisterForAdapterPortEvents for port: %s",
      WWN2STR1(&PortWWN), 0, 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    CHECKLIBRARY();
    /* we now have the _hbaapi_LL_mutex */

    registeredfunc =
    lib_infop->functionTable.RegisterForAdapterPortEventsHandler;
    if(registeredfunc == NULL) {
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
    }

    /*
     * that allocated memory is used both as the handle for the
     * caller, and as userdata to the vendor call so that on
     * callback the specific registration may be recalled
     */
    acbp = (HBA_ADAPTERCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ADAPTERCALLBACK_ELEM));
    if(acbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForAdapterPortEvents: "
        "calloc failed for %d bytes\n",
        sizeof(HBA_ADAPTERCALLBACK_ELEM));
#endif
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);

    }
    *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
    acbp->callback = callback;
    acbp->userdata = userData;
    acbp->lib_info = lib_infop;

    status = (registeredfunc)(adapterportevents_callback,
                  (void *)acbp,
                  vendorHandle,
                  PortWWN,
                  &acbp->vendorcbhandle);
    if(status != HBA_STATUS_OK) {
    free(acbp);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
    }

    GRAB_MUTEX(&_hbaapi_APE_mutex);
    acbp->next = _hbaapi_adapterportevents_callback_list;
    _hbaapi_adapterportevents_callback_list = acbp;
    RELEASE_MUTEX(&_hbaapi_APE_mutex);

    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
}

/* Adapter State Events *******************************************************/
static void
adapterportstatevents_callback (void *data,
                HBA_WWN PortWWN,
                HBA_UINT32 eventType) {
    HBA_ADAPTERCALLBACK_ELEM    *acbp;

    DEBUG(3, "AdapterPortStateEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
      eventType, 0);

    GRAB_MUTEX(&_hbaapi_APSE_mutex);
    for(acbp = _hbaapi_adapterportstatevents_callback_list;
    acbp != NULL;
    acbp = acbp->next) {
    if(data == (void *)acbp) {
        (*acbp->callback)(acbp->userdata, PortWWN, eventType);
        return;
    }
    }
}
HBA_STATUS
HBA_RegisterForAdapterPortStatEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     PortWWN,
    HBA_UINT32  eventType
    ),
    void        *userData,
    HBA_HANDLE      handle,
    HBA_WWN     PortWWN,
    HBA_PORTSTATISTICS  stats,
    HBA_UINT32      statType,
    HBA_CALLBACKHANDLE  *callbackHandle) {

    HBA_ADAPTERCALLBACK_ELEM    *acbp;
    HBARegisterForAdapterPortStatEventsFunc
                registeredfunc;
    HBA_STATUS          status;
    HBA_LIBRARY_INFO        *lib_infop;
    HBA_HANDLE          vendorHandle;

    DEBUG(2, "HBA_RegisterForAdapterPortStatEvents for port: %s",
      WWN2STR1(&PortWWN), 0, 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    CHECKLIBRARY();
    /* we now have the _hbaapi_LL_mutex */

    registeredfunc =
    lib_infop->functionTable.RegisterForAdapterPortStatEventsHandler;
    if(registeredfunc == NULL) {
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
    }

    /*
     * that allocated memory is used both as the handle for the
     * caller, and as userdata to the vendor call so that on
     * callback the specific registration may be recalled
     */
    acbp = (HBA_ADAPTERCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ADAPTERCALLBACK_ELEM));
    if(acbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForAdapterPortStatEvents: "
        "calloc failed for %d bytes\n",
        sizeof(HBA_ADAPTERCALLBACK_ELEM));
#endif
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
    }
    *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
    acbp->callback = callback;
    acbp->userdata = userData;
    acbp->lib_info = lib_infop;

    status = (registeredfunc)(adapterportstatevents_callback,
                  (void *)acbp,
                  vendorHandle,
                  PortWWN,
                  stats,
                  statType,
                  &acbp->vendorcbhandle);
    if(status != HBA_STATUS_OK) {
    free(acbp);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
    }

    GRAB_MUTEX(&_hbaapi_APSE_mutex);
    acbp->next = _hbaapi_adapterportstatevents_callback_list;
    _hbaapi_adapterportstatevents_callback_list = acbp;
    RELEASE_MUTEX(&_hbaapi_APSE_mutex);

    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
}

/* Target Events **************************************************************/
static void
targetevents_callback (void *data,
               HBA_WWN hbaPortWWN,
               HBA_WWN discoveredPortWWN,
               HBA_UINT32 eventType) {
    HBA_ADAPTERCALLBACK_ELEM    *acbp;

    DEBUG(3, "TargetEvent, hbaPort:%s, discoveredPort:%s eventType:%d",
      WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), eventType);

    GRAB_MUTEX(&_hbaapi_TE_mutex);
    for(acbp = _hbaapi_targetevents_callback_list;
    acbp != NULL;
    acbp = acbp->next) {
    if(data == (void *)acbp) {
        (*acbp->callback)(acbp->userdata, hbaPortWWN,
                  discoveredPortWWN, eventType);
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_TE_mutex);
}
HBA_STATUS
HBA_RegisterForTargetEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     discoveredPortWWN,
    HBA_UINT32  eventType
    ),
    void        *userData,
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     discoveredPortWWN,
    HBA_CALLBACKHANDLE  *callbackHandle,
    HBA_UINT32      allTargets) {

    HBA_ADAPTERCALLBACK_ELEM
            *acbp;
    HBARegisterForTargetEventsFunc
            registeredfunc;
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;

    DEBUG(2, "HBA_RegisterForTargetEvents, hbaPort: %s, discoveredPort: %s",
      WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    CHECKLIBRARY();
    /* we now have the _hbaapi_LL_mutex */

    registeredfunc = lib_infop->functionTable.RegisterForTargetEventsHandler;
    if(registeredfunc == NULL) {
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
    }

    /*
     * that allocated memory is used both as the handle for the
     * caller, and as userdata to the vendor call so that on
     * callback the specific registration may be recalled
     */
    acbp = (HBA_ADAPTERCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ADAPTERCALLBACK_ELEM));
    if(acbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForTargetEvents: calloc failed for %d bytes\n",
        sizeof(HBA_ADAPTERCALLBACK_ELEM));
#endif
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
    }
    *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
    acbp->callback = callback;
    acbp->userdata = userData;
    acbp->lib_info = lib_infop;

    status = (registeredfunc)(targetevents_callback,
                  (void *)acbp,
                  vendorHandle,
                  hbaPortWWN,
                  discoveredPortWWN,
                  &acbp->vendorcbhandle,
                  allTargets);
    if(status != HBA_STATUS_OK) {
    free(acbp);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
    }

    GRAB_MUTEX(&_hbaapi_TE_mutex);
    acbp->next = _hbaapi_targetevents_callback_list;
    _hbaapi_targetevents_callback_list = acbp;
    RELEASE_MUTEX(&_hbaapi_TE_mutex);

    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
}

/* Link Events ****************************************************************/
static void
linkevents_callback (void *data,
             HBA_WWN adapterWWN,
             HBA_UINT32 eventType,
             void *pRLIRBuffer,
             HBA_UINT32 RLIRBufferSize) {
    HBA_ADAPTERCALLBACK_ELEM    *acbp;

    DEBUG(3, "LinkEvent, hbaWWN:%s, eventType:%d",
      WWN2STR1(&adapterWWN), eventType, 0);

    GRAB_MUTEX(&_hbaapi_LE_mutex);
    for(acbp = _hbaapi_linkevents_callback_list;
    acbp != NULL;
    acbp = acbp->next) {
    if(data == (void *)acbp) {
        (*acbp->callback)(acbp->userdata, adapterWWN,
                  eventType, pRLIRBuffer, RLIRBufferSize);
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_LE_mutex);
}
HBA_STATUS
HBA_RegisterForLinkEvents (
    void        (*callback) (
    void        *data,
    HBA_WWN     adapterWWN,
    HBA_UINT32  eventType,
    void        *pRLIRBuffer,
    HBA_UINT32  RLIRBufferSize),
    void        *userData,
    void        *pRLIRBuffer,
    HBA_UINT32      RLIRBufferSize,
    HBA_HANDLE      handle,
    HBA_CALLBACKHANDLE  *callbackHandle) {

    HBA_ADAPTERCALLBACK_ELEM    *acbp;
    HBARegisterForLinkEventsFunc
                registeredfunc;
    HBA_STATUS          status;
    HBA_LIBRARY_INFO        *lib_infop;
    HBA_HANDLE          vendorHandle;

    DEBUG(2, "HBA_RegisterForLinkEvents", 0, 0, 0);

    if (callbackHandle == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    CHECKLIBRARY();
    /* we now have the _hbaapi_LL_mutex */

    registeredfunc = lib_infop->functionTable.RegisterForLinkEventsHandler;
    if(registeredfunc == NULL) {
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
    }

    /*
     * that allocated memory is used both as the handle for the
     * caller, and as userdata to the vendor call so that on
     * callback the specific registration may be recalled
     */
    acbp = (HBA_ADAPTERCALLBACK_ELEM *)
    calloc(1, sizeof(HBA_ADAPTERCALLBACK_ELEM));
    if(acbp == NULL) {
#ifndef WIN32
    fprintf(stderr,
        "HBA_RegisterForLinkEvents: calloc failed for %d bytes\n",
        sizeof(HBA_ADAPTERCALLBACK_ELEM));
#endif
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
    }
    *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
    acbp->callback = callback;
    acbp->userdata = userData;
    acbp->lib_info = lib_infop;

    status = (registeredfunc)(linkevents_callback,
                  (void *)acbp,
                  pRLIRBuffer,
                  RLIRBufferSize,
                  vendorHandle,
                  &acbp->vendorcbhandle);
    if(status != HBA_STATUS_OK) {
    free(acbp);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
    }

    GRAB_MUTEX(&_hbaapi_LE_mutex);
    acbp->next = _hbaapi_linkevents_callback_list;
    _hbaapi_linkevents_callback_list = acbp;
    RELEASE_MUTEX(&_hbaapi_LE_mutex);

    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
}


/*
 * All of the functions below are almost passthru functions to the
 * vendor specific function
 */

void
HBA_CloseAdapter(HBA_HANDLE handle) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBACloseAdapterFunc CloseAdapterFunc;

    DEBUG(2, "HBA_CloseAdapter", 0, 0, 0);

    status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
    if (status == HBA_STATUS_OK) {
    CloseAdapterFunc = lib_infop->functionTable.CloseAdapterHandler;
    if (CloseAdapterFunc != NULL) {
        ((CloseAdapterFunc)(vendorHandle));
    }
    RELEASE_MUTEX(&_hbaapi_LL_mutex);
    }
}

HBA_STATUS
HBA_GetAdapterAttributes (
    HBA_HANDLE      handle,
    HBA_ADAPTERATTRIBUTES
            *hbaattributes)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetAdapterAttributesFunc GetAdapterAttributesFunc;

    DEBUG(2, "HBA_GetAdapterAttributes", 0, 0, 0);

    CHECKLIBRARY();
    GetAdapterAttributesFunc =
    lib_infop->functionTable.GetAdapterAttributesHandler;
    if (GetAdapterAttributesFunc != NULL) {
    status = ((GetAdapterAttributesFunc)(vendorHandle, hbaattributes));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetAdapterPortAttributes (
    HBA_HANDLE      handle,
    HBA_UINT32      portindex,
    HBA_PORTATTRIBUTES  *portattributes)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetAdapterPortAttributesFunc
            GetAdapterPortAttributesFunc;

    DEBUG(2, "HBA_GetAdapterPortAttributes", 0, 0, 0);

    CHECKLIBRARY();
    GetAdapterPortAttributesFunc =
    lib_infop->functionTable.GetAdapterPortAttributesHandler;
    if (GetAdapterPortAttributesFunc != NULL) {
    status = ((GetAdapterPortAttributesFunc)
          (vendorHandle, portindex, portattributes));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetPortStatistics (
    HBA_HANDLE      handle,
    HBA_UINT32      portindex,
    HBA_PORTSTATISTICS  *portstatistics)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetPortStatisticsFunc
            GetPortStatisticsFunc;

    DEBUG(2, "HBA_GetPortStatistics", 0, 0, 0);

    CHECKLIBRARY();
    GetPortStatisticsFunc =
    lib_infop->functionTable.GetPortStatisticsHandler;
    if (GetPortStatisticsFunc != NULL) {
    status = ((GetPortStatisticsFunc)
          (vendorHandle, portindex, portstatistics));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetDiscoveredPortAttributes (
    HBA_HANDLE      handle,
    HBA_UINT32      portindex,
    HBA_UINT32      discoveredportindex,
    HBA_PORTATTRIBUTES  *portattributes)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetDiscoveredPortAttributesFunc
            GetDiscoveredPortAttributesFunc;

    DEBUG(2, "HBA_GetDiscoveredPortAttributes", 0, 0, 0);

    CHECKLIBRARY();
    GetDiscoveredPortAttributesFunc =
    lib_infop->functionTable.GetDiscoveredPortAttributesHandler;
    if (GetDiscoveredPortAttributesFunc != NULL)  {
    status = ((GetDiscoveredPortAttributesFunc)
          (vendorHandle, portindex, discoveredportindex,
           portattributes));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetPortAttributesByWWN (
    HBA_HANDLE      handle,
    HBA_WWN     PortWWN,
    HBA_PORTATTRIBUTES  *portattributes)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetPortAttributesByWWNFunc
            GetPortAttributesByWWNFunc;

    DEBUG(2, "HBA_GetPortAttributesByWWN: %s", WWN2STR1(&PortWWN), 0, 0);

    CHECKLIBRARY();
    GetPortAttributesByWWNFunc =
    lib_infop->functionTable.GetPortAttributesByWWNHandler;
    if (GetPortAttributesByWWNFunc != NULL) {
    status = ((GetPortAttributesByWWNFunc)
          (vendorHandle, PortWWN, portattributes));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendCTPassThru (
    HBA_HANDLE      handle,
    void        *pReqBuffer,
    HBA_UINT32      ReqBufferSize,
    void        *pRspBuffer,
    HBA_UINT32      RspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendCTPassThruFunc
            SendCTPassThruFunc;

    DEBUG(2, "HBA_SendCTPassThru", 0, 0, 0);

    CHECKLIBRARY();
    SendCTPassThruFunc = lib_infop->functionTable.SendCTPassThruHandler;
    if (SendCTPassThruFunc != NULL) {
    status = (SendCTPassThruFunc)
        (vendorHandle,
         pReqBuffer, ReqBufferSize,
         pRspBuffer, RspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendCTPassThruV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    void        *pReqBuffer,
    HBA_UINT32      ReqBufferSize,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendCTPassThruV2Func
            registeredfunc;

    DEBUG(2, "HBA_SendCTPassThruV2m hbaPortWWN: %s", WWN2STR1(&hbaPortWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendCTPassThruV2Handler;
    if (registeredfunc != NULL) {
    status = (registeredfunc)
        (vendorHandle, hbaPortWWN,
         pReqBuffer, ReqBufferSize,
         pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetEventBuffer (
    HBA_HANDLE      handle,
    PHBA_EVENTINFO  EventBuffer,
    HBA_UINT32      *EventBufferCount)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetEventBufferFunc
            GetEventBufferFunc;

    DEBUG(2, "HBA_GetEventBuffer", 0, 0, 0);

    CHECKLIBRARY();
    GetEventBufferFunc = lib_infop->functionTable.GetEventBufferHandler;
    if (GetEventBufferFunc != NULL) {
    status = (GetEventBufferFunc)
        (vendorHandle, EventBuffer, EventBufferCount);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SetRNIDMgmtInfo (HBA_HANDLE handle, HBA_MGMTINFO Info) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASetRNIDMgmtInfoFunc
            SetRNIDMgmtInfoFunc;

    DEBUG(2, "HBA_SetRNIDMgmtInfo", 0, 0, 0);

    CHECKLIBRARY();
    SetRNIDMgmtInfoFunc = lib_infop->functionTable.SetRNIDMgmtInfoHandler;
    if (SetRNIDMgmtInfoFunc != NULL) {
    status = (SetRNIDMgmtInfoFunc)(vendorHandle, Info);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetRNIDMgmtInfo (HBA_HANDLE handle, HBA_MGMTINFO *pInfo) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetRNIDMgmtInfoFunc
             GetRNIDMgmtInfoFunc;

    DEBUG(2, "HBA_GetRNIDMgmtInfo", 0, 0, 0);

    CHECKLIBRARY();
    GetRNIDMgmtInfoFunc = lib_infop->functionTable.GetRNIDMgmtInfoHandler;
    if (GetRNIDMgmtInfoFunc != NULL) {
    status = (GetRNIDMgmtInfoFunc)(vendorHandle, pInfo);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendRNID (
    HBA_HANDLE      handle,
    HBA_WWN     wwn,
    HBA_WWNTYPE     wwntype,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendRNIDFunc SendRNIDFunc;

    DEBUG(2, "HBA_SendRNID for wwn: %s", WWN2STR1(&wwn), 0, 0);

    CHECKLIBRARY();
    SendRNIDFunc = lib_infop->functionTable.SendRNIDHandler;
    if (SendRNIDFunc != NULL) {
    status = ((SendRNIDFunc)(vendorHandle, wwn, wwntype,
                 pRspBuffer, pRspBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendRNIDV2(
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     destWWN,
    HBA_UINT32      destFCID,
    HBA_UINT32      NodeIdDataFormat,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendRNIDV2Func   registeredfunc;

    DEBUG(2, "HBA_SendRNIDV2, hbaPortWWN: %s", WWN2STR1(&hbaPortWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendRNIDV2Handler;
    if (registeredfunc != NULL) {
    status = (registeredfunc)
        (vendorHandle, hbaPortWWN, destWWN, destFCID, NodeIdDataFormat,
         pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

void
HBA_RefreshInformation (HBA_HANDLE handle) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBARefreshInformationFunc
            RefreshInformationFunc;

    DEBUG(2, "HBA_RefreshInformation", 0, 0, 0);

    status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
    if(status == HBA_STATUS_OK) {
    RefreshInformationFunc =
        lib_infop->functionTable.RefreshInformationHandler;
    if (RefreshInformationFunc != NULL) {
        ((RefreshInformationFunc)(vendorHandle));
    }
    RELEASE_MUTEX(&_hbaapi_LL_mutex);
    }
}

void
HBA_ResetStatistics (HBA_HANDLE handle, HBA_UINT32 portindex) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAResetStatisticsFunc
            ResetStatisticsFunc;

    DEBUG(2, "HBA_ResetStatistics", 0, 0, 0);

    status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
    if(status == HBA_STATUS_OK) {
    ResetStatisticsFunc = lib_infop->functionTable.ResetStatisticsHandler;
    if (ResetStatisticsFunc != NULL) {
        ((ResetStatisticsFunc)(vendorHandle, portindex));
    }
    RELEASE_MUTEX(&_hbaapi_LL_mutex);
    }
}

HBA_STATUS
HBA_GetFcpTargetMapping (HBA_HANDLE handle, PHBA_FCPTARGETMAPPING mapping) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetFcpTargetMappingFunc GetFcpTargetMappingFunc;

    DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);

    CHECKLIBRARY();
    GetFcpTargetMappingFunc =
    lib_infop->functionTable.GetFcpTargetMappingHandler;
    if (GetFcpTargetMappingFunc != NULL) {
    status = ((GetFcpTargetMappingFunc)(vendorHandle, mapping));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetFcpTargetMappingV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_FCPTARGETMAPPINGV2
                *pmapping)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetFcpTargetMappingV2Func
            registeredfunc;

    DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc =
    lib_infop->functionTable.GetFcpTargetMappingV2Handler;
    if (registeredfunc != NULL) {
    status = ((registeredfunc)(vendorHandle, hbaPortWWN, pmapping));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetFcpPersistentBinding (HBA_HANDLE handle, PHBA_FCPBINDING binding) {
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetFcpPersistentBindingFunc
            GetFcpPersistentBindingFunc;

    DEBUG(2, "HBA_GetFcpPersistentBinding", 0, 0, 0);

    CHECKLIBRARY();
    GetFcpPersistentBindingFunc =
    lib_infop->functionTable.GetFcpPersistentBindingHandler;
    if (GetFcpPersistentBindingFunc != NULL) {
    status = ((GetFcpPersistentBindingFunc)(vendorHandle, binding));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_ScsiInquiryV2 (
    HBA_HANDLE  handle,
    HBA_WWN hbaPortWWN,
    HBA_WWN discoveredPortWWN,
    HBA_UINT64  fcLUN,
    HBA_UINT8   CDB_Byte1,
    HBA_UINT8   CDB_Byte2,
    void    *pRspBuffer,
    HBA_UINT32  *pRspBufferSize,
    HBA_UINT8   *pScsiStatus,
    void    *pSenseBuffer,
    HBA_UINT32  *pSenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAScsiInquiryV2Func ScsiInquiryV2Func;

    DEBUG(2, "HBA_ScsiInquiryV2 to discoveredPortWWN: %s",
      WWN2STR1(&discoveredPortWWN), 0, 0);

    CHECKLIBRARY();
    ScsiInquiryV2Func =
    lib_infop->functionTable.ScsiInquiryV2Handler;
    if (ScsiInquiryV2Func != NULL) {
    status =((ScsiInquiryV2Func)(
        vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN, CDB_Byte1,
        CDB_Byte2, pRspBuffer, pRspBufferSize, pScsiStatus,
        pSenseBuffer, pSenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendScsiInquiry (
    HBA_HANDLE  handle,
    HBA_WWN PortWWN,
    HBA_UINT64  fcLUN,
    HBA_UINT8   EVPD,
    HBA_UINT32  PageCode,
    void    *pRspBuffer,
    HBA_UINT32  RspBufferSize,
    void    *pSenseBuffer,
    HBA_UINT32  SenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendScsiInquiryFunc SendScsiInquiryFunc;

    DEBUG(2, "HBA_SendScsiInquiry to PortWWN: %s", WWN2STR1(&PortWWN), 0, 0);

    CHECKLIBRARY();
    SendScsiInquiryFunc = lib_infop->functionTable.ScsiInquiryHandler;
    if (SendScsiInquiryFunc != NULL) {
    status =((SendScsiInquiryFunc)(
        vendorHandle, PortWWN, fcLUN, EVPD, PageCode, pRspBuffer,
        RspBufferSize, pSenseBuffer, SenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_ScsiReportLUNsV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     discoveredPortWWN,
    void        *pRespBuffer,
    HBA_UINT32      *pRespBufferSize,
    HBA_UINT8       *pScsiStatus,
    void        *pSenseBuffer,
    HBA_UINT32      *pSenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAScsiReportLUNsV2Func ScsiReportLUNsV2Func;

    DEBUG(2, "HBA_ScsiReportLUNsV2 to discoveredPortWWN: %s",
      WWN2STR1(&discoveredPortWWN), 0, 0);

    CHECKLIBRARY();
    ScsiReportLUNsV2Func = lib_infop->functionTable.ScsiReportLUNsV2Handler;
    if (ScsiReportLUNsV2Func != NULL) {
    status = ((ScsiReportLUNsV2Func)(
        vendorHandle, hbaPortWWN, discoveredPortWWN,
        pRespBuffer, pRespBufferSize,
        pScsiStatus,
        pSenseBuffer, pSenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendReportLUNs (
    HBA_HANDLE handle,
    HBA_WWN portWWN,
    void *pRspBuffer,
    HBA_UINT32 RspBufferSize,
    void *pSenseBuffer,
    HBA_UINT32 SenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendReportLUNsFunc SendReportLUNsFunc;

    DEBUG(2, "HBA_SendReportLUNs to PortWWN: %s", WWN2STR1(&portWWN), 0, 0);

    CHECKLIBRARY();
    SendReportLUNsFunc = lib_infop->functionTable.ReportLUNsHandler;
    if (SendReportLUNsFunc != NULL) {
    status = ((SendReportLUNsFunc)(
        vendorHandle, portWWN, pRspBuffer,
        RspBufferSize, pSenseBuffer, SenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_ScsiReadCapacityV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     discoveredPortWWN,
    HBA_UINT64      fcLUN,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize,
    HBA_UINT8       *pScsiStatus,
    void        *pSenseBuffer,
    HBA_UINT32      *SenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAScsiReadCapacityV2Func ScsiReadCapacityV2Func;

    DEBUG(2, "HBA_ScsiReadCapacityV2 to discoveredPortWWN: %s",
      WWN2STR1(&discoveredPortWWN), 0, 0);

    CHECKLIBRARY();
    ScsiReadCapacityV2Func =
    lib_infop->functionTable.ScsiReadCapacityV2Handler;
    if (ScsiReadCapacityV2Func != NULL) {
    status =((ScsiReadCapacityV2Func)(
        vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN,
        pRspBuffer, pRspBufferSize,
        pScsiStatus,
        pSenseBuffer, SenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendReadCapacity (
    HBA_HANDLE handle,
    HBA_WWN portWWN,
    HBA_UINT64 fcLUN,
    void *pRspBuffer,
    HBA_UINT32 RspBufferSize,
    void *pSenseBuffer,
    HBA_UINT32 SenseBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendReadCapacityFunc SendReadCapacityFunc;

    DEBUG(2, "HBA_SendReadCapacity to portWWN: %s", WWN2STR1(&portWWN), 0, 0);

    CHECKLIBRARY();
    SendReadCapacityFunc = lib_infop->functionTable.ReadCapacityHandler;
    if (SendReadCapacityFunc != NULL) {
    status =((SendReadCapacityFunc)
         (vendorHandle, portWWN, fcLUN, pRspBuffer,
          RspBufferSize, pSenseBuffer, SenseBufferSize));
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendRLS (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     destWWN,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendRLSFunc registeredfunc;

    DEBUG(2, "HBA_SendRLS to agent_wwn: %s:%d",
      WWN2STR1(&agent_wwn), agent_domain, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendRLSHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(
        vendorHandle, hbaPortWWN, destWWN, pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendRPL (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     agent_wwn,
    HBA_UINT32      agent_domain,
    HBA_UINT32      portindex,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendRPLFunc registeredfunc;

    DEBUG(2, "HBA_SendRPL to agent_wwn: %s:%d",
      WWN2STR1(&agent_wwn), agent_domain, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendRPLHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(
        vendorHandle, hbaPortWWN, agent_wwn, agent_domain, portindex,
        pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendRPS (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     agent_wwn,
    HBA_UINT32      agent_domain,
    HBA_WWN     object_wwn,
    HBA_UINT32      object_port_number,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendRPSFunc registeredfunc;

    DEBUG(2, "HBA_SendRPS  to agent_wwn: %s:%d",
      WWN2STR1(&agent_wwn), agent_domain, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendRPSHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(
        vendorHandle, hbaPortWWN, agent_wwn, agent_domain,
        object_wwn, object_port_number,
        pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendSRL (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_WWN     wwn,
    HBA_UINT32      domain,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendSRLFunc registeredfunc;

    DEBUG(2, "HBA_SendSRL to wwn:%s domain:%d", WWN2STR1(&wwn), domain, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendSRLHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(
        vendorHandle, hbaPortWWN, wwn, domain,
        pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SendLIRR (
    HBA_HANDLE      handle,
    HBA_WWN     sourceWWN,
    HBA_WWN     destWWN,
    HBA_UINT8       function,
    HBA_UINT8       type,
    void        *pRspBuffer,
    HBA_UINT32      *pRspBufferSize)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASendLIRRFunc registeredfunc;

    DEBUG(2, "HBA_SendLIRR destWWN:%s", WWN2STR1(&destWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SendLIRRHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(
        vendorHandle, sourceWWN, destWWN, function, type,
        pRspBuffer, pRspBufferSize);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetBindingCapability(
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_BIND_CAPABILITY *pcapability)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetBindingCapabilityFunc
            registeredfunc;

    DEBUG(2, "HBA_GetBindingCapability", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.GetBindingCapabilityHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetBindingSupport (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_BIND_CAPABILITY *pcapability)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetBindingSupportFunc
            registeredfunc;

    DEBUG(2, "HBA_GetBindingSupport", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.GetBindingSupportHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SetBindingSupport(
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_BIND_CAPABILITY capability)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASetBindingSupportFunc
            registeredfunc;

    DEBUG(2, "HBA_SetBindingSupport", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SetBindingSupportHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, capability);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_SetPersistentBindingV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    const HBA_FCPBINDING2
                *pbinding)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBASetPersistentBindingV2Func
            registeredfunc;

    DEBUG(2, "HBA_SetPersistentBindingV2 port: %s", WWN2STR1(&hbaPortWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.SetPersistentBindingV2Handler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetPersistentBindingV2 (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    HBA_FCPBINDING2 *pbinding)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetPersistentBindingV2Func
            registeredfunc;

    DEBUG(2, "HBA_GetPersistentBindingV2 port: %s", WWN2STR1(&hbaPortWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc = lib_infop->functionTable.GetPersistentBindingV2Handler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_RemovePersistentBinding (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN,
    const HBA_FCPBINDING2
            *pbinding)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBARemovePersistentBindingFunc
            registeredfunc;

    DEBUG(2, "HBA_RemovePersistentBinding", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc =
    lib_infop->functionTable.RemovePersistentBindingHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_RemoveAllPersistentBindings (
    HBA_HANDLE      handle,
    HBA_WWN     hbaPortWWN)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBARemoveAllPersistentBindingsFunc
            registeredfunc;

    DEBUG(2, "HBA_RemoveAllPersistentBindings", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc =
    lib_infop->functionTable.RemoveAllPersistentBindingsHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, hbaPortWWN);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetFC4Statistics (
    HBA_HANDLE      handle,
    HBA_WWN     portWWN,
    HBA_UINT8       FC4type,
    HBA_FC4STATISTICS   *pstatistics)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetFC4StatisticsFunc
            registeredfunc;

    DEBUG(2, "HBA_GetFC4Statistics port: %s", WWN2STR1(&portWWN), 0, 0);

    CHECKLIBRARY();
    registeredfunc =
    lib_infop->functionTable.GetFC4StatisticsHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)
        (vendorHandle, portWWN, FC4type, pstatistics);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_STATUS
HBA_GetFCPStatistics (
    HBA_HANDLE      handle,
    const HBA_SCSIID    *lunit,
    HBA_FC4STATISTICS   *pstatistics)
{
    HBA_STATUS      status;
    HBA_LIBRARY_INFO    *lib_infop;
    HBA_HANDLE      vendorHandle;
    HBAGetFCPStatisticsFunc
            registeredfunc;

    DEBUG(2, "HBA_GetFCPStatistics", 0, 0, 0);

    CHECKLIBRARY();
    registeredfunc =
    lib_infop->functionTable.GetFCPStatisticsHandler;
    if (registeredfunc != NULL) {
    status =(registeredfunc)(vendorHandle, lunit, pstatistics);
    } else {
    status = HBA_STATUS_ERROR_NOT_SUPPORTED;
    }
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
}

HBA_UINT32
HBA_GetVendorLibraryAttributes (
    HBA_UINT32 adapter_index,
    HBA_LIBRARYATTRIBUTES *attributes)
{
    HBA_ADAPTER_INFO    *adapt_infop;
    HBAGetVendorLibraryAttributesFunc
            registeredfunc;
    HBA_UINT32      ret = 0;

    DEBUG(2, "HBA_GetVendorLibraryAttributes adapterindex:%d",
      adapter_index, 0, 0);
    if(_hbaapi_librarylist == NULL) {
    DEBUG(1, "HBAAPI not loaded yet.", 0, 0, 0);
    return(0);
    }

    if (attributes == NULL) {
        return(HBA_STATUS_ERROR_ARG);
    }

    memset(attributes, 0, sizeof(HBA_LIBRARYATTRIBUTES));

    GRAB_MUTEX(&_hbaapi_LL_mutex);
    GRAB_MUTEX(&_hbaapi_AL_mutex);
    for(adapt_infop = _hbaapi_adapterlist;
    adapt_infop != NULL;
    adapt_infop = adapt_infop->next) {

    if(adapt_infop->index == adapter_index) {
        registeredfunc = adapt_infop->library->
        functionTable.GetVendorLibraryAttributesHandler;
        if(registeredfunc != NULL) {
        ret = (registeredfunc)(attributes);
        } else {
        /* Version 1 libary? */
        HBAGetVersionFunc   GetVersionFunc;
        GetVersionFunc = adapt_infop->library->
            functionTable.GetVersionHandler;
        if(GetVersionFunc != NULL) {
            ret = ((GetVersionFunc)());
        }
#ifdef NOTDEF
        else {
            /* This should not happen, dont think its going to */
        }
#endif
        }
        if (attributes->LibPath[0] == '\0') {
        if(strlen(adapt_infop->library->LibraryPath) < 256) {
            strcpy(attributes->LibPath,
               adapt_infop->library->LibraryPath);
        }
        }
        break;
    }
    }
    RELEASE_MUTEX(&_hbaapi_AL_mutex);
    RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, ret);
}