2 /* Support for dynamic loading of extension modules */
14 const struct filedescr _PyImport_DynLoadFiletab
[] = {
16 {"_d.pyd", "rb", C_EXTENSION
},
18 {".pyd", "rb", C_EXTENSION
},
24 /* Case insensitive string compare, to avoid any dependencies on particular
25 C RTL implementations */
27 static int strcasecmp (char *string1
, char *string2
)
32 first
= tolower(*string1
);
33 second
= tolower(*string2
);
36 } while (first
&& first
== second
);
38 return (first
- second
);
42 /* Function to return the name of the "python" DLL that the supplied module
43 directly imports. Looks through the list of imported modules and
44 returns the first entry that starts with "python" (case sensitive) and
45 is followed by nothing but numbers until the separator (period).
47 Returns a pointer to the import name, or NULL if no matching name was
50 This function parses through the PE header for the module as loaded in
51 memory by the system loader. The PE header is accessed as documented by
52 Microsoft in the MSDN PE and COFF specification (2/99), and handles
53 both PE32 and PE32+. It only worries about the direct import table and
54 not the delay load import table since it's unlikely an extension is
55 going to be delay loading Python (after all, it's already loaded).
57 If any magic values are not found (e.g., the PE header or optional
58 header magic), then this function simply returns NULL. */
60 #define DWORD_AT(mem) (*(DWORD *)(mem))
61 #define WORD_AT(mem) (*(WORD *)(mem))
63 static char *GetPythonImport (HINSTANCE hModule
)
65 unsigned char *dllbase
, *import_data
, *import_name
;
66 DWORD pe_offset
, opt_offset
;
68 int num_dict_off
, import_off
;
70 /* Safety check input */
71 if (hModule
== NULL
) {
75 /* Module instance is also the base load address. First portion of
76 memory is the MS-DOS loader, which holds the offset to the PE
77 header (from the load base) at 0x3C */
78 dllbase
= (unsigned char *)hModule
;
79 pe_offset
= DWORD_AT(dllbase
+ 0x3C);
81 /* The PE signature must be "PE\0\0" */
82 if (memcmp(dllbase
+pe_offset
,"PE\0\0",4)) {
86 /* Following the PE signature is the standard COFF header (20
87 bytes) and then the optional header. The optional header starts
88 with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+
89 uses 64-bits for some fields). It might also be 0x107 for a ROM
90 image, but we don't process that here.
92 The optional header ends with a data dictionary that directly
93 points to certain types of data, among them the import entries
94 (in the second table entry). Based on the header type, we
95 determine offsets for the data dictionary count and the entry
96 within the dictionary pointing to the imports. */
98 opt_offset
= pe_offset
+ 4 + 20;
99 opt_magic
= WORD_AT(dllbase
+opt_offset
);
100 if (opt_magic
== 0x10B) {
104 } else if (opt_magic
== 0x20B) {
113 /* Now if an import table exists, offset to it and walk the list of
114 imports. The import table is an array (ending when an entry has
115 empty values) of structures (20 bytes each), which contains (at
116 offset 12) a relative address (to the module base) at which a
117 string constant holding the import name is located. */
119 if (DWORD_AT(dllbase
+ opt_offset
+ num_dict_off
) >= 2) {
120 /* We have at least 2 tables - the import table is the second
121 one. But still it may be that the table size is zero */
122 if (0 == DWORD_AT(dllbase
+ opt_offset
+ import_off
+ sizeof(DWORD
)))
124 import_data
= dllbase
+ DWORD_AT(dllbase
+
127 while (DWORD_AT(import_data
)) {
128 import_name
= dllbase
+ DWORD_AT(import_data
+12);
129 if (strlen(import_name
) >= 6 &&
130 !strncmp(import_name
,"python",6)) {
133 /* Ensure python prefix is followed only
134 by numbers to the end of the basename */
135 pch
= import_name
+ 6;
137 while (*pch
&& pch
[0] != '_' && pch
[1] != 'd' && pch
[2] != '.') {
139 while (*pch
&& *pch
!= '.') {
141 if (*pch
>= '0' && *pch
<= '9') {
150 /* Found it - return the name */
162 dl_funcptr
_PyImport_GetDynLoadFunc(const char *fqname
, const char *shortname
,
163 const char *pathname
, FILE *fp
)
166 char funcname
[258], *import_python
;
168 PyOS_snprintf(funcname
, sizeof(funcname
), "init%.200s", shortname
);
171 HINSTANCE hDLL
= NULL
;
174 unsigned int old_mode
;
175 /* We use LoadLibraryEx so Windows looks for dependent DLLs
176 in directory of pathname first. However, Windows95
177 can sometimes not work correctly unless the absolute
178 path is used. If GetFullPathName() fails, the LoadLibrary
179 will certainly fail too, so use its error code */
181 /* Don't display a message box when Python can't load a DLL */
182 old_mode
= SetErrorMode(SEM_FAILCRITICALERRORS
);
184 if (GetFullPathName(pathname
,
188 /* XXX This call doesn't exist in Windows CE */
189 hDLL
= LoadLibraryEx(pathname
, NULL
,
190 LOAD_WITH_ALTERED_SEARCH_PATH
);
192 /* restore old error mode settings */
193 SetErrorMode(old_mode
);
197 unsigned int errorCode
;
199 /* Get an error string from Win32 error code */
200 char theInfo
[256]; /* Pointer to error text
202 int theLength
; /* Length of error text */
204 errorCode
= GetLastError();
206 theLength
= FormatMessage(
207 FORMAT_MESSAGE_FROM_SYSTEM
|
208 FORMAT_MESSAGE_IGNORE_INSERTS
, /* flags */
209 NULL
, /* message source */
210 errorCode
, /* the message (error) ID */
211 0, /* default language environment */
212 (LPTSTR
) theInfo
, /* the buffer */
213 sizeof(theInfo
), /* the buffer size */
214 NULL
); /* no additional format args. */
216 /* Problem: could not get the error message.
217 This should not happen if called correctly. */
218 if (theLength
== 0) {
219 PyOS_snprintf(errBuf
, sizeof(errBuf
),
220 "DLL load failed with error code %d",
224 /* For some reason a \r\n
225 is appended to the text */
226 if (theLength
>= 2 &&
227 theInfo
[theLength
-2] == '\r' &&
228 theInfo
[theLength
-1] == '\n') {
230 theInfo
[theLength
] = '\0';
232 strcpy(errBuf
, "DLL load failed: ");
233 len
= strlen(errBuf
);
234 strncpy(errBuf
+len
, theInfo
,
236 errBuf
[sizeof(errBuf
)-1] = '\0';
238 PyErr_SetString(PyExc_ImportError
, errBuf
);
244 PyOS_snprintf(buffer
, sizeof(buffer
), "python%d%d_d.dll",
246 PyOS_snprintf(buffer
, sizeof(buffer
), "python%d%d.dll",
248 PY_MAJOR_VERSION
,PY_MINOR_VERSION
);
249 import_python
= GetPythonImport(hDLL
);
252 strcasecmp(buffer
,import_python
)) {
253 PyOS_snprintf(buffer
, sizeof(buffer
),
254 "Module use of %.150s conflicts "
255 "with this version of Python.",
257 PyErr_SetString(PyExc_ImportError
,buffer
);
262 p
= GetProcAddress(hDLL
, funcname
);