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...
15extern ULONG_PTR _Py_ActivateActCtx();
16void _Py_DeactivateActCtx(ULONG_PTR cookie);
17
18const 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
31static 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
67static 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
166dl_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