libs/basekit/source/DynLib.c

   1 /*
   2 docLicense("BSD revised")
   3 docCredits("based on DllHandle.c, contributed by Daniel A. Koepke
   4         Reorg, Steve Dekorte, 2003-08-30
   5         Window fix, Chuck Adams, 2004-02-06:)
   6 */
   7
   8 #include "Base.h"
   9 #include "DynLib.h"
  10 #include "PortableStrlcpy.h"
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 #if defined(__WIN32__) || defined(WIN32) || defined(_WIN32) || defined(_MSC_VER)
  17 #include <windows.h>
  18
  19 #define RTLD_NOW    0    /* don't support link flags */
  20 #define RTLD_GLOBAL 0
  21
  22 static void *dlopen(const char *path, int mode)
  23 {
  24     void *result;
  25     result = (void *)LoadLibraryEx(path, NULL, 0);
  26     if (result)
  27         SetLastError(ERROR_SUCCESS);
  28
  29     return result;
  30 }
  31
  32 static int dlclose(void *handle)
  33 {
  34     return FreeLibrary((HANDLE)handle);
  35 }
  36
  37 static const char *dlerror(void)
  38 {
  39     // XXX this will leak the error string
  40
  41     LPSTR buf;
  42     DWORD err;
  43     err = GetLastError();
  44     if (err == ERROR_SUCCESS)
  45         return (char*)0;
  46
  47     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
  48                                   | FORMAT_MESSAGE_IGNORE_INSERTS
  49                                   | FORMAT_MESSAGE_FROM_SYSTEM,
  50                                   NULL, err,
  51                                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  52                                   (LPSTR)&buf, 0, NULL);
  53     return buf;
  54 }
  55
  56 static void *dlsym(void *handle, const char *symbol)
  57 {
  58     return (void*)GetProcAddress((HANDLE)handle, symbol);
  59 }
  60
  61
  62 #else
  63 #include <dlfcn.h>
  64 #endif
  65
  66 DynLib *DynLib_new(void)
  67 {
  68     DynLib *self = (DynLib *)io_calloc(1, sizeof(DynLib));
  69     DynLib_setPath_(self, "");
  70     return self;
  71 }
  72
  73 void DynLib_free(DynLib *self)
  74 {
  75     //DynLib_close(self);
  76     if (self->path) io_free(self->path);
  77     if (self->initFuncName) io_free(self->initFuncName);
  78     if (self->freeFuncName) io_free(self->freeFuncName);
  79     if (self->error) io_free(self->error);
  80     io_free(self);
  81 }
  82
  83 void DynLib_setPath_(DynLib *self, const char *path)
  84 {
  85     size_t len = strlen(path);
  86     char *ptr = (char*)io_realloc(self->path, len + 1);
  87     PortableStrlcpy(ptr, path, len + 1);
  88     self->path = ptr;
  89 }
  90
  91 char *DynLib_path(DynLib *self)
  92 {
  93     return self->path;
  94 }
  95
  96 void DynLib_setInitFuncName_(DynLib *self, const char *name)
  97 {
  98     size_t len = strlen(name);
  99     char* ptr = (char*)io_realloc(self->initFuncName, len + 1);
 100     PortableStrlcpy(ptr, name, len + 1);
 101     self->initFuncName = ptr;
 102 }
 103
 104 char *DynLib_initFuncName(DynLib *self)
 105 {
 106     return self->initFuncName;
 107 }
 108
 109 void DynLib_setInitArg_(DynLib *self, void *arg)
 110 {
 111     self->initArg = arg;
 112 }
 113
 114 void DynLib_setFreeFuncName_(DynLib *self, const char *name)
 115 {
 116     size_t len = strlen(name);
 117     char* ptr = (char*)io_realloc(self->freeFuncName, len + 1);
 118     PortableStrlcpy(ptr, name, len + 1);
 119     self->freeFuncName = ptr;
 120 }
 121
 122 char *DynLib_freeFuncName(DynLib *self)
 123 {
 124     return self->freeFuncName;
 125 }
 126
 127 void DynLib_setFreeArg_(DynLib *self, void *arg)
 128 {
 129     self->freeArg = arg;
 130 }
 131
 132 void DynLib_setError_(DynLib *self,const char *error)
 133 {
 134     if (error)
 135     {
 136                 self->error = strcpy((char *)io_realloc(self->error, strlen(error)+1), error);
 137     }
 138     else
 139     {
 140                 if (self->error) io_free(self->error);
 141                 self->error = NULL;
 142     }
 143 }
 144
 145 char *DynLib_error(DynLib *self)
 146 {
 147     return self->error;
 148 }
 149
 150 void DynLib_updateError(DynLib *self)
 151 {
 152     DynLib_setError_(self, dlerror());
 153 }
 154
 155 unsigned char DynLib_hasError(DynLib *self)
 156 {
 157     return self->error != NULL;
 158 }
 159
 160 void DynLib_open(DynLib *self)
 161 {
 162     self->handle = dlopen(self->path, RTLD_NOW | RTLD_GLOBAL); /* RTLD_LAZY); */
 163     //self->handle = dlopen(self->path, RTLD_NOW | RTLD_LAZY);
 164     DynLib_updateError(self);
 165
 166     if (DynLib_hasError(self))
 167     {
 168                 return;
 169     }
 170
 171     if (self->initFuncName)
 172     {
 173                 void *f = DynLib_pointerForSymbolName_(self, self->initFuncName);
 174
 175                 if (!f)
 176                 {
 177                         DynLib_setError_(self, "init function not found");
 178                         return;
 179                 }
 180
 181                 if (self->initArg)
 182                 {
 183                         //printf("DynLib: opening with 1 arg %p\n", self->initArg);
 184                         (*(DynLibOneArgFunction *)f)(self->initArg);
 185                 }
 186                 else
 187                 {
 188                         (*(DynLibNoArgFunction *)f)();
 189                 }
 190     }
 191 }
 192
 193 unsigned char DynLib_isOpen(DynLib *self)
 194 {
 195     return self->handle != NULL;
 196 }
 197
 198 void DynLib_close(DynLib *self)
 199 {
 200     if (self->freeFuncName)
 201     {
 202                 void *f = DynLib_pointerForSymbolName_(self, self->freeFuncName);
 203
 204                 if (!f)
 205                 {
 206                         DynLib_setError_(self, "io_free function not found");
 207                         return;
 208                 }
 209
 210                 if (self->freeArg)
 211                 {
 212                         (*(DynLibOneArgFunction *)f)(self->freeArg);
 213                 }
 214                 else
 215                 {
 216                         (*(DynLibNoArgFunction *)f)();
 217                 }
 218     }
 219
 220     if (self->handle)
 221     {
 222                 dlclose(self->handle);
 223     }
 224
 225     self->handle = NULL;
 226 }
 227
 228 void *DynLib_pointerForSymbolName_(DynLib *self, const char *symbolName)
 229 {
 230     DynLib_setError_(self, dlerror());
 231     return dlsym(self->handle, symbolName);
 232 }
 233