Python/dynload_win.c

   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 }