← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/System/Win32/DynamicLibrary.inc

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/System/Win32/DynamicLibrary.inc
 
1
//===- Win32/DynamicLibrary.cpp - Win32 DL Implementation -------*- C++ -*-===//
 
2
// 
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
// 
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file provides the Win32 specific implementation of DynamicLibrary.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "Win32.h"
 
15
 
 
16
#ifdef __MINGW32__
 
17
 #include <imagehlp.h>
 
18
#else
 
19
 #include <dbghelp.h>
 
20
#endif
 
21
 
 
22
#ifdef _MSC_VER
 
23
 #include <ntverp.h>
 
24
#endif
 
25
 
 
26
#ifdef __MINGW32__
 
27
 #if (HAVE_LIBIMAGEHLP != 1)
 
28
  #error "libimagehlp.a should be present"
 
29
 #endif
 
30
#else
 
31
 #pragma comment(lib, "dbghelp.lib")
 
32
#endif
 
33
 
 
34
namespace llvm {
 
35
using namespace sys;
 
36
 
 
37
//===----------------------------------------------------------------------===//
 
38
//=== WARNING: Implementation here must contain only Win32 specific code 
 
39
//===          and must not be UNIX code.
 
40
//===----------------------------------------------------------------------===//
 
41
 
 
42
static std::vector<HMODULE> OpenedHandles;
 
43
 
 
44
#ifdef _WIN64
 
45
  typedef DWORD64 ModuleBaseType;
 
46
#else
 
47
  typedef ULONG ModuleBaseType;
 
48
#endif
 
49
 
 
50
extern "C" {
 
51
// Use old callback if:
 
52
//  - Not using Visual Studio
 
53
//  - Visual Studio 2005 or earlier but only if we are not using the Windows SDK 
 
54
//    or Windows SDK version is older than 6.0
 
55
// Use new callback if:
 
56
//  - Newer Visual Studio (comes with newer SDK).
 
57
//  - Visual Studio 2005 with Windows SDK 6.0+
 
58
#if !defined(_MSC_VER) || _MSC_VER < 1500 && (!defined(VER_PRODUCTBUILD) || VER_PRODUCTBUILD < 6000)
 
59
  static BOOL CALLBACK ELM_Callback(PSTR  ModuleName,
 
60
                                    ModuleBaseType ModuleBase,
 
61
                                    ULONG ModuleSize,
 
62
                                    PVOID UserContext)
 
63
#else
 
64
  static BOOL CALLBACK ELM_Callback(PCSTR  ModuleName,
 
65
                                    ModuleBaseType ModuleBase,
 
66
                                    ULONG ModuleSize,
 
67
                                    PVOID UserContext)
 
68
#endif
 
69
  {
 
70
    // Ignore VC++ runtimes prior to 7.1.  Somehow some of them get loaded
 
71
    // into the process.
 
72
    if (stricmp(ModuleName, "msvci70") != 0 &&
 
73
        stricmp(ModuleName, "msvcirt") != 0 &&
 
74
        stricmp(ModuleName, "msvcp50") != 0 &&
 
75
        stricmp(ModuleName, "msvcp60") != 0 &&
 
76
        stricmp(ModuleName, "msvcp70") != 0 &&
 
77
        stricmp(ModuleName, "msvcr70") != 0 &&
 
78
#ifndef __MINGW32__
 
79
        // Mingw32 uses msvcrt.dll by default. Don't ignore it.
 
80
        // Otherwise, user should be aware, what he's doing :)
 
81
        stricmp(ModuleName, "msvcrt") != 0 &&
 
82
#endif
 
83
        stricmp(ModuleName, "msvcrt20") != 0 &&
 
84
        stricmp(ModuleName, "msvcrt40") != 0) {
 
85
      OpenedHandles.push_back((HMODULE)ModuleBase);
 
86
    }
 
87
    return TRUE;
 
88
  }
 
89
}
 
90
 
 
91
bool DynamicLibrary::LoadLibraryPermanently(const char *filename,
 
92
                                            std::string *ErrMsg) {                                            
 
93
  if (filename) {
 
94
    HMODULE a_handle = LoadLibrary(filename);
 
95
 
 
96
    if (a_handle == 0)
 
97
      return MakeErrMsg(ErrMsg, std::string(filename) + ": Can't open : ");
 
98
 
 
99
    OpenedHandles.push_back(a_handle);
 
100
  } else {
 
101
    // When no file is specified, enumerate all DLLs and EXEs in the
 
102
    // process.
 
103
    EnumerateLoadedModules(GetCurrentProcess(), ELM_Callback, 0);
 
104
  }
 
105
 
 
106
  // Because we don't remember the handle, we will never free it; hence,
 
107
  // it is loaded permanently.
 
108
  return false;
 
109
}
 
110
 
 
111
// Stack probing routines are in the support library (e.g. libgcc), but we don't
 
112
// have dynamic linking on windows. Provide a hook.
 
113
#if defined(__MINGW32__) || defined (_MSC_VER)
 
114
  #define EXPLICIT_SYMBOL(SYM)                    \
 
115
    if (!strcmp(symbolName, #SYM)) return (void*)&SYM
 
116
  #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO)        \
 
117
    if (!strcmp(symbolName, #SYMFROM)) return (void*)&SYMTO
 
118
  #define EXPLICIT_SYMBOL_DEF(SYM)                \
 
119
    extern "C" { extern void *SYM; }
 
120
 
 
121
  #if defined(__MINGW32__)
 
122
    EXPLICIT_SYMBOL_DEF(_alloca)
 
123
    EXPLICIT_SYMBOL_DEF(__main)
 
124
    EXPLICIT_SYMBOL_DEF(__ashldi3)
 
125
    EXPLICIT_SYMBOL_DEF(__ashrdi3)
 
126
    EXPLICIT_SYMBOL_DEF(__cmpdi2)
 
127
    EXPLICIT_SYMBOL_DEF(__divdi3)
 
128
    EXPLICIT_SYMBOL_DEF(__fixdfdi)
 
129
    EXPLICIT_SYMBOL_DEF(__fixsfdi)
 
130
    EXPLICIT_SYMBOL_DEF(__fixunsdfdi)
 
131
    EXPLICIT_SYMBOL_DEF(__fixunssfdi)
 
132
    EXPLICIT_SYMBOL_DEF(__floatdidf)
 
133
    EXPLICIT_SYMBOL_DEF(__floatdisf)
 
134
    EXPLICIT_SYMBOL_DEF(__lshrdi3)
 
135
    EXPLICIT_SYMBOL_DEF(__moddi3)
 
136
    EXPLICIT_SYMBOL_DEF(__udivdi3)
 
137
    EXPLICIT_SYMBOL_DEF(__umoddi3)
 
138
  #elif defined(_MSC_VER)
 
139
    EXPLICIT_SYMBOL_DEF(_alloca_probe)
 
140
  #endif
 
141
#endif
 
142
 
 
143
void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
 
144
  // First check symbols added via AddSymbol().
 
145
  if (ExplicitSymbols) {
 
146
    std::map<std::string, void *>::iterator I = 
 
147
      ExplicitSymbols->find(symbolName);
 
148
    std::map<std::string, void *>::iterator E = ExplicitSymbols->end();
 
149
    if (I != E)
 
150
      return I->second;
 
151
  }
 
152
 
 
153
  // Now search the libraries.
 
154
  for (std::vector<HMODULE>::iterator I = OpenedHandles.begin(),
 
155
       E = OpenedHandles.end(); I != E; ++I) {
 
156
    FARPROC ptr = GetProcAddress((HMODULE)*I, symbolName);
 
157
    if (ptr) {
 
158
      return (void *) ptr;
 
159
    }
 
160
  }
 
161
 
 
162
#if defined(__MINGW32__)
 
163
  {
 
164
    EXPLICIT_SYMBOL(_alloca);
 
165
    EXPLICIT_SYMBOL(__main);
 
166
    EXPLICIT_SYMBOL(__ashldi3);
 
167
    EXPLICIT_SYMBOL(__ashrdi3);
 
168
    EXPLICIT_SYMBOL(__cmpdi2);
 
169
    EXPLICIT_SYMBOL(__divdi3);
 
170
    EXPLICIT_SYMBOL(__fixdfdi);
 
171
    EXPLICIT_SYMBOL(__fixsfdi);
 
172
    EXPLICIT_SYMBOL(__fixunsdfdi);
 
173
    EXPLICIT_SYMBOL(__fixunssfdi);
 
174
    EXPLICIT_SYMBOL(__floatdidf);
 
175
    EXPLICIT_SYMBOL(__floatdisf);
 
176
    EXPLICIT_SYMBOL(__lshrdi3);
 
177
    EXPLICIT_SYMBOL(__moddi3);
 
178
    EXPLICIT_SYMBOL(__udivdi3);
 
179
    EXPLICIT_SYMBOL(__umoddi3);
 
180
 
 
181
    EXPLICIT_SYMBOL2(alloca, _alloca);
 
182
#undef EXPLICIT_SYMBOL
 
183
#undef EXPLICIT_SYMBOL2
 
184
#undef EXPLICIT_SYMBOL_DEF
 
185
  }
 
186
#elif defined(_MSC_VER)
 
187
  {
 
188
    EXPLICIT_SYMBOL2(alloca, _alloca_probe);
 
189
    EXPLICIT_SYMBOL2(_alloca, _alloca_probe);
 
190
#undef EXPLICIT_SYMBOL
 
191
#undef EXPLICIT_SYMBOL2
 
192
#undef EXPLICIT_SYMBOL_DEF
 
193
  }
 
194
#endif
 
195
 
 
196
  return 0;
 
197
}
 
198
 
 
199
}
 
200