int do_import(FARPROC init_func, char *modname) { int res = -1; PyObject* (*p)(void); PyObject *m = NULL; struct PyModuleDef *def; char *oldcontext; PyObject *name = PyUnicode_FromString(modname); if (name == NULL) return -1; m = _PyImport_FindExtensionObject(name, name); if (m != NULL) { Py_DECREF(name); return 0; } if (init_func == NULL) { PyObject *msg = PyUnicode_FromFormat("dynamic module does not define " "init function (PyInit_%s)", modname); if (msg == NULL) return -1; PyErr_SetImportError(msg, name, NULL); Py_DECREF(msg); Py_DECREF(name); return -1; } oldcontext = _Py_PackageContext; _Py_PackageContext = modname; p = (PyObject*(*)(void))init_func; m = (*p)(); _Py_PackageContext = oldcontext; if (PyErr_Occurred()) { Py_DECREF(name); return -1; } /* Remember pointer to module init function. */ def = PyModule_GetDef(m); if (def == NULL) { PyErr_Format(PyExc_SystemError, "initialization of %s did not return an extension " "module", modname); Py_DECREF(name); return -1; } def->m_base.m_init = p; res = _PyImport_FixupExtensionObject(m, name, name); Py_DECREF(name); return res; }
dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, const char *pathname, FILE *fp) { dl_funcptr p; void *handle; char funcname[258]; char pathbuf[260]; int dlopenflags=0; if (strchr(pathname, '/') == NULL) { /* Prefix bare filename with "./" */ PyOS_snprintf(pathbuf, sizeof(pathbuf), "./%-.255s", pathname); pathname = pathbuf; } PyOS_snprintf(funcname, sizeof(funcname), LEAD_UNDERSCORE "PyInit_%.200s", shortname); if (fp != NULL) { int i; struct stat statb; if (fstat(fileno(fp), &statb) == -1) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } for (i = 0; i < nhandles; i++) { if (statb.st_dev == handles[i].dev && statb.st_ino == handles[i].ino) { p = (dl_funcptr) dlsym(handles[i].handle, funcname); return p; } } if (nhandles < 128) { handles[nhandles].dev = statb.st_dev; #ifdef __VMS handles[nhandles].ino[0] = statb.st_ino[0]; handles[nhandles].ino[1] = statb.st_ino[1]; handles[nhandles].ino[2] = statb.st_ino[2]; #else handles[nhandles].ino = statb.st_ino; #endif } } dlopenflags = PyThreadState_GET()->interp->dlopenflags; #ifdef __VMS /* VMS currently don't allow a pathname, use a logical name instead */ /* Concatenate 'python_module_' and shortname */ /* so "import vms.bar" will use the logical python_module_bar */ /* As C module use only one name space this is probably not a */ /* important limitation */ PyOS_snprintf(pathbuf, sizeof(pathbuf), "python_module_%-.200s", shortname); pathname = pathbuf; #endif handle = dlopen(pathname, dlopenflags); if (handle == NULL) { PyObject *mod_name; PyObject *path; PyObject *error_ob; const char *error = dlerror(); if (error == NULL) error = "unknown dlopen() error"; error_ob = PyUnicode_FromString(error); if (error_ob == NULL) return NULL; mod_name = PyUnicode_FromString(shortname); if (mod_name == NULL) { Py_DECREF(error_ob); return NULL; } path = PyUnicode_FromString(pathname); if (path == NULL) { Py_DECREF(error_ob); Py_DECREF(mod_name); return NULL; } PyErr_SetImportError(error_ob, mod_name, path); Py_DECREF(error_ob); Py_DECREF(mod_name); Py_DECREF(path); return NULL; } if (fp != NULL && nhandles < 128) handles[nhandles++].handle = handle; p = (dl_funcptr) dlsym(handle, funcname); return p; }
PyObject * _PyImport_LoadDynamicModuleWithSpec(PyObject *spec, FILE *fp) { #ifndef MS_WINDOWS PyObject *pathbytes = NULL; #endif PyObject *name_unicode = NULL, *name = NULL, *path = NULL, *m = NULL; const char *name_buf, *hook_prefix; const char *oldcontext; dl_funcptr exportfunc; PyModuleDef *def; PyObject *(*p0)(void); name_unicode = PyObject_GetAttrString(spec, "name"); if (name_unicode == NULL) { return NULL; } name = get_encoded_name(name_unicode, &hook_prefix); if (name == NULL) { goto error; } name_buf = PyBytes_AS_STRING(name); path = PyObject_GetAttrString(spec, "origin"); if (path == NULL) goto error; #ifdef MS_WINDOWS exportfunc = _PyImport_FindSharedFuncptrWindows(hook_prefix, name_buf, path, fp); #else pathbytes = PyUnicode_EncodeFSDefault(path); if (pathbytes == NULL) goto error; exportfunc = _PyImport_FindSharedFuncptr(hook_prefix, name_buf, PyBytes_AS_STRING(pathbytes), fp); Py_DECREF(pathbytes); #endif if (exportfunc == NULL) { if (!PyErr_Occurred()) { PyObject *msg; msg = PyUnicode_FromFormat( "dynamic module does not define " "module export function (%s_%s)", hook_prefix, name_buf); if (msg == NULL) goto error; PyErr_SetImportError(msg, name_unicode, path); Py_DECREF(msg); } goto error; } p0 = (PyObject *(*)(void))exportfunc; /* Package context is needed for single-phase init */ oldcontext = _Py_PackageContext; _Py_PackageContext = PyUnicode_AsUTF8(name_unicode); if (_Py_PackageContext == NULL) { _Py_PackageContext = oldcontext; goto error; } m = p0(); _Py_PackageContext = oldcontext; if (m == NULL) { if (!PyErr_Occurred()) { PyErr_Format( PyExc_SystemError, "initialization of %s failed without raising an exception", name_buf); } goto error; } else if (PyErr_Occurred()) { PyErr_Clear(); PyErr_Format( PyExc_SystemError, "initialization of %s raised unreported exception", name_buf); m = NULL; goto error; } if (Py_TYPE(m) == NULL) { /* This can happen when a PyModuleDef is returned without calling * PyModuleDef_Init on it */ PyErr_Format(PyExc_SystemError, "init function of %s returned uninitialized object", name_buf); m = NULL; /* prevent segfault in DECREF */ goto error; } if (PyObject_TypeCheck(m, &PyModuleDef_Type)) { Py_DECREF(name_unicode); Py_DECREF(name); Py_DECREF(path); return PyModule_FromDefAndSpec((PyModuleDef*)m, spec); } /* Fall back to single-phase init mechanism */ if (hook_prefix == nonascii_prefix) { /* don't allow legacy init for non-ASCII module names */ PyErr_Format( PyExc_SystemError, "initialization of * did not return PyModuleDef", name_buf); goto error; } /* Remember pointer to module init function. */ def = PyModule_GetDef(m); if (def == NULL) { PyErr_Format(PyExc_SystemError, "initialization of %s did not return an extension " "module", name_buf); goto error; } def->m_base.m_init = p0; /* Remember the filename as the __file__ attribute */ if (PyModule_AddObject(m, "__file__", path) < 0) PyErr_Clear(); /* Not important enough to report */ else Py_INCREF(path); if (_PyImport_FixupExtensionObject(m, name_unicode, path) < 0) goto error; Py_DECREF(name_unicode); Py_DECREF(name); Py_DECREF(path); return m; error: Py_DECREF(name_unicode); Py_XDECREF(name); Py_XDECREF(path); Py_XDECREF(m); return NULL; }
static char *GetPythonImport (HINSTANCE hModule) { unsigned char *dllbase, *import_data, *import_name; DWORD pe_offset, opt_offset; WORD opt_magic; int num_dict_off, import_off; /* Safety check input */ if (hModule == NULL) { return NULL; } /* Module instance is also the base load address. First portion of memory is the MS-DOS loader, which holds the offset to the PE header (from the load base) at 0x3C */ dllbase = (unsigned char *)hModule; pe_offset = DWORD_AT(dllbase + 0x3C); /* The PE signature must be "PE\0\0" */ if (memcmp(dllbase+pe_offset,"PE\0\0",4)) { return NULL; } /* Following the PE signature is the standard COFF header (20 bytes) and then the optional header. The optional header starts with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+ uses 64-bits for some fields). It might also be 0x107 for a ROM image, but we don't process that here. The optional header ends with a data dictionary that directly points to certain types of data, among them the import entries (in the second table entry). Based on the header type, we determine offsets for the data dictionary count and the entry within the dictionary pointing to the imports. */ opt_offset = pe_offset + 4 + 20; opt_magic = WORD_AT(dllbase+opt_offset); if (opt_magic == 0x10B) { /* PE32 */ num_dict_off = 92; import_off = 104; } else if (opt_magic == 0x20B) { /* PE32+ */ num_dict_off = 108; import_off = 120; } else { /* Unsupported */ return NULL; } /* Now if an import table exists, offset to it and walk the list of imports. The import table is an array (ending when an entry has empty values) of structures (20 bytes each), which contains (at offset 12) a relative address (to the module base) at which a string constant holding the import name is located. */ if (DWORD_AT(dllbase + opt_offset + num_dict_off) >= 2) { /* We have at least 2 tables - the import table is the second one. But still it may be that the table size is zero */ if (0 == DWORD_AT(dllbase + opt_offset + import_off + sizeof(DWORD))) return NULL; import_data = dllbase + DWORD_AT(dllbase + opt_offset + import_off); while (DWORD_AT(import_data)) { import_name = dllbase + DWORD_AT(import_data+12); if (strlen(import_name) >= 6 && !strncmp(import_name,"python",6)) { char *pch; #ifndef _DEBUG /* In a release version, don't claim that python3.dll is a Python DLL. */ if (strcmp(import_name, "python3.dll") == 0) { import_data += 20; continue; } #endif /* Ensure python prefix is followed only by numbers to the end of the basename */ pch = import_name + 6; #ifdef _DEBUG while (*pch && pch[0] != '_' && pch[1] != 'd' && pch[2] != '.') { #else while (*pch && *pch != '.') { #endif if (*pch >= '0' && *pch <= '9') { pch++; } else { pch = NULL; break; } } if (pch) { /* Found it - return the name */ return import_name; } } import_data += 20; } } return NULL; } dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix, const char *shortname, PyObject *pathname, FILE *fp) { dl_funcptr p; char funcname[258], *import_python; const wchar_t *wpathname; #ifndef _DEBUG _Py_CheckPython3(); #endif wpathname = _PyUnicode_AsUnicode(pathname); if (wpathname == NULL) return NULL; PyOS_snprintf(funcname, sizeof(funcname), "%.20s_%.200s", prefix, shortname); { HINSTANCE hDLL = NULL; unsigned int old_mode; #if HAVE_SXS ULONG_PTR cookie = 0; #endif /* Don't display a message box when Python can't load a DLL */ old_mode = SetErrorMode(SEM_FAILCRITICALERRORS); #if HAVE_SXS cookie = _Py_ActivateActCtx(); #endif /* We use LoadLibraryEx so Windows looks for dependent DLLs in directory of pathname first. */ /* XXX This call doesn't exist in Windows CE */ Py_BEGIN_ALLOW_THREADS hDLL = LoadLibraryExW(wpathname, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); Py_END_ALLOW_THREADS #if HAVE_SXS _Py_DeactivateActCtx(cookie); #endif /* restore old error mode settings */ SetErrorMode(old_mode); if (hDLL==NULL){ PyObject *message; unsigned int errorCode; /* Get an error string from Win32 error code */ wchar_t theInfo[256]; /* Pointer to error text from system */ int theLength; /* Length of error text */ errorCode = GetLastError(); theLength = FormatMessageW( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, /* flags */ NULL, /* message source */ errorCode, /* the message (error) ID */ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ theInfo, /* the buffer */ sizeof(theInfo) / sizeof(wchar_t), /* size in wchars */ NULL); /* no additional format args. */ /* Problem: could not get the error message. This should not happen if called correctly. */ if (theLength == 0) { message = PyUnicode_FromFormat( "DLL load failed with error code %d", errorCode); } else { /* For some reason a \r\n is appended to the text */ if (theLength >= 2 && theInfo[theLength-2] == '\r' && theInfo[theLength-1] == '\n') { theLength -= 2; theInfo[theLength] = '\0'; } message = PyUnicode_FromString( "DLL load failed: "); PyUnicode_AppendAndDel(&message, PyUnicode_FromWideChar( theInfo, theLength)); } if (message != NULL) { PyObject *shortname_obj = PyUnicode_FromString(shortname); PyErr_SetImportError(message, shortname_obj, pathname); Py_XDECREF(shortname_obj); Py_DECREF(message); } return NULL; } else { char buffer[256]; PyOS_snprintf(buffer, sizeof(buffer), #ifdef _DEBUG "python%d%d_d.dll", #else "python%d%d.dll", #endif PY_MAJOR_VERSION,PY_MINOR_VERSION); import_python = GetPythonImport(hDLL); if (import_python && strcasecmp(buffer,import_python)) { PyErr_Format(PyExc_ImportError, "Module use of %.150s conflicts " "with this version of Python.", import_python); Py_BEGIN_ALLOW_THREADS FreeLibrary(hDLL); Py_END_ALLOW_THREADS return NULL; } } Py_BEGIN_ALLOW_THREADS p = GetProcAddress(hDLL, funcname); Py_END_ALLOW_THREADS }
dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, const char *shortname, const char *pathname, FILE *fp) { dl_funcptr p; void *handle; char funcname[258]; char pathbuf[260]; int dlopenflags=0; if (strchr(pathname, '/') == NULL) { /* Prefix bare filename with "./" */ PyOS_snprintf(pathbuf, sizeof(pathbuf), "./%-.255s", pathname); pathname = pathbuf; } PyOS_snprintf(funcname, sizeof(funcname), LEAD_UNDERSCORE "%.20s_%.200s", prefix, shortname); if (fp != NULL) { int i; struct _Py_stat_struct status; if (_Py_fstat(fileno(fp), &status) == -1) return NULL; for (i = 0; i < nhandles; i++) { if (status.st_dev == handles[i].dev && status.st_ino == handles[i].ino) { p = (dl_funcptr) dlsym(handles[i].handle, funcname); return p; } } if (nhandles < 128) { handles[nhandles].dev = status.st_dev; handles[nhandles].ino = status.st_ino; } } dlopenflags = PyThreadState_GET()->interp->dlopenflags; handle = dlopen(pathname, dlopenflags); if (handle == NULL) { PyObject *mod_name; PyObject *path; PyObject *error_ob; const char *error = dlerror(); if (error == NULL) error = "unknown dlopen() error"; error_ob = PyUnicode_FromString(error); if (error_ob == NULL) return NULL; mod_name = PyUnicode_FromString(shortname); if (mod_name == NULL) { Py_DECREF(error_ob); return NULL; } path = PyUnicode_FromString(pathname); if (path == NULL) { Py_DECREF(error_ob); Py_DECREF(mod_name); return NULL; } PyErr_SetImportError(error_ob, mod_name, path); Py_DECREF(error_ob); Py_DECREF(mod_name); Py_DECREF(path); return NULL; } if (fp != NULL && nhandles < 128) handles[nhandles++].handle = handle; p = (dl_funcptr) dlsym(handle, funcname); return p; }