2 /* Support for dynamic loading of extension modules */
13 const struct filedescr _PyImport_DynLoadFiletab
[] = {
15 {"_d.pyd", "rb", C_EXTENSION
},
16 /* Temporarily disable .dll, to avoid conflicts between sqlite3.dll
17 and the sqlite3 package. If this needs to be reverted for 2.5,
18 some other solution for the naming conflict must be found.
19 {"_d.dll", "rb", C_EXTENSION},
22 {".pyd", "rb", C_EXTENSION
},
24 {".dll", "rb", C_EXTENSION},
31 /* Case insensitive string compare, to avoid any dependencies on particular
32 C RTL implementations */
34 static int strcasecmp (char *string1
, char *string2
)
39 first
= tolower(*string1
);
40 second
= tolower(*string2
);
43 } while (first
&& first
== second
);
45 return (first
- second
);
49 /* Function to return the name of the "python" DLL that the supplied module
50 directly imports. Looks through the list of imported modules and
51 returns the first entry that starts with "python" (case sensitive) and
52 is followed by nothing but numbers until the separator (period).
54 Returns a pointer to the import name, or NULL if no matching name was
57 This function parses through the PE header for the module as loaded in
58 memory by the system loader. The PE header is accessed as documented by
59 Microsoft in the MSDN PE and COFF specification (2/99), and handles
60 both PE32 and PE32+. It only worries about the direct import table and
61 not the delay load import table since it's unlikely an extension is
62 going to be delay loading Python (after all, it's already loaded).
64 If any magic values are not found (e.g., the PE header or optional
65 header magic), then this function simply returns NULL. */
67 #define DWORD_AT(mem) (*(DWORD *)(mem))
68 #define WORD_AT(mem) (*(WORD *)(mem))
70 static char *GetPythonImport (HINSTANCE hModule
)
72 unsigned char *dllbase
, *import_data
, *import_name
;
73 DWORD pe_offset
, opt_offset
;
75 int num_dict_off
, import_off
;
77 /* Safety check input */
78 if (hModule
== NULL
) {
82 /* Module instance is also the base load address. First portion of
83 memory is the MS-DOS loader, which holds the offset to the PE
84 header (from the load base) at 0x3C */
85 dllbase
= (unsigned char *)hModule
;
86 pe_offset
= DWORD_AT(dllbase
+ 0x3C);
88 /* The PE signature must be "PE\0\0" */
89 if (memcmp(dllbase
+pe_offset
,"PE\0\0",4)) {
93 /* Following the PE signature is the standard COFF header (20
94 bytes) and then the optional header. The optional header starts
95 with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+
96 uses 64-bits for some fields). It might also be 0x107 for a ROM
97 image, but we don't process that here.
99 The optional header ends with a data dictionary that directly
100 points to certain types of data, among them the import entries
101 (in the second table entry). Based on the header type, we
102 determine offsets for the data dictionary count and the entry
103 within the dictionary pointing to the imports. */
105 opt_offset
= pe_offset
+ 4 + 20;
106 opt_magic
= WORD_AT(dllbase
+opt_offset
);
107 if (opt_magic
== 0x10B) {
111 } else if (opt_magic
== 0x20B) {
120 /* Now if an import table exists, offset to it and walk the list of
121 imports. The import table is an array (ending when an entry has
122 empty values) of structures (20 bytes each), which contains (at
123 offset 12) a relative address (to the module base) at which a
124 string constant holding the import name is located. */
126 if (DWORD_AT(dllbase
+ opt_offset
+ num_dict_off
) >= 2) {
127 /* We have at least 2 tables - the import table is the second
128 one. But still it may be that the table size is zero */
129 if (0 == DWORD_AT(dllbase
+ opt_offset
+ import_off
+ sizeof(DWORD
)))
131 import_data
= dllbase
+ DWORD_AT(dllbase
+
134 while (DWORD_AT(import_data
)) {
135 import_name
= dllbase
+ DWORD_AT(import_data
+12);
136 if (strlen(import_name
) >= 6 &&
137 !strncmp(import_name
,"python",6)) {
140 /* Ensure python prefix is followed only
141 by numbers to the end of the basename */
142 pch
= import_name
+ 6;
144 while (*pch
&& pch
[0] != '_' && pch
[1] != 'd' && pch
[2] != '.') {
146 while (*pch
&& *pch
!= '.') {
148 if (*pch
>= '0' && *pch
<= '9') {
157 /* Found it - return the name */
169 dl_funcptr
_PyImport_GetDynLoadFunc(const char *fqname
, const char *shortname
,
170 const char *pathname
, FILE *fp
)
173 char funcname
[258], *import_python
;
175 PyOS_snprintf(funcname
, sizeof(funcname
), "init%.200s", shortname
);
178 HINSTANCE hDLL
= NULL
;
181 /* We use LoadLibraryEx so Windows looks for dependent DLLs
182 in directory of pathname first. However, Windows95
183 can sometimes not work correctly unless the absolute
184 path is used. If GetFullPathName() fails, the LoadLibrary
185 will certainly fail too, so use its error code */
186 if (GetFullPathName(pathname
,
190 /* XXX This call doesn't exist in Windows CE */
191 hDLL
= LoadLibraryEx(pathname
, NULL
,
192 LOAD_WITH_ALTERED_SEARCH_PATH
);
195 unsigned int errorCode
;
197 /* Get an error string from Win32 error code */
198 char theInfo
[256]; /* Pointer to error text
200 int theLength
; /* Length of error text */
202 errorCode
= GetLastError();
204 theLength
= FormatMessage(
205 FORMAT_MESSAGE_FROM_SYSTEM
, /* flags */
206 NULL
, /* message source */
207 errorCode
, /* the message (error) ID */
208 0, /* default language environment */
209 (LPTSTR
) theInfo
, /* the buffer */
210 sizeof(theInfo
), /* the buffer size */
211 NULL
); /* no additional format args. */
213 /* Problem: could not get the error message.
214 This should not happen if called correctly. */
215 if (theLength
== 0) {
216 PyOS_snprintf(errBuf
, sizeof(errBuf
),
217 "DLL load failed with error code %d",
221 /* For some reason a \r\n
222 is appended to the text */
223 if (theLength
>= 2 &&
224 theInfo
[theLength
-2] == '\r' &&
225 theInfo
[theLength
-1] == '\n') {
227 theInfo
[theLength
] = '\0';
229 strcpy(errBuf
, "DLL load failed: ");
230 len
= strlen(errBuf
);
231 strncpy(errBuf
+len
, theInfo
,
233 errBuf
[sizeof(errBuf
)-1] = '\0';
235 PyErr_SetString(PyExc_ImportError
, errBuf
);
241 PyOS_snprintf(buffer
, sizeof(buffer
), "python%d%d_d.dll",
243 PyOS_snprintf(buffer
, sizeof(buffer
), "python%d%d.dll",
245 PY_MAJOR_VERSION
,PY_MINOR_VERSION
);
246 import_python
= GetPythonImport(hDLL
);
249 strcasecmp(buffer
,import_python
)) {
250 PyOS_snprintf(buffer
, sizeof(buffer
),
251 "Module use of %.150s conflicts "
252 "with this version of Python.",
254 PyErr_SetString(PyExc_ImportError
,buffer
);
259 p
= GetProcAddress(hDLL
, funcname
);