#include "Python.h"

#include "code.h"

#include "frameobject.h" // PyFrame_GetBack()

#include "pycore_ceval.h"

#include "pycore_initconfig.h"

#include "pycore_long.h" // _PY_LONG_MAX_STR_DIGITS_THRESHOLD

#include "pycore_object.h"

#include "pycore_pathconfig.h"

#include "pycore_pyerrors.h"

#include "pycore_pylifecycle.h"

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

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

#include "pycore_tupleobject.h"

#include "pydtrace.h"

#include "osdefs.h" // DELIM

#include <locale.h>

#ifdef MS_WINDOWS

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif /* MS_WINDOWS */

#ifdef MS_COREDLL

extern void *PyWin_DLLhModule;

extern const char *PyWin_DLLVersionString;

#include "clinic/sysmodule.c.h"

_Py_IDENTIFIER(_);

_Py_IDENTIFIER(__sizeof__);

_Py_IDENTIFIER(_xoptions);

_Py_IDENTIFIER(buffer);

_Py_IDENTIFIER(builtins);

_Py_IDENTIFIER(encoding);

_Py_IDENTIFIER(path);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

_Py_IDENTIFIER(warnoptions);

_Py_IDENTIFIER(write);

static PyObject *

sys_get_object_id(PyThreadState *tstate, _Py_Identifier *key)

{

PyObject *sd = tstate->interp->sysdict;

if (sd == NULL) {

return NULL;

}

return _PyDict_GetItemId(sd, key);

}

PyObject *

_PySys_GetObjectId(_Py_Identifier *key)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_get_object_id(tstate, key);

}

PyObject *

PySys_GetObject(const char *name)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *sd = tstate->interp->sysdict;

if (sd == NULL) {

return NULL;

}

return PyDict_GetItemString(sd, name);

}

static int

sys_set_object_id(PyThreadState *tstate, _Py_Identifier *key, PyObject *v)

{

PyObject *sd = tstate->interp->sysdict;

if (v == NULL) {

if (_PyDict_GetItemId(sd, key) == NULL) {

return 0;

}

else {

return _PyDict_DelItemId(sd, key);

}

}

else {

return _PyDict_SetItemId(sd, key, v);

}

}

_PySys_SetObjectId(_Py_Identifier *key, PyObject *v)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_set_object_id(tstate, key, v);

}

static int

sys_set_object(PyThreadState *tstate, const char *name, PyObject *v)

{

PyObject *sd = tstate->interp->sysdict;

if (v == NULL) {

if (PyDict_GetItemString(sd, name) == NULL) {

return 0;

}

else {

return PyDict_DelItemString(sd, name);

}

}

else {

return PyDict_SetItemString(sd, name, v);

}

}

PySys_SetObject(const char *name, PyObject *v)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_set_object(tstate, name, v);

}

static int

should_audit(PyInterpreterState *is)

{

/* tstate->interp cannot be NULL, but test it just in case

assert(is != NULL);

if (!is) {

return 0;

}

return (is->runtime->audit_hook_head

|| is->audit_hooks

|| PyDTrace_AUDIT_ENABLED());

}

static int

sys_audit_tstate(PyThreadState *ts, const char *event,

const char *argFormat, va_list vargs)

{

/* N format is inappropriate, because you do not know

assert(!argFormat || !strchr(argFormat, 'N'));

if (!ts) {

/* Audit hooks cannot be called with a NULL thread state */

return 0;

}

/* The current implementation cannot be called if tstate is not

assert(ts == _PyThreadState_GET());

/* Early exit when no hooks are registered */

PyInterpreterState *is = ts->interp;

if (!should_audit(is)) {

return 0;

}

PyObject *eventName = NULL;

PyObject *eventArgs = NULL;

PyObject *hooks = NULL;

PyObject *hook = NULL;

int res = -1;

int dtrace = PyDTrace_AUDIT_ENABLED();

PyObject *exc_type, *exc_value, *exc_tb;

_PyErr_Fetch(ts, &exc_type, &exc_value, &exc_tb);

/* Initialize event args now */

if (argFormat && argFormat[0]) {

eventArgs = _Py_VaBuildValue_SizeT(argFormat, vargs);

if (eventArgs && !PyTuple_Check(eventArgs)) {

PyObject *argTuple = PyTuple_Pack(1, eventArgs);

Py_DECREF(eventArgs);

eventArgs = argTuple;

}

}

else {

eventArgs = PyTuple_New(0);

}

if (!eventArgs) {

goto exit;

}

/* Call global hooks */

_Py_AuditHookEntry *e = is->runtime->audit_hook_head;

for (; e; e = e->next) {

if (e->hookCFunction(event, eventArgs, e->userData) < 0) {

goto exit;

}

}

/* Dtrace USDT point */

if (dtrace) {

PyDTrace_AUDIT(event, (void *)eventArgs);

}

/* Call interpreter hooks */

if (is->audit_hooks) {

eventName = PyUnicode_FromString(event);

if (!eventName) {

goto exit;

}

hooks = PyObject_GetIter(is->audit_hooks);

if (!hooks) {

goto exit;

}

/* Disallow tracing in hooks unless explicitly enabled */

ts->tracing++;

ts->use_tracing = 0;

while ((hook = PyIter_Next(hooks)) != NULL) {

_Py_IDENTIFIER(__cantrace__);

PyObject *o;

int canTrace = _PyObject_LookupAttrId(hook, &PyId___cantrace__, &o);

if (o) {

canTrace = PyObject_IsTrue(o);

Py_DECREF(o);

}

if (canTrace < 0) {

break;

}

if (canTrace) {

ts->use_tracing = (ts->c_tracefunc || ts->c_profilefunc);

ts->tracing--;

}

PyObject* args[2] = {eventName, eventArgs};

o = _PyObject_FastCallTstate(ts, hook, args, 2);

if (canTrace) {

ts->tracing++;

ts->use_tracing = 0;

}

if (!o) {

break;

}

Py_DECREF(o);

Py_CLEAR(hook);

}

ts->use_tracing = (ts->c_tracefunc || ts->c_profilefunc);

ts->tracing--;

if (_PyErr_Occurred(ts)) {

goto exit;

}

}

res = 0;

exit:

Py_XDECREF(hook);

Py_XDECREF(hooks);

Py_XDECREF(eventName);

Py_XDECREF(eventArgs);

if (!res) {

_PyErr_Restore(ts, exc_type, exc_value, exc_tb);

}

else {

assert(_PyErr_Occurred(ts));

Py_XDECREF(exc_type);

Py_XDECREF(exc_value);

Py_XDECREF(exc_tb);

}

return res;

}

_PySys_Audit(PyThreadState *tstate, const char *event,

const char *argFormat, ...)

{

va_list vargs;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, argFormat);

va_start(vargs);

int res = sys_audit_tstate(tstate, event, argFormat, vargs);

va_end(vargs);

return res;

}

PySys_Audit(const char *event, const char *argFormat, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

va_list vargs;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, argFormat);

va_start(vargs);

int res = sys_audit_tstate(tstate, event, argFormat, vargs);

va_end(vargs);

return res;

}

_PySys_ClearAuditHooks(PyThreadState *ts)

{

assert(ts != NULL);

if (!ts) {

return;

}

_PyRuntimeState *runtime = ts->interp->runtime;

PyThreadState *finalizing = _PyRuntimeState_GetFinalizing(runtime);

assert(finalizing == ts);

if (finalizing != ts) {

return;

}

const PyConfig *config = _PyInterpreterState_GetConfig(ts->interp);

if (config->verbose) {

PySys_WriteStderr("# clear sys.audit hooks\n");

}

/* Hooks can abort later hooks for this event, but cannot

_PySys_Audit(ts, "cpython._PySys_ClearAuditHooks", NULL);

_PyErr_Clear(ts);

_Py_AuditHookEntry *e = runtime->audit_hook_head, *n;

runtime->audit_hook_head = NULL;

while (e) {

n = e->next;

PyMem_RawFree(e);

e = n;

}

}

PySys_AddAuditHook(Py_AuditHookFunction hook, void *userData)

{

/* tstate can be NULL, so access directly _PyRuntime:

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate;

if (runtime->initialized) {

tstate = _PyRuntimeState_GetThreadState(runtime);

}

else {

tstate = NULL;

}

/* Invoke existing audit hooks to allow them an opportunity to abort. */

/* Cannot invoke hooks until we are initialized */

if (tstate != NULL) {

if (_PySys_Audit(tstate, "sys.addaudithook", NULL) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_RuntimeError)) {

/* We do not report errors derived from RuntimeError */

_PyErr_Clear(tstate);

return 0;

}

return -1;

}

}

_Py_AuditHookEntry *e = runtime->audit_hook_head;

if (!e) {

e = (_Py_AuditHookEntry*)PyMem_RawMalloc(sizeof(_Py_AuditHookEntry));

runtime->audit_hook_head = e;

} else {

while (e->next) {

e = e->next;

}

e = e->next = (_Py_AuditHookEntry*)PyMem_RawMalloc(

sizeof(_Py_AuditHookEntry));

}

if (!e) {

if (tstate != NULL) {

_PyErr_NoMemory(tstate);

}

return -1;

}

e->next = NULL;

e->hookCFunction = (Py_AuditHookFunction)hook;

e->userData = userData;

return 0;

}

static PyObject *

sys_addaudithook_impl(PyObject *module, PyObject *hook)

{

PyThreadState *tstate = _PyThreadState_GET();

/* Invoke existing audit hooks to allow them an opportunity to abort. */

if (_PySys_Audit(tstate, "sys.addaudithook", NULL) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_Exception)) {

/* We do not report errors derived from Exception */

_PyErr_Clear(tstate);

Py_RETURN_NONE;

}

return NULL;

}

PyInterpreterState *is = tstate->interp;

if (is->audit_hooks == NULL) {

is->audit_hooks = PyList_New(0);

if (is->audit_hooks == NULL) {

return NULL;

}

/* Avoid having our list of hooks show up in the GC module */

PyObject_GC_UnTrack(is->audit_hooks);

}

if (PyList_Append(is->audit_hooks, hook) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(audit_doc,

Passes the event to any audit hooks that are attached.");

static PyObject *

sys_audit(PyObject *self, PyObject *const *args, Py_ssize_t argc)

{

PyThreadState *tstate = _PyThreadState_GET();

_Py_EnsureTstateNotNULL(tstate);

if (argc == 0) {

_PyErr_SetString(tstate, PyExc_TypeError,

"audit() missing 1 required positional argument: "

"'event'");

return NULL;

}

if (!should_audit(tstate->interp)) {

Py_RETURN_NONE;

}

PyObject *auditEvent = args[0];

if (!auditEvent) {

_PyErr_SetString(tstate, PyExc_TypeError,

"expected str for argument 'event'");

return NULL;

}

if (!PyUnicode_Check(auditEvent)) {

_PyErr_Format(tstate, PyExc_TypeError,

"expected str for argument 'event', not %.200s",

Py_TYPE(auditEvent)->tp_name);

return NULL;

}

const char *event = PyUnicode_AsUTF8(auditEvent);

if (!event) {

return NULL;

}

PyObject *auditArgs = _PyTuple_FromArray(args + 1, argc - 1);

if (!auditArgs) {

return NULL;

}

int res = _PySys_Audit(tstate, event, "O", auditArgs);

Py_DECREF(auditArgs);

if (res < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

sys_breakpointhook(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)

{

PyThreadState *tstate = _PyThreadState_GET();

assert(!_PyErr_Occurred(tstate));

char *envar = Py_GETENV("PYTHONBREAKPOINT");

if (envar == NULL || strlen(envar) == 0) {

envar = "pdb.set_trace";

}

else if (!strcmp(envar, "0")) {

/* The breakpoint is explicitly no-op'd. */

Py_RETURN_NONE;

}

/* According to POSIX the string returned by getenv() might be invalidated

envar = _PyMem_RawStrdup(envar);

if (envar == NULL) {

_PyErr_NoMemory(tstate);

return NULL;

}

const char *last_dot = strrchr(envar, '.');

const char *attrname = NULL;

PyObject *modulepath = NULL;

if (last_dot == NULL) {

/* The breakpoint is a built-in, e.g. PYTHONBREAKPOINT=int */

modulepath = PyUnicode_FromString("builtins");

attrname = envar;

}

else if (last_dot != envar) {

/* Split on the last dot; */

modulepath = PyUnicode_FromStringAndSize(envar, last_dot - envar);

attrname = last_dot + 1;

}

else {

goto warn;

}

if (modulepath == NULL) {

PyMem_RawFree(envar);

return NULL;

}

PyObject *module = PyImport_Import(modulepath);

Py_DECREF(modulepath);

if (module == NULL) {

if (_PyErr_ExceptionMatches(tstate, PyExc_ImportError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyObject *hook = PyObject_GetAttrString(module, attrname);

Py_DECREF(module);

if (hook == NULL) {

if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyMem_RawFree(envar);

PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);

Py_DECREF(hook);

return retval;

warn:

/* If any of the imports went wrong, then warn and ignore. */

_PyErr_Clear(tstate);

int status = PyErr_WarnFormat(

PyExc_RuntimeWarning, 0,

"Ignoring unimportable $PYTHONBREAKPOINT: \"%s\"", envar);

PyMem_RawFree(envar);

if (status < 0) {

/* Printing the warning raised an exception. */

return NULL;

}

/* The warning was (probably) issued. */

Py_RETURN_NONE;

}

PyDoc_STRVAR(breakpointhook_doc,

);

static int

sys_displayhook_unencodable(PyObject *outf, PyObject *o)

{

PyObject *stdout_encoding = NULL;

PyObject *encoded, *escaped_str, *repr_str, *buffer, *result;

const char *stdout_encoding_str;

int ret;

stdout_encoding = _PyObject_GetAttrId(outf, &PyId_encoding);

if (stdout_encoding == NULL)

goto error;

stdout_encoding_str = PyUnicode_AsUTF8(stdout_encoding);

if (stdout_encoding_str == NULL)

goto error;

repr_str = PyObject_Repr(o);

if (repr_str == NULL)

goto error;

encoded = PyUnicode_AsEncodedString(repr_str,

stdout_encoding_str,

"backslashreplace");

Py_DECREF(repr_str);

if (encoded == NULL)

goto error;

if (_PyObject_LookupAttrId(outf, &PyId_buffer, &buffer) < 0) {

Py_DECREF(encoded);

goto error;

}

if (buffer) {

result = _PyObject_CallMethodIdOneArg(buffer, &PyId_write, encoded);

Py_DECREF(buffer);

Py_DECREF(encoded);

if (result == NULL)

goto error;

Py_DECREF(result);

}

else {

escaped_str = PyUnicode_FromEncodedObject(encoded,

stdout_encoding_str,

"strict");

Py_DECREF(encoded);

if (PyFile_WriteObject(escaped_str, outf, Py_PRINT_RAW) != 0) {

Py_DECREF(escaped_str);

goto error;

}

Py_DECREF(escaped_str);

}

ret = 0;

goto finally;

error:

ret = -1;

finally:

Py_XDECREF(stdout_encoding);

return ret;

}

static PyObject *

sys_displayhook(PyObject *module, PyObject *o)

{

PyObject *outf;

PyObject *builtins;

static PyObject *newline = NULL;

PyThreadState *tstate = _PyThreadState_GET();

builtins = _PyImport_GetModuleId(&PyId_builtins);

if (builtins == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"lost builtins module");

}

return NULL;

}

Py_DECREF(builtins);

/* Print value except if None */

/* After printing, also assign to '_' */

/* Before, set '_' to None to avoid recursion */

if (o == Py_None) {

Py_RETURN_NONE;

}

if (_PyObject_SetAttrId(builtins, &PyId__, Py_None) != 0)

return NULL;

outf = sys_get_object_id(tstate, &PyId_stdout);

if (outf == NULL || outf == Py_None) {

_PyErr_SetString(tstate, PyExc_RuntimeError, "lost sys.stdout");

return NULL;

}

if (PyFile_WriteObject(o, outf, 0) != 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_UnicodeEncodeError)) {

int err;

/* repr(o) is not encodable to sys.stdout.encoding with

_PyErr_Clear(tstate);

err = sys_displayhook_unencodable(outf, o);

if (err) {

return NULL;

}

}

else {

return NULL;

}

}

if (newline == NULL) {

newline = PyUnicode_FromString("\n");

if (newline == NULL)

return NULL;

}

if (PyFile_WriteObject(newline, outf, Py_PRINT_RAW) != 0)

return NULL;

if (_PyObject_SetAttrId(builtins, &PyId__, o) != 0)

return NULL;

Py_RETURN_NONE;

}

static PyObject *

sys_excepthook_impl(PyObject *module, PyObject *exctype, PyObject *value,

PyObject *traceback)

{

PyErr_Display(exctype, value, traceback);

Py_RETURN_NONE;

}

static PyObject *

sys_exc_info_impl(PyObject *module)

{

_PyErr_StackItem *err_info = _PyErr_GetTopmostException(_PyThreadState_GET());

return Py_BuildValue(

"(OOO)",

err_info->exc_type != NULL ? err_info->exc_type : Py_None,

err_info->exc_value != NULL ? err_info->exc_value : Py_None,

err_info->exc_traceback != NULL ?

err_info->exc_traceback : Py_None);

}

static PyObject *

sys_unraisablehook(PyObject *module, PyObject *unraisable)

{

return _PyErr_WriteUnraisableDefaultHook(unraisable);

}

static PyObject *

sys_exit_impl(PyObject *module, PyObject *status)

{

/* Raise SystemExit so callers may catch it or clean up. */

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetObject(tstate, PyExc_SystemExit, status);

return NULL;

}

static PyObject *

sys_getdefaultencoding_impl(PyObject *module)

{

return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());

}

static PyObject *

sys_getfilesystemencoding_impl(PyObject *module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

const PyConfig *config = _PyInterpreterState_GetConfig(interp);

return PyUnicode_FromWideChar(config->filesystem_encoding, -1);

}

static PyObject *

sys_getfilesystemencodeerrors_impl(PyObject *module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

const PyConfig *config = _PyInterpreterState_GetConfig(interp);

return PyUnicode_FromWideChar(config->filesystem_errors, -1);

}

static PyObject *

sys_intern_impl(PyObject *module, PyObject *s)

{

PyThreadState *tstate = _PyThreadState_GET();

if (PyUnicode_CheckExact(s)) {

Py_INCREF(s);

PyUnicode_InternInPlace(&s);

return s;

}

else {

_PyErr_Format(tstate, PyExc_TypeError,

"can't intern %.400s", Py_TYPE(s)->tp_name);

return NULL;

}

}

static PyObject *whatstrings[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

static int

trace_init(void)

{

static const char * const whatnames[8] = {

"call", "exception", "line", "return",

"c_call", "c_exception", "c_return",

"opcode"

};

PyObject *name;

int i;

for (i = 0; i < 8; ++i) {

if (whatstrings[i] == NULL) {

name = PyUnicode_InternFromString(whatnames[i]);

if (name == NULL)

return -1;

whatstrings[i] = name;

}

}

return 0;

}

static PyObject *

call_trampoline(PyThreadState *tstate, PyObject* callback,

PyFrameObject *frame, int what, PyObject *arg)

{

if (PyFrame_FastToLocalsWithError(frame) < 0) {

return NULL;

}

PyObject *stack[3];

stack[0] = (PyObject *)frame;

stack[1] = whatstrings[what];

stack[2] = (arg != NULL) ? arg : Py_None;

/* call the Python-level function */

PyObject *result = _PyObject_FastCallTstate(tstate, callback, stack, 3);

PyFrame_LocalsToFast(frame, 1);

if (result == NULL) {

PyTraceBack_Here(frame);

}

return result;

}

static int

profile_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

if (arg == NULL) {

arg = Py_None;

}

PyThreadState *tstate = _PyThreadState_GET();

PyObject *result = call_trampoline(tstate, self, frame, what, arg);

if (result == NULL) {

_PyEval_SetProfile(tstate, NULL, NULL);

return -1;

}

Py_DECREF(result);

return 0;

}

static int

trace_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

PyObject *callback;

if (what == PyTrace_CALL) {

callback = self;

}

else {

callback = frame->f_trace;

}

if (callback == NULL) {

return 0;

}

PyThreadState *tstate = _PyThreadState_GET();

PyObject *result = call_trampoline(tstate, callback, frame, what, arg);

if (result == NULL) {

_PyEval_SetTrace(tstate, NULL, NULL);

Py_CLEAR(frame->f_trace);

return -1;

}

if (result != Py_None) {

Py_XSETREF(frame->f_trace, result);

}

else {