#include "Python.h"

#include "pycore_audit.h" // _PySys_Audit()

#include "pycore_ceval.h"

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION()

#include "pycore_dict.h" // _PyDict_Contains_KnownHash()

#include "pycore_hashtable.h" // _Py_hashtable_new_full()

#include "pycore_import.h" // _PyImport_BootstrapImp()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_interp.h" // struct _import_runtime_state

#include "pycore_interpframe.h"

#include "pycore_lazyimportobject.h"

#include "pycore_long.h" // _PyLong_GetZero

#include "pycore_magic_number.h" // PYC_MAGIC_NUMBER_TOKEN

#include "pycore_moduleobject.h" // _PyModule_GetDef()

#include "pycore_namespace.h" // _PyNamespace_Type

#include "pycore_object.h" // _Py_SetImmortal()

#include "pycore_pyatomic_ft_wrappers.h"

#include "pycore_pyerrors.h" // _PyErr_SetString()

#include "pycore_pyhash.h" // _Py_KeyedHash()

#include "pycore_pylifecycle.h"

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

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

#include "pycore_setobject.h" // _PySet_NextEntry()

#include "pycore_sysmodule.h" // _PySys_ClearAttrString()

#include "pycore_time.h" // _PyTime_AsMicroseconds()

#include "pycore_traceback.h"

#include "pycore_unicodeobject.h" // _PyUnicode_AsUTF8NoNUL()

#include "pycore_weakref.h" // _PyWeakref_GET_REF()

#include "marshal.h" // PyMarshal_ReadObjectFromString()

#include "pycore_importdl.h" // _PyImport_DynLoadFiletab

#include "pydtrace.h" // PyDTrace_IMPORT_FIND_LOAD_START_ENABLED()

#include <stdbool.h> // bool

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#include "clinic/import.c.h"

#ifndef NDEBUG

static bool

is_interpreter_isolated(PyInterpreterState *interp)

{

return !_Py_IsMainInterpreter(interp)

&& !(interp->feature_flags & Py_RTFLAGS_USE_MAIN_OBMALLOC)

&& interp->ceval.own_gil;

}

extern struct _inittab _PyImport_Inittab[];

struct _inittab *PyImport_Inittab = _PyImport_Inittab;

static struct _inittab *inittab_copy = NULL;

#define INITTAB _PyRuntime.imports.inittab

#define LAST_MODULE_INDEX _PyRuntime.imports.last_module_index

#define EXTENSIONS _PyRuntime.imports.extensions

#define MODULES(interp) \

(interp)->imports.modules

#define MODULES_BY_INDEX(interp) \

(interp)->imports.modules_by_index

#define LAZY_MODULES(interp) \

(interp)->imports.lazy_modules

#define LAZY_PENDING_SUBMODULES(interp) \

(interp)->imports.lazy_pending_submodules

#define IMPORTLIB(interp) \

(interp)->imports.importlib

#define OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK(interp) \

(interp)->imports.override_multi_interp_extensions_check

#define OVERRIDE_FROZEN_MODULES(interp) \

(interp)->imports.override_frozen_modules

#ifdef HAVE_DLOPEN

# define DLOPENFLAGS(interp) \

(interp)->imports.dlopenflags

#define IMPORT_FUNC(interp) \

(interp)->imports.import_func

#define LAZY_IMPORT_FUNC(interp) \

(interp)->imports.lazy_import_func

#define IMPORT_LOCK(interp) \

(interp)->imports.lock

#define FIND_AND_LOAD(interp) \

(interp)->imports.find_and_load

#define LAZY_IMPORTS_MODE(interp) \

(interp)->imports.lazy_imports_mode

#define LAZY_IMPORTS_FILTER(interp) \

(interp)->imports.lazy_imports_filter

#ifdef Py_GIL_DISABLED

#define LAZY_IMPORTS_LOCK(interp) PyMutex_Lock(&(interp)->imports.lazy_mutex)

#define LAZY_IMPORTS_UNLOCK(interp) PyMutex_Unlock(&(interp)->imports.lazy_mutex)

#define LAZY_IMPORTS_LOCK(interp)

#define LAZY_IMPORTS_UNLOCK(interp)

#define _IMPORT_TIME_HEADER(interp) \

do { \

if (FIND_AND_LOAD((interp)).header) { \

fputs("import time: self [us] | cumulative | imported package\n", \

stderr); \

FIND_AND_LOAD((interp)).header = 0; \

} \

} while (0)

_PyImport_AcquireLock(PyInterpreterState *interp)

{

_PyRecursiveMutex_Lock(&IMPORT_LOCK(interp));

}

_PyImport_ReleaseLock(PyInterpreterState *interp)

{

_PyRecursiveMutex_Unlock(&IMPORT_LOCK(interp));

}

_PyImport_ReInitLock(PyInterpreterState *interp)

{

// gh-126688: Thread id may change after fork() on some operating systems.

IMPORT_LOCK(interp).thread = PyThread_get_thread_ident_ex();

}

PyObject *

_PyImport_InitModules(PyInterpreterState *interp)

{

assert(MODULES(interp) == NULL);

MODULES(interp) = PyDict_New();

if (MODULES(interp) == NULL) {

return NULL;

}

return MODULES(interp);

}

PyObject *

_PyImport_GetModules(PyInterpreterState *interp)

{

return MODULES(interp);

}

PyObject *

_PyImport_GetModulesRef(PyInterpreterState *interp)

{

_PyImport_AcquireLock(interp);

PyObject *modules = MODULES(interp);

if (modules == NULL) {

/* The interpreter hasn't been initialized yet. */

modules = Py_None;

}

Py_INCREF(modules);

_PyImport_ReleaseLock(interp);

return modules;

}

_PyImport_ClearModules(PyInterpreterState *interp)

{

Py_SETREF(MODULES(interp), NULL);

}

static inline PyObject *

get_modules_dict(PyThreadState *tstate, bool fatal)

{

/* Technically, it would make sense to incref the dict,

PyObject *modules = MODULES(tstate->interp);

if (modules == NULL) {

if (fatal) {

Py_FatalError("interpreter has no modules dictionary");

}

_PyErr_SetString(tstate, PyExc_RuntimeError,

"unable to get sys.modules");

return NULL;

}

return modules;

}

PyObject *

PyImport_GetModuleDict(void)

{

PyThreadState *tstate = _PyThreadState_GET();

return get_modules_dict(tstate, true);

}

_PyImport_SetModule(PyObject *name, PyObject *m)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *modules = get_modules_dict(tstate, true);

return PyObject_SetItem(modules, name, m);

}

_PyImport_SetModuleString(const char *name, PyObject *m)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *modules = get_modules_dict(tstate, true);

return PyMapping_SetItemString(modules, name, m);

}

static PyObject *

import_get_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = get_modules_dict(tstate, false);

if (modules == NULL) {

return NULL;

}

PyObject *m;

Py_INCREF(modules);

(void)PyMapping_GetOptionalItem(modules, name, &m);

Py_DECREF(modules);

return m;

}

PyObject *

_PyImport_InitLazyModules(PyInterpreterState *interp)

{

assert(LAZY_MODULES(interp) == NULL &&

LAZY_PENDING_SUBMODULES(interp) == NULL);

LAZY_PENDING_SUBMODULES(interp) = PyDict_New();

LAZY_MODULES(interp) = PySet_New(0);

return LAZY_MODULES(interp);

}

_PyImport_ClearLazyModules(PyInterpreterState *interp)

{

Py_CLEAR(LAZY_MODULES(interp));

Py_CLEAR(LAZY_PENDING_SUBMODULES(interp));

}

static int

import_ensure_initialized(PyInterpreterState *interp, PyObject *mod, PyObject *name)

{

PyObject *spec;

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

int rc = PyObject_GetOptionalAttr(mod, &_Py_ID(__spec__), &spec);

if (rc > 0) {

rc = _PyModuleSpec_IsInitializing(spec);

Py_DECREF(spec);

}

if (rc == 0) {

goto done;

}

else if (rc < 0) {

return rc;

}

/* Wait until module is done importing. */

PyObject *value = PyObject_CallMethodOneArg(

IMPORTLIB(interp), &_Py_ID(_lock_unlock_module), name);

if (value == NULL) {

return -1;

}

Py_DECREF(value);

done:

/* When -X importtime=2, print an import time entry even if an

if (_PyInterpreterState_GetConfig(interp)->import_time == 2) {

_IMPORT_TIME_HEADER(interp);

#define import_level FIND_AND_LOAD(interp).import_level

fprintf(stderr, "import time: cached | cached | %*s\n",

import_level*2, PyUnicode_AsUTF8(name));

#undef import_level

}

return 0;

}

static void remove_importlib_frames(PyThreadState *tstate);

PyObject *

PyImport_GetModule(PyObject *name)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *mod;

mod = import_get_module(tstate, name);

if (mod != NULL && mod != Py_None) {

if (import_ensure_initialized(tstate->interp, mod, name) < 0) {

goto error;

}

/* Verify the module is still in sys.modules. Another thread may have

PyObject *mod_check = import_get_module(tstate, name);

if (mod_check != mod) {

Py_XDECREF(mod_check);

if (_PyErr_Occurred(tstate)) {

goto error;

}

/* The module was removed or replaced. Return NULL to report

Py_DECREF(mod);

return NULL;

}

Py_DECREF(mod_check);

}

return mod;

error:

Py_DECREF(mod);

remove_importlib_frames(tstate);

return NULL;

}

static PyObject *

import_add_module_lock_held(PyObject *modules, PyObject *name)

{

PyObject *m;

if (PyMapping_GetOptionalItem(modules, name, &m) < 0) {

return NULL;

}

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

return m;

}

Py_XDECREF(m);

m = PyModule_NewObject(name);

if (m == NULL)

return NULL;

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

Py_DECREF(m);

return NULL;

}

return m;

}

static PyObject *

import_add_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = get_modules_dict(tstate, false);

if (modules == NULL) {

return NULL;

}

PyObject *m;

Py_BEGIN_CRITICAL_SECTION(modules);

m = import_add_module_lock_held(modules, name);

Py_END_CRITICAL_SECTION();

return m;

}

PyObject *

PyImport_AddModuleRef(const char *name)

{

PyObject *name_obj = PyUnicode_FromString(name);

if (name_obj == NULL) {

return NULL;

}

PyThreadState *tstate = _PyThreadState_GET();

PyObject *module = import_add_module(tstate, name_obj);

Py_DECREF(name_obj);

return module;

}

PyObject *

PyImport_AddModuleObject(PyObject *name)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *mod = import_add_module(tstate, name);

if (!mod) {

return NULL;

}

// gh-86160: PyImport_AddModuleObject() returns a borrowed reference.

// Create a weak reference to produce a borrowed reference, since it can

// become NULL. sys.modules type can be different than dict and it is not

// guaranteed that it keeps a strong reference to the module. It can be a

// custom mapping with __getitem__() which returns a new object or removes

// returned object, or __setitem__ which does nothing. There is so much

// unknown. With weakref we can be sure that we get either a reference to

// live object or NULL.

//

// Use PyImport_AddModuleRef() to avoid these issues.

PyObject *ref = PyWeakref_NewRef(mod, NULL);

Py_DECREF(mod);

if (ref == NULL) {

return NULL;

}

mod = _PyWeakref_GET_REF(ref);

Py_DECREF(ref);

Py_XDECREF(mod);

if (mod == NULL && !PyErr_Occurred()) {

PyErr_SetString(PyExc_RuntimeError,

"sys.modules does not hold a strong reference "

"to the module");

}

return mod; /* borrowed reference */

}

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 *exc = _PyErr_GetRaisedException(tstate);

PyObject *modules = get_modules_dict(tstate, true);

if (PyDict_CheckExact(modules)) {

// Error is reported to the caller

(void)PyDict_Pop(modules, name, NULL);

}

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

if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

_PyErr_ChainExceptions1(exc);

}

_PyImport_GetNextModuleIndex(void)

{

return _Py_atomic_add_ssize(&LAST_MODULE_INDEX, 1) + 1;

}

#ifndef NDEBUG

struct extensions_cache_value;

static struct extensions_cache_value * _find_cached_def(PyModuleDef *);

static Py_ssize_t _get_cached_module_index(struct extensions_cache_value *);

static Py_ssize_t

_get_module_index_from_def(PyModuleDef *def)

{

Py_ssize_t index = def->m_base.m_index;

#ifndef NDEBUG

struct extensions_cache_value *cached = _find_cached_def(def);

assert(cached == NULL || index == _get_cached_module_index(cached));

return index;

}

static void

_set_module_index(PyModuleDef *def, Py_ssize_t index)

{

assert(index > 0);

if (index == def->m_base.m_index) {

/* There's nothing to do. */

}

else if (def->m_base.m_index == 0) {

/* It should have been initialized by PyModuleDef_Init().

assert(def->m_base.m_index != 0);

def->m_base.m_index = index;

}

else {

/* It was already set for a different module.

assert(def->m_base.m_index > 0);

def->m_base.m_index = index;

}

}

static const char *

_modules_by_index_check(PyInterpreterState *interp, Py_ssize_t index)

{

if (index <= 0) {

return "invalid module index";

}

if (MODULES_BY_INDEX(interp) == NULL) {

return "Interpreters module-list not accessible.";

}

if (index >= PyList_GET_SIZE(MODULES_BY_INDEX(interp))) {

return "Module index out of bounds.";

}

return NULL;

}

static PyObject *

_modules_by_index_get(PyInterpreterState *interp, Py_ssize_t index)

{

if (_modules_by_index_check(interp, index) != NULL) {

return NULL;

}

PyObject *res = PyList_GET_ITEM(MODULES_BY_INDEX(interp), index);

return res==Py_None ? NULL : res;

}

static int

_modules_by_index_set(PyInterpreterState *interp,

Py_ssize_t index, PyObject *module)

{

assert(index > 0);

if (MODULES_BY_INDEX(interp) == NULL) {

MODULES_BY_INDEX(interp) = PyList_New(0);

if (MODULES_BY_INDEX(interp) == NULL) {

return -1;

}

}

while (PyList_GET_SIZE(MODULES_BY_INDEX(interp)) <= index) {

if (PyList_Append(MODULES_BY_INDEX(interp), Py_None) < 0) {

return -1;

}

}

return PyList_SetItem(MODULES_BY_INDEX(interp), index, Py_NewRef(module));

}

static int

_modules_by_index_clear_one(PyInterpreterState *interp, Py_ssize_t index)

{

const char *err = _modules_by_index_check(interp, index);

if (err != NULL) {

Py_FatalError(err);

return -1;

}

return PyList_SetItem(MODULES_BY_INDEX(interp), index, Py_NewRef(Py_None));

}

PyState_FindModule(PyModuleDef* module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (module->m_slots) {

return NULL;

}

Py_ssize_t index = _get_module_index_from_def(module);

return _modules_by_index_get(interp, index);

}

_PyState_AddModule(PyThreadState *tstate, PyObject* module, PyModuleDef* def)

{

if (!def) {

assert(_PyErr_Occurred(tstate));

return -1;

}

if (def->m_slots) {

_PyErr_SetString(tstate,

PyExc_SystemError,

"PyState_AddModule called on module with slots");

return -1;

}

assert(def->m_slots == NULL);

Py_ssize_t index = _get_module_index_from_def(def);

return _modules_by_index_set(tstate->interp, index, module);

}

PyState_AddModule(PyObject* module, PyModuleDef* def)

{

if (!def) {

Py_FatalError("module definition is NULL");

return -1;

}

PyThreadState *tstate = _PyThreadState_GET();

if (def->m_slots) {

_PyErr_SetString(tstate,

PyExc_SystemError,

"PyState_AddModule called on module with slots");

return -1;

}

PyInterpreterState *interp = tstate->interp;

Py_ssize_t index = _get_module_index_from_def(def);

if (MODULES_BY_INDEX(interp) &&

index < PyList_GET_SIZE(MODULES_BY_INDEX(interp)) &&

module == PyList_GET_ITEM(MODULES_BY_INDEX(interp), index))

{

_Py_FatalErrorFormat(__func__, "module %p already added", module);

return -1;

}

assert(def->m_slots == NULL);

return _modules_by_index_set(interp, index, module);

}

PyState_RemoveModule(PyModuleDef* def)

{

PyThreadState *tstate = _PyThreadState_GET();

if (def->m_slots) {

_PyErr_SetString(tstate,

PyExc_SystemError,

"PyState_RemoveModule called on module with slots");

return -1;

}

Py_ssize_t index = _get_module_index_from_def(def);

return _modules_by_index_clear_one(tstate->interp, index);

}

_PyImport_ClearModulesByIndex(PyInterpreterState *interp)

{

if (!MODULES_BY_INDEX(interp)) {

return;

}

Py_ssize_t i;

for (i = 0; i < PyList_GET_SIZE(MODULES_BY_INDEX(interp)); i++) {

PyObject *m = PyList_GET_ITEM(MODULES_BY_INDEX(interp), i);

if (PyModule_Check(m)) {

/* cleanup the saved copy of module dicts */

PyModuleDef *md = PyModule_GetDef(m);

if (md) {

// XXX Do this more carefully. The dict might be owned

// by another interpreter.

Py_CLEAR(md->m_base.m_copy);

}

}

}

/* Setting modules_by_index to NULL could be dangerous, so we

if (PyList_SetSlice(MODULES_BY_INDEX(interp),

0, PyList_GET_SIZE(MODULES_BY_INDEX(interp)),

NULL)) {

PyErr_FormatUnraisable("Exception ignored while "

"clearing interpreters module list");

}

}

static _Py_thread_local const char *pkgcontext = NULL;

# define PKGCONTEXT pkgcontext

const char *

_PyImport_ResolveNameWithPackageContext(const char *name)

{

if (PKGCONTEXT != NULL) {

const char *p = strrchr(PKGCONTEXT, '.');

if (p != NULL && strcmp(name, p+1) == 0) {

name = PKGCONTEXT;

PKGCONTEXT = NULL;

}

}

return name;

}

const char *

_PyImport_SwapPackageContext(const char *newcontext)

{

const char *oldcontext = PKGCONTEXT;

PKGCONTEXT = newcontext;

return oldcontext;

}

#ifdef HAVE_DLOPEN

_PyImport_GetDLOpenFlags(PyInterpreterState *interp)

{

return DLOPENFLAGS(interp);

}

_PyImport_SetDLOpenFlags(PyInterpreterState *interp, int new_val)

{

DLOPENFLAGS(interp) = new_val;

}

#endif // HAVE_DLOPEN

static int

exec_builtin_or_dynamic(PyObject *mod) {

void *state;

if (!PyModule_Check(mod)) {

return 0;

}

state = PyModule_GetState(mod);

if (state) {

/* Already initialized; skip reload */

return 0;

}

return PyModule_Exec(mod);

}

static int clear_singlephase_extension(PyInterpreterState *interp,

PyObject *name, PyObject *filename);

_PyImport_ClearExtension(PyObject *name, PyObject *filename)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

/* Clearing a module's C globals is up to the module. */

if (clear_singlephase_extension(interp, name, filename) < 0) {

return -1;

}

// In the future we'll probably also make sure the extension's

// file handle (and DL handle) is closed (requires saving it).

return 0;

}