/* Support for dynamic loading of extension modules */

#include "Python.h"

#include "pycore_call.h" // _PyObject_CallMethod()

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

#include "pycore_importdl.h"

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

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

#include "pycore_runtime.h" // _Py_ID()

/***********************************/

/* module info to use when loading */

/***********************************/

static const struct hook_prefixes ascii_only_prefixes = {

"PyInit", "PyModExport"};

static const struct hook_prefixes nonascii_prefixes = {

"PyInitU", "PyModExportU"};

/* Get the variable part of a module's export symbol name.

* Returns a bytes instance. For non-ASCII-named modules, the name is

* encoded as per PEP 489.

* The hook_prefix pointer is set to either ascii_only_prefix or

* nonascii_prefix, as appropriate.

*/

static PyObject *

get_encoded_name(PyObject *name, const struct hook_prefixes **hook_prefixes) {

PyObject *tmp;

PyObject *encoded = NULL;

PyObject *modname = NULL;

Py_ssize_t name_len, lastdot;

/* Get the short name (substring after last dot) */

name_len = PyUnicode_GetLength(name);

if (name_len < 0) {

return NULL;

}

lastdot = PyUnicode_FindChar(name, '.', 0, name_len, -1);

if (lastdot < -1) {

return NULL;

} else if (lastdot >= 0) {

tmp = PyUnicode_Substring(name, lastdot + 1, name_len);

if (tmp == NULL)

return NULL;

name = tmp;

/* "name" now holds a new reference to the substring */

} else {

Py_INCREF(name);

}

/* Encode to ASCII or Punycode, as needed */

encoded = PyUnicode_AsEncodedString(name, "ascii", NULL);

if (encoded != NULL) {

*hook_prefixes = &ascii_only_prefixes;

} else {

if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) {

PyErr_Clear();

encoded = PyUnicode_AsEncodedString(name, "punycode", NULL);

if (encoded == NULL) {

goto error;

}

*hook_prefixes = &nonascii_prefixes;

} else {

goto error;

}

}

/* Replace '-' by '_' */

modname = _PyObject_CallMethod(encoded, &_Py_ID(replace), "cc", '-', '_');

if (modname == NULL)

goto error;

Py_DECREF(name);

Py_DECREF(encoded);

return modname;

error:

Py_DECREF(name);

Py_XDECREF(encoded);

return NULL;

}

void

_Py_ext_module_loader_info_clear(struct _Py_ext_module_loader_info *info)

{

Py_CLEAR(info->filename);

#ifndef MS_WINDOWS

Py_CLEAR(info->filename_encoded);

#endif

Py_CLEAR(info->name);

Py_CLEAR(info->name_encoded);

}

int

_Py_ext_module_loader_info_init(struct _Py_ext_module_loader_info *p_info,

PyObject *name, PyObject *filename,

_Py_ext_module_origin origin)

{

struct _Py_ext_module_loader_info info = {

.origin=origin,

};

assert(name != NULL);

if (!PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"module name must be a string");

_Py_ext_module_loader_info_clear(&info);

return -1;

}

assert(PyUnicode_GetLength(name) > 0);

info.name = Py_NewRef(name);

info.name_encoded = get_encoded_name(info.name, &info.hook_prefixes);

if (info.name_encoded == NULL) {

_Py_ext_module_loader_info_clear(&info);

return -1;

}

info.newcontext = PyUnicode_AsUTF8(info.name);

if (info.newcontext == NULL) {

_Py_ext_module_loader_info_clear(&info);

return -1;

}

if (filename != NULL) {

if (!PyUnicode_Check(filename)) {

PyErr_SetString(PyExc_TypeError,

"module filename must be a string");

_Py_ext_module_loader_info_clear(&info);

return -1;

}

info.filename = Py_NewRef(filename);

#ifndef MS_WINDOWS

info.filename_encoded = PyUnicode_EncodeFSDefault(info.filename);

if (info.filename_encoded == NULL) {

_Py_ext_module_loader_info_clear(&info);

return -1;

}

#endif

info.path = info.filename;

}

else {

info.path = info.name;

}

*p_info = info;

return 0;

}

int

_Py_ext_module_loader_info_init_for_builtin(

struct _Py_ext_module_loader_info *info,

PyObject *name)

{

assert(PyUnicode_Check(name));

assert(PyUnicode_GetLength(name) > 0);

PyObject *name_encoded = PyUnicode_AsEncodedString(name, "ascii", NULL);

if (name_encoded == NULL) {

return -1;

}

*info = (struct _Py_ext_module_loader_info){

.name=Py_NewRef(name),

.name_encoded=name_encoded,

/* We won't need filename. */

.path=name,

.origin=_Py_ext_module_origin_BUILTIN,

.hook_prefixes=&ascii_only_prefixes,

.newcontext=NULL,

};

return 0;

}

int

_Py_ext_module_loader_info_init_for_core(

struct _Py_ext_module_loader_info *info,

PyObject *name)

{

if (_Py_ext_module_loader_info_init_for_builtin(info, name) < 0) {

return -1;

}

info->origin = _Py_ext_module_origin_CORE;

return 0;

}

#ifdef HAVE_DYNAMIC_LOADING

int

_Py_ext_module_loader_info_init_from_spec(

struct _Py_ext_module_loader_info *p_info,

PyObject *spec)

{

PyObject *name = PyObject_GetAttrString(spec, "name");

if (name == NULL) {

return -1;

}

PyObject *filename = PyObject_GetAttrString(spec, "origin");

if (filename == NULL) {

Py_DECREF(name);

return -1;

}

/* We could also accommodate builtin modules here without much trouble. */

_Py_ext_module_origin origin = _Py_ext_module_origin_DYNAMIC;

int err = _Py_ext_module_loader_info_init(p_info, name, filename, origin);

Py_DECREF(name);

Py_DECREF(filename);

return err;

}

#endif /* HAVE_DYNAMIC_LOADING */

/********************************/

/* module init function results */

/********************************/

void

_Py_ext_module_loader_result_clear(struct _Py_ext_module_loader_result *res)

{

/* Instead, the caller should have called

* _Py_ext_module_loader_result_apply_error(). */

assert(res->err == NULL);

*res = (struct _Py_ext_module_loader_result){0};

}

static void

_Py_ext_module_loader_result_set_error(

struct _Py_ext_module_loader_result *res,

enum _Py_ext_module_loader_result_error_kind kind)

{

#ifndef NDEBUG

switch (kind) {

case _Py_ext_module_loader_result_EXCEPTION: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_UNREPORTED_EXC:

assert(PyErr_Occurred());

break;

case _Py_ext_module_loader_result_ERR_MISSING: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_UNINITIALIZED: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NOT_MODULE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_MISSING_DEF:

assert(!PyErr_Occurred());

break;

default:

/* We added a new error kind but forgot to add it to this switch. */

assert(0);

}

#endif

assert(res->err == NULL && res->_err.exc == NULL);

res->err = &res->_err;

*res->err = (struct _Py_ext_module_loader_result_error){

.kind=kind,

.exc=PyErr_GetRaisedException(),

};

/* For some kinds, we also set/check res->kind. */

switch (kind) {

case _Py_ext_module_loader_result_ERR_UNINITIALIZED:

assert(res->kind == _Py_ext_module_kind_UNKNOWN);

res->kind = _Py_ext_module_kind_INVALID;

break;

/* None of the rest affect the result kind. */

case _Py_ext_module_loader_result_EXCEPTION: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_MISSING: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_UNREPORTED_EXC: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NOT_MODULE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_MISSING_DEF:

break;

default:

/* We added a new error kind but forgot to add it to this switch. */

assert(0);

}

}

void

_Py_ext_module_loader_result_apply_error(

struct _Py_ext_module_loader_result *res,

const char *name)

{

assert(!PyErr_Occurred());

assert(res->err != NULL && res->err == &res->_err);

struct _Py_ext_module_loader_result_error err = *res->err;

res->err = NULL;

/* We're otherwise done with the result at this point. */

_Py_ext_module_loader_result_clear(res);

#ifndef NDEBUG

switch (err.kind) {

case _Py_ext_module_loader_result_EXCEPTION: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_UNREPORTED_EXC:

assert(err.exc != NULL);

break;

case _Py_ext_module_loader_result_ERR_MISSING: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_UNINITIALIZED: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_NOT_MODULE: _Py_FALLTHROUGH;

case _Py_ext_module_loader_result_ERR_MISSING_DEF:

assert(err.exc == NULL);

break;

default:

/* We added a new error kind but forgot to add it to this switch. */

assert(0);

}

#endif

const char *msg = NULL;

switch (err.kind) {

case _Py_ext_module_loader_result_EXCEPTION:

break;

case _Py_ext_module_loader_result_ERR_MISSING:

msg = "initialization of %s failed without raising an exception";

break;

case _Py_ext_module_loader_result_ERR_UNREPORTED_EXC:

msg = "initialization of %s raised unreported exception";

break;

case _Py_ext_module_loader_result_ERR_UNINITIALIZED:

msg = "init function of %s returned uninitialized object";

break;

case _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE:

msg = "initialization of %s did not return PyModuleDef";

break;

case _Py_ext_module_loader_result_ERR_NOT_MODULE:

msg = "initialization of %s did not return an extension module";

break;

case _Py_ext_module_loader_result_ERR_MISSING_DEF:

msg = "initialization of %s did not return a valid extension module";

break;

default:

/* We added a new error kind but forgot to add it to this switch. */

assert(0);

PyErr_Format(PyExc_SystemError,

"loading %s failed due to init function", name);

return;

}

if (err.exc != NULL) {

PyErr_SetRaisedException(err.exc);

err.exc = NULL; /* PyErr_SetRaisedException() stole our reference. */

if (msg != NULL) {

_PyErr_FormatFromCause(PyExc_SystemError, msg, name);

}

}

else {

assert(msg != NULL);

PyErr_Format(PyExc_SystemError, msg, name);

}

}

/********************************************/

/* getting/running the module init function */

/********************************************/

#ifdef HAVE_DYNAMIC_LOADING

static dl_funcptr

findfuncptr(const char *prefix, const char *name_buf,

struct _Py_ext_module_loader_info *info,

FILE *fp)

{

#ifdef MS_WINDOWS

return _PyImport_FindSharedFuncptrWindows(

prefix, name_buf, info->filename, fp);

#else

const char *path_buf = PyBytes_AS_STRING(info->filename_encoded);

return _PyImport_FindSharedFuncptr(

prefix, name_buf, path_buf, fp);

#endif

}

int

_PyImport_GetModuleExportHooks(

struct _Py_ext_module_loader_info *info,

FILE *fp,

PyModInitFunction *modinit,

PyModExportFunction *modexport)

{

*modinit = NULL;

*modexport = NULL;

const char *name_buf = PyBytes_AS_STRING(info->name_encoded);

dl_funcptr exportfunc;

exportfunc = findfuncptr(

info->hook_prefixes->export_prefix,

name_buf, info, fp);

if (exportfunc) {

*modexport = (PyModExportFunction)exportfunc;

return 2;

}

if (PyErr_Occurred()) {

return -1;

}

exportfunc = findfuncptr(

info->hook_prefixes->init_prefix,

name_buf, info, fp);

if (exportfunc) {

*modinit = (PyModInitFunction)exportfunc;

return 1;

}

if (!PyErr_Occurred()) {

PyObject *msg;

msg = PyUnicode_FromFormat(

"dynamic module does not define "

"module export function (%s_%s or %s_%s)",

info->hook_prefixes->export_prefix, name_buf,

info->hook_prefixes->init_prefix, name_buf);

if (msg != NULL) {

PyErr_SetImportError(msg, info->name, info->filename);

Py_DECREF(msg);

}

}

return -1;

}

#endif /* HAVE_DYNAMIC_LOADING */

int

_PyImport_RunModInitFunc(PyModInitFunction p0,

struct _Py_ext_module_loader_info *info,

struct _Py_ext_module_loader_result *p_res)

{

struct _Py_ext_module_loader_result res = {

.kind=_Py_ext_module_kind_UNKNOWN,

};

/* Call the module init function. */

/* Package context is needed for single-phase init */

const char *oldcontext = _PyImport_SwapPackageContext(info->newcontext);

PyObject *m = p0();

_PyImport_SwapPackageContext(oldcontext);

/* Validate the result (and populate "res". */

if (m == NULL) {

/* The init func for multi-phase init modules is expected

* to return a PyModuleDef after calling PyModuleDef_Init().

* That function never raises an exception nor returns NULL,

* so at this point it must be a single-phase init modules. */

res.kind = _Py_ext_module_kind_SINGLEPHASE;

if (PyErr_Occurred()) {

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_EXCEPTION);

}

else {

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_MISSING);

}

goto error;

} else if (PyErr_Occurred()) {

/* Likewise, we infer that this is a single-phase init module. */

res.kind = _Py_ext_module_kind_SINGLEPHASE;

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_UNREPORTED_EXC);

/* We would probably be correct to decref m here,

* but we weren't doing so before,

* so we stick with doing nothing. */

m = NULL;

goto error;

}

if (Py_IS_TYPE(m, NULL)) {

/* This can happen when a PyModuleDef is returned without calling

* PyModuleDef_Init on it

*/

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_UNINITIALIZED);

/* Likewise, decref'ing here makes sense. However, the original

* code has a note about "prevent segfault in DECREF",

* so we play it safe and leave it alone. */

m = NULL; /* prevent segfault in DECREF */

goto error;

}

if (PyObject_TypeCheck(m, &PyModuleDef_Type)) {

/* multi-phase init */

res.kind = _Py_ext_module_kind_MULTIPHASE;

res.def = (PyModuleDef *)m;

/* Run PyModule_FromDefAndSpec() to finish loading the module. */

}

else if (info->hook_prefixes == &nonascii_prefixes) {

/* Non-ASCII is only supported for multi-phase init. */

res.kind = _Py_ext_module_kind_MULTIPHASE;

/* Don't allow legacy init for non-ASCII module names. */

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_NONASCII_NOT_MULTIPHASE);

goto error;

}

else {

/* single-phase init (legacy) */

res.kind = _Py_ext_module_kind_SINGLEPHASE;

res.module = m;

if (!PyModule_Check(m)) {

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_NOT_MODULE);

goto error;

}

res.def = _PyModule_GetDefOrNull(m);

if (res.def == NULL) {

PyErr_Clear();

_Py_ext_module_loader_result_set_error(

&res, _Py_ext_module_loader_result_ERR_MISSING_DEF);

goto error;

}

}

assert(!PyErr_Occurred());

assert(res.err == NULL);

*p_res = res;

return 0;

error:

assert(!PyErr_Occurred());

assert(res.err != NULL);

Py_CLEAR(res.module);

res.def = NULL;

*p_res = res;

p_res->err = &p_res->_err;

return -1;

}