src/msw/dlmsw.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/dlmsw.cpp
   3 // Purpose:     Win32-specific part of wxDynamicLibrary and related classes
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     2005-01-10 (partly extracted from common/dynlib.cpp)
   7 // Copyright:   (c) 1998-2005 Vadim Zeitlin <vadim@wxwindows.org>
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 #include  "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22   #pragma hdrstop
  23 #endif
  24
  25 #if wxUSE_DYNLIB_CLASS
  26
  27 #include "wx/msw/private.h"
  28 #include "wx/msw/debughlp.h"
  29 #include "wx/filename.h"
  30
  31 // ----------------------------------------------------------------------------
  32 // private classes
  33 // ----------------------------------------------------------------------------
  34
  35 // wrap some functions from version.dll: load them dynamically and provide a
  36 // clean interface
  37 class wxVersionDLL
  38 {
  39 public:
  40     // load version.dll and bind to its functions
  41     wxVersionDLL();
  42
  43     // return the file version as string, e.g. "x.y.z.w"
  44     wxString GetFileVersion(const wxString& filename) const;
  45
  46 private:
  47     typedef DWORD (APIENTRY *GetFileVersionInfoSize_t)(PTSTR, PDWORD);
  48     typedef BOOL (APIENTRY *GetFileVersionInfo_t)(PTSTR, DWORD, DWORD, PVOID);
  49     typedef BOOL (APIENTRY *VerQueryValue_t)(const PVOID, PTSTR, PVOID *, PUINT);
  50
  51     #define DO_FOR_ALL_VER_FUNCS(what)                                        \
  52         what(GetFileVersionInfoSize);                                         \
  53         what(GetFileVersionInfo);                                             \
  54         what(VerQueryValue)
  55
  56     #define DECLARE_VER_FUNCTION(func) func ## _t m_pfn ## func
  57
  58     DO_FOR_ALL_VER_FUNCS(DECLARE_VER_FUNCTION);
  59
  60     #undef DECLARE_VER_FUNCTION
  61
  62
  63     wxDynamicLibrary m_dll;
  64
  65
  66     wxDECLARE_NO_COPY_CLASS(wxVersionDLL);
  67 };
  68
  69 // class used to create wxDynamicLibraryDetails objects
  70 class WXDLLIMPEXP_BASE wxDynamicLibraryDetailsCreator
  71 {
  72 public:
  73     // type of parameters being passed to EnumModulesProc
  74     struct EnumModulesProcParams
  75     {
  76         wxDynamicLibraryDetailsArray *dlls;
  77         wxVersionDLL *verDLL;
  78     };
  79
  80     // TODO: fix EnumerateLoadedModules() to use EnumerateLoadedModules64()
  81     #ifdef __WIN64__
  82         typedef DWORD64 DWORD_32_64;
  83     #else
  84         typedef DWORD DWORD_32_64;
  85     #endif
  86
  87     static BOOL CALLBACK
  88     EnumModulesProc(PCSTR name, DWORD_32_64 base, ULONG size, void *data);
  89 };
  90
  91 // ============================================================================
  92 // wxVersionDLL implementation
  93 // ============================================================================
  94
  95 // ----------------------------------------------------------------------------
  96 // loading
  97 // ----------------------------------------------------------------------------
  98
  99 wxVersionDLL::wxVersionDLL()
 100 {
 101     // don't give errors if DLL can't be loaded or used, we're prepared to
 102     // handle it
 103     wxLogNull noLog;
 104
 105     if ( m_dll.Load(wxT("version.dll"), wxDL_VERBATIM) )
 106     {
 107         // the functions we load have either 'A' or 'W' suffix depending on
 108         // whether we're in ANSI or Unicode build
 109         #ifdef UNICODE
 110             #define SUFFIX L"W"
 111         #else // ANSI
 112             #define SUFFIX "A"
 113         #endif // UNICODE/ANSI
 114
 115         #define LOAD_VER_FUNCTION(name)                                       \
 116             m_pfn ## name = (name ## _t)m_dll.GetSymbol(wxT(#name SUFFIX));    \
 117         if ( !m_pfn ## name )                                                 \
 118         {                                                                     \
 119             m_dll.Unload();                                                   \
 120             return;                                                           \
 121         }
 122
 123         DO_FOR_ALL_VER_FUNCS(LOAD_VER_FUNCTION);
 124
 125         #undef LOAD_VER_FUNCTION
 126     }
 127 }
 128
 129 // ----------------------------------------------------------------------------
 130 // wxVersionDLL operations
 131 // ----------------------------------------------------------------------------
 132
 133 wxString wxVersionDLL::GetFileVersion(const wxString& filename) const
 134 {
 135     wxString ver;
 136     if ( m_dll.IsLoaded() )
 137     {
 138         wxChar *pc = const_cast<wxChar *>((const wxChar*) filename.t_str());
 139
 140         DWORD dummy;
 141         DWORD sizeVerInfo = m_pfnGetFileVersionInfoSize(pc, &dummy);
 142         if ( sizeVerInfo )
 143         {
 144             wxCharBuffer buf(sizeVerInfo);
 145             if ( m_pfnGetFileVersionInfo(pc, 0, sizeVerInfo, buf.data()) )
 146             {
 147                 void *pVer;
 148                 UINT sizeInfo;
 149                 if ( m_pfnVerQueryValue(buf.data(),
 150                                         const_cast<wxChar *>(wxT("\\")),
 151                                         &pVer,
 152                                         &sizeInfo) )
 153                 {
 154                     VS_FIXEDFILEINFO *info = (VS_FIXEDFILEINFO *)pVer;
 155                     ver.Printf(wxT("%d.%d.%d.%d"),
 156                                HIWORD(info->dwFileVersionMS),
 157                                LOWORD(info->dwFileVersionMS),
 158                                HIWORD(info->dwFileVersionLS),
 159                                LOWORD(info->dwFileVersionLS));
 160                 }
 161             }
 162         }
 163     }
 164     //else: we failed to load DLL, can't retrieve version info
 165
 166     return ver;
 167 }
 168
 169 // ============================================================================
 170 // wxDynamicLibraryDetailsCreator implementation
 171 // ============================================================================
 172
 173 /* static */
 174 BOOL CALLBACK
 175 wxDynamicLibraryDetailsCreator::EnumModulesProc(PCSTR name,
 176                                                 DWORD_32_64 base,
 177                                                 ULONG size,
 178                                                 void *data)
 179 {
 180     EnumModulesProcParams *params = (EnumModulesProcParams *)data;
 181
 182     wxDynamicLibraryDetails *details = new wxDynamicLibraryDetails;
 183
 184     // fill in simple properties
 185     details->m_name = name;
 186     details->m_address = wxUIntToPtr(base);
 187     details->m_length = size;
 188
 189     // to get the version, we first need the full path
 190     const HMODULE hmod = wxDynamicLibrary::MSWGetModuleHandle
 191                          (
 192                             details->m_name,
 193                             details->m_address
 194                          );
 195     if ( hmod )
 196     {
 197         wxString fullname = wxGetFullModuleName(hmod);
 198         if ( !fullname.empty() )
 199         {
 200             details->m_path = fullname;
 201             details->m_version = params->verDLL->GetFileVersion(fullname);
 202         }
 203     }
 204
 205     params->dlls->Add(details);
 206
 207     // continue enumeration (returning FALSE would have stopped it)
 208     return TRUE;
 209 }
 210
 211 // ============================================================================
 212 // wxDynamicLibrary implementation
 213 // ============================================================================
 214
 215 // ----------------------------------------------------------------------------
 216 // misc functions
 217 // ----------------------------------------------------------------------------
 218
 219 wxDllType wxDynamicLibrary::GetProgramHandle()
 220 {
 221     return (wxDllType)::GetModuleHandle(NULL);
 222 }
 223
 224 // ----------------------------------------------------------------------------
 225 // loading/unloading DLLs
 226 // ----------------------------------------------------------------------------
 227
 228 #ifndef MAX_PATH
 229     #define MAX_PATH 260        // from VC++ headers
 230 #endif
 231
 232 /* static */
 233 wxDllType
 234 wxDynamicLibrary::RawLoad(const wxString& libname, int flags)
 235 {
 236     if (flags & wxDL_GET_LOADED)
 237         return ::GetModuleHandle(libname.t_str());
 238
 239     // Explicitly look in the same path as where the main wx HINSTANCE module
 240     // is located (usually the executable or the DLL that uses wx).  Normally
 241     // this is automatically part of the default search path but in some cases
 242     // it may not be, such as when the wxPython extension modules need to load
 243     // a DLL, but the intperpreter executable is located elsewhere.  Doing
 244     // this allows us to always be able to dynamically load a DLL that is
 245     // located at the same place as the wx modules.
 246     wxString modpath, path;
 247     ::GetModuleFileName(wxGetInstance(),
 248                         wxStringBuffer(modpath, MAX_PATH+1),
 249                         MAX_PATH);
 250
 251     wxFileName::SplitPath(modpath, &path, NULL, NULL);
 252
 253     typedef BOOL (WINAPI *SetDllDirectory_t)(LPCTSTR lpPathName);
 254
 255     static SetDllDirectory_t s_pfnSetDllDirectory = (SetDllDirectory_t) -1;
 256
 257     if ( s_pfnSetDllDirectory == (SetDllDirectory_t) -1 )
 258     {
 259         /*
 260         Should wxLoadedDLL ever not be used here (or rather, the
 261         wxDL_GET_LOADED flag isn't used), infinite recursion will take
 262         place (unless s_pfnSetDllDirectory is set to NULL here right
 263         before loading the DLL).
 264         */
 265         wxLoadedDLL dllKernel("kernel32.dll");
 266
 267         wxDL_INIT_FUNC_AW(s_pfn, SetDllDirectory, dllKernel);
 268     }
 269
 270     if (s_pfnSetDllDirectory)
 271     {
 272         s_pfnSetDllDirectory(path.t_str());
 273     }
 274
 275     wxDllType handle = ::LoadLibrary(libname.t_str());
 276
 277     // reset the search path
 278     if (s_pfnSetDllDirectory)
 279     {
 280         s_pfnSetDllDirectory(NULL);
 281     }
 282
 283     return handle;
 284 }
 285
 286 /* static */
 287 void wxDynamicLibrary::Unload(wxDllType handle)
 288 {
 289     ::FreeLibrary(handle);
 290 }
 291
 292 /* static */
 293 void *wxDynamicLibrary::RawGetSymbol(wxDllType handle, const wxString& name)
 294 {
 295     return (void *)::GetProcAddress(handle,
 296 #ifdef __WXWINCE__
 297                                             name.c_str()
 298 #else
 299                                             name.ToAscii()
 300 #endif // __WXWINCE__
 301                                    );
 302 }
 303
 304 // ----------------------------------------------------------------------------
 305 // enumerating loaded DLLs
 306 // ----------------------------------------------------------------------------
 307
 308 /* static */
 309 wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
 310 {
 311     wxDynamicLibraryDetailsArray dlls;
 312
 313 #if wxUSE_DBGHELP
 314     if ( wxDbgHelpDLL::Init() )
 315     {
 316         // prepare to use functions for version info extraction
 317         wxVersionDLL verDLL;
 318
 319         wxDynamicLibraryDetailsCreator::EnumModulesProcParams params;
 320         params.dlls = &dlls;
 321         params.verDLL = &verDLL;
 322
 323         // Note that the cast of EnumModulesProc is needed because the type of
 324         // PENUMLOADED_MODULES_CALLBACK changed: in old SDK versions its first
 325         // argument was non-const PSTR while now it's PCSTR. By explicitly
 326         // casting to whatever the currently used headers require we ensure
 327         // that the code compilers in any case.
 328         if ( !wxDbgHelpDLL::EnumerateLoadedModules
 329                             (
 330                                 ::GetCurrentProcess(),
 331                                 (PENUMLOADED_MODULES_CALLBACK)
 332                                 wxDynamicLibraryDetailsCreator::EnumModulesProc,
 333                                 &params
 334                             ) )
 335         {
 336             wxLogLastError(wxT("EnumerateLoadedModules"));
 337         }
 338     }
 339 #endif // wxUSE_DBGHELP
 340
 341     return dlls;
 342 }
 343
 344 /* static */
 345 WXHMODULE wxDynamicLibrary::MSWGetModuleHandle(const wxString& name, void *addr)
 346 {
 347     // we want to use GetModuleHandleEx() instead of usual GetModuleHandle()
 348     // because the former works correctly for comctl32.dll while the latter
 349     // returns NULL when comctl32.dll version 6 is used under XP (note that
 350     // GetModuleHandleEx() is only available under XP and later, coincidence?)
 351
 352     // check if we can use GetModuleHandleEx
 353     typedef BOOL (WINAPI *GetModuleHandleEx_t)(DWORD, LPCTSTR, HMODULE *);
 354
 355     static const GetModuleHandleEx_t INVALID_FUNC_PTR = (GetModuleHandleEx_t)-1;
 356
 357     static GetModuleHandleEx_t s_pfnGetModuleHandleEx = INVALID_FUNC_PTR;
 358     if ( s_pfnGetModuleHandleEx == INVALID_FUNC_PTR )
 359     {
 360         wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);
 361         s_pfnGetModuleHandleEx =
 362             (GetModuleHandleEx_t)dll.GetSymbolAorW(wxT("GetModuleHandleEx"));
 363
 364         // dll object can be destroyed, kernel32.dll won't be unloaded anyhow
 365     }
 366
 367     // get module handle from its address
 368     if ( s_pfnGetModuleHandleEx )
 369     {
 370         // flags are GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
 371         //           GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 372         HMODULE hmod;
 373         if ( s_pfnGetModuleHandleEx(6, (LPCTSTR)addr, &hmod) && hmod )
 374             return hmod;
 375     }
 376
 377     return ::GetModuleHandle(name.t_str());
 378 }
 379
 380 #endif // wxUSE_DYNLIB_CLASS
 381