/* Support for dynamic loading of extension modules */

#include "Python.h"

/* ./configure sets HAVE_DYNAMIC_LOADING if dynamic loading of modules is

   supported on this platform. configure will then compile and link in one

   of the dynload_*.c files, as appropriate. We will call a function in

   those modules to get a function pointer to the module's init function.

*/

#ifdef HAVE_DYNAMIC_LOADING

#include "importdl.h"

#ifdef MS_WINDOWS

extern dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix,

                                                     const char *shortname,

                                                     PyObject *pathname,

                                                     FILE *fp);

#else

extern dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix,

                                              const char *shortname,

                                              const char *pathname, FILE *fp);

#endif

static const char * const ascii_only_prefix = "PyInit";

static const char * const nonascii_prefix = "PyInitU";

/* 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 char **hook_prefix) {

    PyObject *tmp;

    PyObject *encoded = NULL;

    PyObject *modname = NULL;

    Py_ssize_t name_len, lastdot;

    _Py_IDENTIFIER(replace);

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

    name_len = PyUnicode_GetLength(name);

    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_prefix = ascii_only_prefix;

    } else {

        if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) {

            PyErr_Clear();

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

            if (encoded == NULL) {

                goto error;

            }

            *hook_prefix = nonascii_prefix;

        } else {

            goto error;

        }

    }

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

    modname = _PyObject_CallMethodId(encoded, &PyId_replace, "cc", '-', '_');

    if (modname == NULL)

        goto error;

    Py_DECREF(name);

    Py_DECREF(encoded);

    return modname;

error:

    Py_DECREF(name);

    Py_XDECREF(encoded);

    return NULL;

}

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;

    }

    if (!PyUnicode_Check(name_unicode)) {

        PyErr_SetString(PyExc_TypeError,

                        "spec.name must be a string");

        goto error;

    }

    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;

    if (PySys_Audit("import", "OOOOO", name_unicode, path,

                    Py_None, Py_None, Py_None) < 0) {

        return NULL;

    }

#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);

    PyObject *modules = PyImport_GetModuleDict();

    if (_PyImport_FixupExtensionObject(m, name_unicode, path, modules) < 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;

}

#endif /* HAVE_DYNAMIC_LOADING */