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