1 
2 /* Support for dynamic loading of extension modules */
3 
4 #include "Python.h"
5 
6 #ifdef HAVE_DIRECT_H
7 #include <direct.h>
8 #endif
9 #include <ctype.h>
10 
11 #include "importdl.h"
12 #include <windows.h>
13 
14 // "activation context" magic - see dl_nt.c...
15 extern ULONG_PTR _Py_ActivateActCtx();
16 void _Py_DeactivateActCtx(ULONG_PTR cookie);
17 
18 const struct filedescr _PyImport_DynLoadFiletab[] = {
19 #ifdef _DEBUG
20     {"_d.pyd", "rb", C_EXTENSION},
21 #else
22     {".pyd", "rb", C_EXTENSION},
23 #endif
24     {0, 0}
25 };
26 
27 
28 /* Case insensitive string compare, to avoid any dependencies on particular
29    C RTL implementations */
30 
31 static int strcasecmp (char *string1, char *string2)
32 {
33     int first, second;
34 
35     do {
36         first  = tolower(*string1);
37         second = tolower(*string2);
38         string1++;
39         string2++;
40     } while (first && first == second);
41 
42     return (first - second);
43 }
44 
45 
46 /* Function to return the name of the "python" DLL that the supplied module
47    directly imports.  Looks through the list of imported modules and
48    returns the first entry that starts with "python" (case sensitive) and
49    is followed by nothing but numbers until the separator (period).
50 
51    Returns a pointer to the import name, or NULL if no matching name was
52    located.
53 
54    This function parses through the PE header for the module as loaded in
55    memory by the system loader.  The PE header is accessed as documented by
56    Microsoft in the MSDN PE and COFF specification (2/99), and handles
57    both PE32 and PE32+.  It only worries about the direct import table and
58    not the delay load import table since it's unlikely an extension is
59    going to be delay loading Python (after all, it's already loaded).
60 
61    If any magic values are not found (e.g., the PE header or optional
62    header magic), then this function simply returns NULL. */
63 
64 #define DWORD_AT(mem) (*(DWORD *)(mem))
65 #define WORD_AT(mem)  (*(WORD *)(mem))
66 
67 static char *GetPythonImport (HINSTANCE hModule)
68 {
69     unsigned char *dllbase, *import_data, *import_name;
70     DWORD pe_offset, opt_offset;
71     WORD opt_magic;
72     int num_dict_off, import_off;
73 
74     /* Safety check input */
75     if (hModule == NULL) {
76         return NULL;
77     }
78 
79     /* Module instance is also the base load address.  First portion of
80        memory is the MS-DOS loader, which holds the offset to the PE
81        header (from the load base) at 0x3C */
82     dllbase = (unsigned char *)hModule;
83     pe_offset = DWORD_AT(dllbase + 0x3C);
84 
85     /* The PE signature must be "PE\0\0" */
86     if (memcmp(dllbase+pe_offset,"PE\0\0",4)) {
87         return NULL;
88     }
89 
90     /* Following the PE signature is the standard COFF header (20
91        bytes) and then the optional header.  The optional header starts
92        with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+
93        uses 64-bits for some fields).  It might also be 0x107 for a ROM
94        image, but we don't process that here.
95 
96        The optional header ends with a data dictionary that directly
97        points to certain types of data, among them the import entries
98        (in the second table entry). Based on the header type, we
99        determine offsets for the data dictionary count and the entry
100        within the dictionary pointing to the imports. */
101 
102     opt_offset = pe_offset + 4 + 20;
103     opt_magic = WORD_AT(dllbase+opt_offset);
104     if (opt_magic == 0x10B) {
105         /* PE32 */
106         num_dict_off = 92;
107         import_off   = 104;
108     } else if (opt_magic == 0x20B) {
109         /* PE32+ */
110         num_dict_off = 108;
111         import_off   = 120;
112     } else {
113         /* Unsupported */
114         return NULL;
115     }
116 
117     /* Now if an import table exists, offset to it and walk the list of
118        imports.  The import table is an array (ending when an entry has
119        empty values) of structures (20 bytes each), which contains (at
120        offset 12) a relative address (to the module base) at which a
121        string constant holding the import name is located. */
122 
123     if (DWORD_AT(dllbase + opt_offset + num_dict_off) >= 2) {
124         /* We have at least 2 tables - the import table is the second
125            one.  But still it may be that the table size is zero */
126         if (0 == DWORD_AT(dllbase + opt_offset + import_off + sizeof(DWORD)))
127             return NULL;
128         import_data = dllbase + DWORD_AT(dllbase +
129                                          opt_offset +
130                                          import_off);
131         while (DWORD_AT(import_data)) {
132             import_name = dllbase + DWORD_AT(import_data+12);
133             if (strlen(import_name) >= 6 &&
134                 !strncmp(import_name,"python",6)) {
135                 char *pch;
136 
137                 /* Ensure python prefix is followed only
138                    by numbers to the end of the basename */
139                 pch = import_name + 6;
140 #ifdef _DEBUG
141                 while (*pch && pch[0] != '_' && pch[1] != 'd' && pch[2] != '.') {
142 #else
143                 while (*pch && *pch != '.') {
144 #endif
145                     if (*pch >= '0' && *pch <= '9') {
146                         pch++;
147                     } else {
148                         pch = NULL;
149                         break;
150                     }
151                 }
152 
153                 if (pch) {
154                     /* Found it - return the name */
155                     return import_name;
156                 }
157             }
158             import_data += 20;
159         }
160     }
161 
162     return NULL;
163 }
164 
165 
166 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
167                                     const char *pathname, FILE *fp)
168 {
169     dl_funcptr p;
170     char funcname[258], *import_python;
171 
172     PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
173 
174     {
175         HINSTANCE hDLL = NULL;
176         char pathbuf[260];
177         LPTSTR dummy;
178         unsigned int old_mode;
179         ULONG_PTR cookie = 0;
180         /* We use LoadLibraryEx so Windows looks for dependent DLLs
181             in directory of pathname first.  However, Windows95
182             can sometimes not work correctly unless the absolute
183             path is used.  If GetFullPathName() fails, the LoadLibrary
184             will certainly fail too, so use its error code */
185 
186         /* Don't display a message box when Python can't load a DLL */
187         old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
188 
189         if (GetFullPathName(pathname,
190                             sizeof(pathbuf),
191                             pathbuf,
192                             &dummy)) {
193             ULONG_PTR cookie = _Py_ActivateActCtx();
194             /* XXX This call doesn't exist in Windows CE */
195             hDLL = LoadLibraryEx(pathname, NULL,
196                                  LOAD_WITH_ALTERED_SEARCH_PATH);
197             _Py_DeactivateActCtx(cookie);
198         }
199 
200         /* restore old error mode settings */
201         SetErrorMode(old_mode);
202 
203         if (hDLL==NULL){
204             char errBuf[256];
205             unsigned int errorCode;
206 
207             /* Get an error string from Win32 error code */
208             char theInfo[256]; /* Pointer to error text
209                                   from system */
210             int theLength; /* Length of error text */
211 
212             errorCode = GetLastError();
213 
214             theLength = FormatMessage(
215                 FORMAT_MESSAGE_FROM_SYSTEM |
216                 FORMAT_MESSAGE_IGNORE_INSERTS, /* flags */
217                 NULL, /* message source */
218                 errorCode, /* the message (error) ID */
219                 0, /* default language environment */
220                 (LPTSTR) theInfo, /* the buffer */
221                 sizeof(theInfo), /* the buffer size */
222                 NULL); /* no additional format args. */
223 
224             /* Problem: could not get the error message.
225                This should not happen if called correctly. */
226             if (theLength == 0) {
227                 PyOS_snprintf(errBuf, sizeof(errBuf),
228                       "DLL load failed with error code %d",
229                           errorCode);
230             } else {
231                 size_t len;
232                 /* For some reason a \r\n
233                    is appended to the text */
234                 if (theLength >= 2 &&
235                     theInfo[theLength-2] == '\r' &&
236                     theInfo[theLength-1] == '\n') {
237                     theLength -= 2;
238                     theInfo[theLength] = '\0';
239                 }
240                 strcpy(errBuf, "DLL load failed: ");
241                 len = strlen(errBuf);
242                 strncpy(errBuf+len, theInfo,
243                     sizeof(errBuf)-len);
244                 errBuf[sizeof(errBuf)-1] = '\0';
245             }
246             PyErr_SetString(PyExc_ImportError, errBuf);
247             return NULL;
248         } else {
249             char buffer[256];
250 
251 #ifdef _DEBUG
252             PyOS_snprintf(buffer, sizeof(buffer), "python%d%d_d.dll",
253 #else
254             PyOS_snprintf(buffer, sizeof(buffer), "python%d%d.dll",
255 #endif
256                           PY_MAJOR_VERSION,PY_MINOR_VERSION);
257             import_python = GetPythonImport(hDLL);
258 
259             if (import_python &&
260                 strcasecmp(buffer,import_python)) {
261                 PyOS_snprintf(buffer, sizeof(buffer),
262                               "Module use of %.150s conflicts "
263                               "with this version of Python.",
264                               import_python);
265                 PyErr_SetString(PyExc_ImportError,buffer);
266                 FreeLibrary(hDLL);
267                 return NULL;
268             }
269         }
270         p = GetProcAddress(hDLL, funcname);
271     }
272 
273     return p;
274 }
275