#include "Python.h"

#include "Python-ast.h"

#undef Yield /* undefine macro conflicting with <winbase.h> */

#include "pycore_initconfig.h"

#include "pycore_pyerrors.h"

#include "pycore_pyhash.h"

#include "pycore_pylifecycle.h"

#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()

#include "pycore_interp.h" // _PyInterpreterState_ClearModules()

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_sysmodule.h"

#include "errcode.h"

#include "marshal.h"

#include "code.h"

#include "importdl.h"

#include "pydtrace.h"

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#ifdef __cplusplus

extern "C" {

#define CACHEDIR "__pycache__"

static PyObject *import_add_module(PyThreadState *tstate, PyObject *name);

static PyObject *extensions = NULL;

extern struct _inittab _PyImport_Inittab[];

struct _inittab *PyImport_Inittab = _PyImport_Inittab;

static struct _inittab *inittab_copy = NULL;

_Py_IDENTIFIER(__path__);

_Py_IDENTIFIER(__spec__);

#include "clinic/import.c.h"

_PyImportHooks_Init(PyThreadState *tstate)

{

PyObject *v, *path_hooks = NULL;

int err = 0;

/* adding sys.path_hooks and sys.path_importer_cache */

v = PyList_New(0);

if (v == NULL)

goto error;

err = PySys_SetObject("meta_path", v);

Py_DECREF(v);

if (err)

goto error;

v = PyDict_New();

if (v == NULL)

goto error;

err = PySys_SetObject("path_importer_cache", v);

Py_DECREF(v);

if (err)

goto error;

path_hooks = PyList_New(0);

if (path_hooks == NULL)

goto error;

err = PySys_SetObject("path_hooks", path_hooks);

if (err) {

goto error;

}

Py_DECREF(path_hooks);

return _PyStatus_OK();

error:

_PyErr_Print(tstate);

return _PyStatus_ERR("initializing sys.meta_path, sys.path_hooks, "

"or path_importer_cache failed");

}

_PyImportZip_Init(PyThreadState *tstate)

{

PyObject *path_hooks, *zipimport;

int err = 0;

path_hooks = PySys_GetObject("path_hooks");

if (path_hooks == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"unable to get sys.path_hooks");

goto error;

}

int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;

if (verbose) {

PySys_WriteStderr("# installing zipimport hook\n");

}

zipimport = PyImport_ImportModule("zipimport");

if (zipimport == NULL) {

_PyErr_Clear(tstate); /* No zip import module -- okay */

if (verbose) {

PySys_WriteStderr("# can't import zipimport\n");

}

}

else {

_Py_IDENTIFIER(zipimporter);

PyObject *zipimporter = _PyObject_GetAttrId(zipimport,

&PyId_zipimporter);

Py_DECREF(zipimport);

if (zipimporter == NULL) {

_PyErr_Clear(tstate); /* No zipimporter object -- okay */

if (verbose) {

PySys_WriteStderr("# can't import zipimport.zipimporter\n");

}

}

else {

/* sys.path_hooks.insert(0, zipimporter) */

err = PyList_Insert(path_hooks, 0, zipimporter);

Py_DECREF(zipimporter);

if (err < 0) {

goto error;

}

if (verbose) {

PySys_WriteStderr("# installed zipimport hook\n");

}

}

}

return _PyStatus_OK();

error:

PyErr_Print();

return _PyStatus_ERR("initializing zipimport failed");

}

static PyThread_type_lock import_lock = 0;

static unsigned long import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

static int import_lock_level = 0;

_PyImport_AcquireLock(void)

{

unsigned long me = PyThread_get_thread_ident();

if (me == PYTHREAD_INVALID_THREAD_ID)

return; /* Too bad */

if (import_lock == NULL) {

import_lock = PyThread_allocate_lock();

if (import_lock == NULL)

return; /* Nothing much we can do. */

}

if (import_lock_thread == me) {

import_lock_level++;

return;

}

if (import_lock_thread != PYTHREAD_INVALID_THREAD_ID ||

!PyThread_acquire_lock(import_lock, 0))

{

PyThreadState *tstate = PyEval_SaveThread();

PyThread_acquire_lock(import_lock, 1);

PyEval_RestoreThread(tstate);

}

assert(import_lock_level == 0);

import_lock_thread = me;

import_lock_level = 1;

}

_PyImport_ReleaseLock(void)

{

unsigned long me = PyThread_get_thread_ident();

if (me == PYTHREAD_INVALID_THREAD_ID || import_lock == NULL)

return 0; /* Too bad */

if (import_lock_thread != me)

return -1;

import_lock_level--;

assert(import_lock_level >= 0);

if (import_lock_level == 0) {

import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

PyThread_release_lock(import_lock);

}

return 1;

}

#ifdef HAVE_FORK

_PyImport_ReInitLock(void)

{

if (import_lock != NULL) {

if (_PyThread_at_fork_reinit(&import_lock) < 0) {

_Py_FatalErrorFunc(__func__, "failed to create a new lock");

}

}

if (import_lock_level > 1) {

/* Forked as a side effect of import */

unsigned long me = PyThread_get_thread_ident();

/* The following could fail if the lock is already held, but forking as

PyThread_acquire_lock(import_lock, NOWAIT_LOCK);

import_lock_thread = me;

import_lock_level--;

} else {

import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

import_lock_level = 0;

}

}

static PyObject *

_imp_lock_held_impl(PyObject *module)

{

return PyBool_FromLong(import_lock_thread != PYTHREAD_INVALID_THREAD_ID);

}

static PyObject *

_imp_acquire_lock_impl(PyObject *module)

{

_PyImport_AcquireLock();

Py_RETURN_NONE;

}

static PyObject *

_imp_release_lock_impl(PyObject *module)

{

if (_PyImport_ReleaseLock() < 0) {

PyErr_SetString(PyExc_RuntimeError,

"not holding the import lock");

return NULL;

}

Py_RETURN_NONE;

}

_PyImport_Fini(void)

{

Py_CLEAR(extensions);

if (import_lock != NULL) {

PyThread_free_lock(import_lock);

import_lock = NULL;

}

}

_PyImport_Fini2(void)

{

/* Use the same memory allocator than PyImport_ExtendInittab(). */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

// Reset PyImport_Inittab

PyImport_Inittab = _PyImport_Inittab;

/* Free memory allocated by PyImport_ExtendInittab() */

PyMem_RawFree(inittab_copy);

inittab_copy = NULL;

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

PyObject *

PyImport_GetModuleDict(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (interp->modules == NULL) {

Py_FatalError("interpreter has no modules dictionary");

}

return interp->modules;

}

_PyImport_IsInitialized(PyInterpreterState *interp)

{

if (interp->modules == NULL)

return 0;

return 1;

}

PyObject *

_PyImport_GetModuleId(struct _Py_Identifier *nameid)

{

PyObject *name = _PyUnicode_FromId(nameid); /* borrowed */

if (name == NULL) {

return NULL;

}

return PyImport_GetModule(name);

}

_PyImport_SetModule(PyObject *name, PyObject *m)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *modules = tstate->interp->modules;

return PyObject_SetItem(modules, name, m);

}

_PyImport_SetModuleString(const char *name, PyObject *m)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *modules = tstate->interp->modules;

return PyMapping_SetItemString(modules, name, m);

}

static PyObject *

import_get_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = tstate->interp->modules;

if (modules == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"unable to get sys.modules");

return NULL;

}

PyObject *m;

Py_INCREF(modules);

if (PyDict_CheckExact(modules)) {

m = PyDict_GetItemWithError(modules, name); /* borrowed */

Py_XINCREF(m);

}

else {

m = PyObject_GetItem(modules, name);

if (m == NULL && _PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

Py_DECREF(modules);

return m;

}

static int

import_ensure_initialized(PyThreadState *tstate, PyObject *mod, PyObject *name)

{

PyInterpreterState *interp = tstate->interp;

PyObject *spec;

_Py_IDENTIFIER(_lock_unlock_module);

/* Optimization: only call _bootstrap._lock_unlock_module() if

spec = _PyObject_GetAttrId(mod, &PyId___spec__);

int busy = _PyModuleSpec_IsInitializing(spec);

Py_XDECREF(spec);

if (busy) {

/* Wait until module is done importing. */

PyObject *value = _PyObject_CallMethodIdOneArg(

interp->importlib, &PyId__lock_unlock_module, name);

if (value == NULL) {

return -1;

}

Py_DECREF(value);

}

return 0;

}

static const char * const sys_deletes[] = {

"path", "argv", "ps1", "ps2",

"last_type", "last_value", "last_traceback",

"path_hooks", "path_importer_cache", "meta_path",

"__interactivehook__",

NULL

};

static const char * const sys_files[] = {

"stdin", "__stdin__",

"stdout", "__stdout__",

"stderr", "__stderr__",

NULL

};

_PyImport_Cleanup(PyThreadState *tstate)

{

PyInterpreterState *interp = tstate->interp;

PyObject *modules = interp->modules;

if (modules == NULL) {

/* Already done */

return;

}

/* Delete some special variables first. These are common

/* XXX Perhaps these precautions are obsolete. Who knows? */

int verbose = _PyInterpreterState_GetConfig(interp)->verbose;

if (verbose) {

PySys_WriteStderr("# clear builtins._\n");

}

if (PyDict_SetItemString(interp->builtins, "_", Py_None) < 0) {

PyErr_WriteUnraisable(NULL);

}

const char * const *p;

for (p = sys_deletes; *p != NULL; p++) {

if (verbose) {

PySys_WriteStderr("# clear sys.%s\n", *p);

}

if (PyDict_SetItemString(interp->sysdict, *p, Py_None) < 0) {

PyErr_WriteUnraisable(NULL);

}

}

for (p = sys_files; *p != NULL; p+=2) {

if (verbose) {

PySys_WriteStderr("# restore sys.%s\n", *p);

}

PyObject *value = _PyDict_GetItemStringWithError(interp->sysdict,

*(p+1));

if (value == NULL) {

if (_PyErr_Occurred(tstate)) {

PyErr_WriteUnraisable(NULL);

}

value = Py_None;

}

if (PyDict_SetItemString(interp->sysdict, *p, value) < 0) {

PyErr_WriteUnraisable(NULL);

}

}

/* We prepare a list which will receive (name, weakref) tuples of

PyObject *weaklist = PyList_New(0);

if (weaklist == NULL) {

PyErr_WriteUnraisable(NULL);

}

#define STORE_MODULE_WEAKREF(name, mod) \

if (weaklist != NULL) { \

PyObject *wr = PyWeakref_NewRef(mod, NULL); \

if (wr) { \

PyObject *tup = PyTuple_Pack(2, name, wr); \

if (!tup || PyList_Append(weaklist, tup) < 0) { \

PyErr_WriteUnraisable(NULL); \

} \

Py_XDECREF(tup); \

Py_DECREF(wr); \

} \

else { \

PyErr_WriteUnraisable(NULL); \

} \

}

#define CLEAR_MODULE(name, mod) \

if (PyModule_Check(mod)) { \

if (verbose && PyUnicode_Check(name)) { \

PySys_FormatStderr("# cleanup[2] removing %U\n", name); \

} \

STORE_MODULE_WEAKREF(name, mod); \

if (PyObject_SetItem(modules, name, Py_None) < 0) { \

PyErr_WriteUnraisable(NULL); \

} \

}

/* Remove all modules from sys.modules, hoping that garbage collection

if (PyDict_CheckExact(modules)) {

Py_ssize_t pos = 0;

PyObject *key, *value;

while (PyDict_Next(modules, &pos, &key, &value)) {

CLEAR_MODULE(key, value);

}

}

else {

PyObject *iterator = PyObject_GetIter(modules);

if (iterator == NULL) {

PyErr_WriteUnraisable(NULL);

}

else {

PyObject *key;

while ((key = PyIter_Next(iterator))) {

PyObject *value = PyObject_GetItem(modules, key);

if (value == NULL) {

PyErr_WriteUnraisable(NULL);

continue;

}

CLEAR_MODULE(key, value);

Py_DECREF(value);

Py_DECREF(key);

}

if (PyErr_Occurred()) {

PyErr_WriteUnraisable(NULL);

}

Py_DECREF(iterator);

}

}

/* Clear the modules dict. */

if (PyDict_CheckExact(modules)) {

PyDict_Clear(modules);

}

else {

_Py_IDENTIFIER(clear);

if (_PyObject_CallMethodIdNoArgs(modules, &PyId_clear) == NULL) {

PyErr_WriteUnraisable(NULL);

}

}

/* Restore the original builtins dict, to ensure that any

PyObject *dict = PyDict_Copy(interp->builtins);

if (dict == NULL) {

PyErr_WriteUnraisable(NULL);

}

PyDict_Clear(interp->builtins);

if (PyDict_Update(interp->builtins, interp->builtins_copy)) {

_PyErr_Clear(tstate);

}

Py_XDECREF(dict);

/* Collect references */

_PyGC_CollectNoFail();

/* Dump GC stats before it's too late, since it uses the warnings

_PyGC_DumpShutdownStats(tstate);

/* Now, if there are any modules left alive, clear their globals to

if (weaklist != NULL) {

Py_ssize_t i;

/* Since dict is ordered in CPython 3.6+, modules are saved in

for (i = PyList_GET_SIZE(weaklist) - 1; i >= 0; i--) {

PyObject *tup = PyList_GET_ITEM(weaklist, i);

PyObject *name = PyTuple_GET_ITEM(tup, 0);

PyObject *mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1));

if (mod == Py_None)

continue;

assert(PyModule_Check(mod));

dict = PyModule_GetDict(mod);

if (dict == interp->builtins || dict == interp->sysdict)

continue;

Py_INCREF(mod);

if (verbose && PyUnicode_Check(name)) {

PySys_FormatStderr("# cleanup[3] wiping %U\n", name);

}

_PyModule_Clear(mod);

Py_DECREF(mod);

}

Py_DECREF(weaklist);

}

/* Next, delete sys and builtins (in that order) */

if (verbose) {

PySys_FormatStderr("# cleanup[3] wiping sys\n");

}

_PyModule_ClearDict(interp->sysdict);

if (verbose) {

PySys_FormatStderr("# cleanup[3] wiping builtins\n");

}

_PyModule_ClearDict(interp->builtins);

/* Clear module dict copies stored in the interpreter state */

_PyInterpreterState_ClearModules(interp);

/* Clear and delete the modules directory. Actual modules will

interp->modules = NULL;

Py_DECREF(modules);

/* Once more */

_PyGC_CollectNoFail();

#undef CLEAR_MODULE

#undef STORE_MODULE_WEAKREF

}

PyImport_GetMagicNumber(void)

{

long res;

PyInterpreterState *interp = _PyInterpreterState_GET();

PyObject *external, *pyc_magic;

external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external");

if (external == NULL)

return -1;

pyc_magic = PyObject_GetAttrString(external, "_RAW_MAGIC_NUMBER");

Py_DECREF(external);

if (pyc_magic == NULL)

return -1;

res = PyLong_AsLong(pyc_magic);

Py_DECREF(pyc_magic);

return res;

}

extern const char * _PySys_ImplCacheTag;

const char *

PyImport_GetMagicTag(void)

{

return _PySys_ImplCacheTag;

}

_PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,

PyObject *filename, PyObject *modules)

{

if (mod == NULL || !PyModule_Check(mod)) {

PyErr_BadInternalCall();

return -1;

}

struct PyModuleDef *def = PyModule_GetDef(mod);

if (!def) {

PyErr_BadInternalCall();

return -1;

}

PyThreadState *tstate = _PyThreadState_GET();

if (PyObject_SetItem(modules, name, mod) < 0) {

return -1;

}

if (_PyState_AddModule(tstate, mod, def) < 0) {

PyMapping_DelItem(modules, name);

return -1;

}

// bpo-44050: Extensions and def->m_base.m_copy can be updated

// when the extension module doesn't support sub-interpreters.

if (_Py_IsMainInterpreter(tstate) || def->m_size == -1) {

if (def->m_size == -1) {

if (def->m_base.m_copy) {

/* Somebody already imported the module,

Py_CLEAR(def->m_base.m_copy);

}

PyObject *dict = PyModule_GetDict(mod);

if (dict == NULL) {

return -1;

}

def->m_base.m_copy = PyDict_Copy(dict);

if (def->m_base.m_copy == NULL) {

return -1;

}

}

if (extensions == NULL) {

extensions = PyDict_New();

if (extensions == NULL) {

return -1;

}

}

PyObject *key = PyTuple_Pack(2, filename, name);

if (key == NULL) {

return -1;

}

int res = PyDict_SetItem(extensions, key, (PyObject *)def);

Py_DECREF(key);

if (res < 0) {

return -1;

}

}

return 0;

}

_PyImport_FixupBuiltin(PyObject *mod, const char *name, PyObject *modules)

{

int res;

PyObject *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return -1;

res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj, modules);

Py_DECREF(nameobj);

return res;

}

static PyObject *

import_find_extension(PyThreadState *tstate, PyObject *name,

PyObject *filename)

{

if (extensions == NULL) {

return NULL;

}

PyObject *key = PyTuple_Pack(2, filename, name);

if (key == NULL) {

return NULL;

}

PyModuleDef* def = (PyModuleDef *)PyDict_GetItemWithError(extensions, key);

Py_DECREF(key);

if (def == NULL) {

return NULL;

}

PyObject *mod, *mdict;

PyObject *modules = tstate->interp->modules;

if (def->m_size == -1) {

/* Module does not support repeated initialization */

if (def->m_base.m_copy == NULL)

return NULL;

mod = import_add_module(tstate, name);

if (mod == NULL)

return NULL;

mdict = PyModule_GetDict(mod);

if (mdict == NULL)

return NULL;

if (PyDict_Update(mdict, def->m_base.m_copy))

return NULL;

}

else {

if (def->m_base.m_init == NULL)

return NULL;

mod = def->m_base.m_init();

if (mod == NULL)

return NULL;

if (PyObject_SetItem(modules, name, mod) == -1) {

Py_DECREF(mod);

return NULL;

}

Py_DECREF(mod);

}

if (_PyState_AddModule(tstate, mod, def) < 0) {

PyMapping_DelItem(modules, name);

return NULL;

}

int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;

if (verbose) {

PySys_FormatStderr("import %U # previously loaded (%R)\n",

name, filename);

}

return mod;

}

PyObject *

_PyImport_FindExtensionObject(PyObject *name, PyObject *filename)

{

PyThreadState *tstate = _PyThreadState_GET();

return import_find_extension(tstate, name, filename);

}

PyObject *

_PyImport_FindBuiltin(PyThreadState *tstate, const char *name)

{

PyObject *res, *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return NULL;

res = import_find_extension(tstate, nameobj, nameobj);

Py_DECREF(nameobj);

return res;

}

static PyObject *

import_add_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = tstate->interp->modules;

if (modules == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"no import module dictionary");

return NULL;

}

PyObject *m;

if (PyDict_CheckExact(modules)) {

m = PyDict_GetItemWithError(modules, name);

}

else {

m = PyObject_GetItem(modules, name);

// For backward-compatibility we copy the behavior

// of PyDict_GetItemWithError().

if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

if (_PyErr_Occurred(tstate)) {

return NULL;

}

if (m != NULL && PyModule_Check(m)) {

return m;

}

m = PyModule_NewObject(name);

if (m == NULL)

return NULL;

if (PyObject_SetItem(modules, name, m) != 0) {

Py_DECREF(m);

return NULL;

}

Py_DECREF(m); /* Yes, it still exists, in modules! */

return m;

}

PyObject *

PyImport_AddModuleObject(PyObject *name)

{

PyThreadState *tstate = _PyThreadState_GET();

return import_add_module(tstate, name);

}

PyObject *

PyImport_AddModule(const char *name)

{

PyObject *nameobj = PyUnicode_FromString(name);

if (nameobj == NULL) {

return NULL;

}

PyObject *module = PyImport_AddModuleObject(nameobj);

Py_DECREF(nameobj);

return module;

}

static void

remove_module(PyThreadState *tstate, PyObject *name)

{

PyObject *type, *value, *traceback;

_PyErr_Fetch(tstate, &type, &value, &traceback);

PyObject *modules = tstate->interp->modules;

if (PyDict_CheckExact(modules)) {

PyObject *mod = _PyDict_Pop(modules, name, Py_None);

Py_XDECREF(mod);

}

else if (PyMapping_DelItem(modules, name) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

_PyErr_ChainExceptions(type, value, traceback);

}

PyObject *

PyImport_ExecCodeModule(const char *name, PyObject *co)

{

return PyImport_ExecCodeModuleWithPathnames(

name, co, (char *)NULL, (char *)NULL);

}

PyObject *

PyImport_ExecCodeModuleEx(const char *name, PyObject *co, const char *pathname)

{

return PyImport_ExecCodeModuleWithPathnames(

name, co, pathname, (char *)NULL);

}

PyObject *

PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co,

const char *pathname,

const char *cpathname)

{

PyObject *m = NULL;

PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL, *external= NULL;

nameobj = PyUnicode_FromString(name);

if (nameobj == NULL)

return NULL;

if (cpathname != NULL) {

cpathobj = PyUnicode_DecodeFSDefault(cpathname);

if (cpathobj == NULL)

goto error;

}

else

cpathobj = NULL;

if (pathname != NULL) {

pathobj = PyUnicode_DecodeFSDefault(pathname);

if (pathobj == NULL)

goto error;

}

else if (cpathobj != NULL) {

PyInterpreterState *interp = _PyInterpreterState_GET();

_Py_IDENTIFIER(_get_sourcefile);

if (interp == NULL) {

Py_FatalError("no current interpreter");

}

external= PyObject_GetAttrString(interp->importlib,

"_bootstrap_external");

if (external != NULL) {

pathobj = _PyObject_CallMethodIdOneArg(

external, &PyId__get_sourcefile, cpathobj);