1 /* Python interpreter main program */
2
3 #include "Python.h"
4 #include "pycore_initconfig.h"
5 #include "pycore_pylifecycle.h"
6 #include "pycore_pymem.h"
7 #include "pycore_pystate.h"
8
9 #ifdef __FreeBSD__
10 # include <fenv.h> /* fedisableexcept() */
11 #endif
12
13 /* Includes for exit_sigint() */
14 #include <stdio.h> /* perror() */
15 #ifdef HAVE_SIGNAL_H
16 # include <signal.h> /* SIGINT */
17 #endif
18 #if defined(HAVE_GETPID) && defined(HAVE_UNISTD_H)
19 # include <unistd.h> /* getpid() */
20 #endif
21 #ifdef MS_WINDOWS
22 # include <windows.h> /* STATUS_CONTROL_C_EXIT */
23 #endif
24 /* End of includes for exit_sigint() */
25
26 #define COPYRIGHT \
27 "Type \"help\", \"copyright\", \"credits\" or \"license\" " \
28 "for more information."
29
30 #ifdef __cplusplus
31 extern "C" {
32 #endif
33
34 /* --- pymain_init() ---------------------------------------------- */
35
36 static PyStatus
pymain_init(const _PyArgv * args)37 pymain_init(const _PyArgv *args)
38 {
39 PyStatus status;
40
41 status = _PyRuntime_Initialize();
42 if (_PyStatus_EXCEPTION(status)) {
43 return status;
44 }
45
46 /* 754 requires that FP exceptions run in "no stop" mode by default,
47 * and until C vendors implement C99's ways to control FP exceptions,
48 * Python requires non-stop mode. Alas, some platforms enable FP
49 * exceptions by default. Here we disable them.
50 */
51 #ifdef __FreeBSD__
52 fedisableexcept(FE_OVERFLOW);
53 #endif
54
55 PyPreConfig preconfig;
56 PyPreConfig_InitPythonConfig(&preconfig);
57
58 status = _Py_PreInitializeFromPyArgv(&preconfig, args);
59 if (_PyStatus_EXCEPTION(status)) {
60 return status;
61 }
62
63 PyConfig config;
64 PyConfig_InitPythonConfig(&config);
65
66 /* pass NULL as the config: config is read from command line arguments,
67 environment variables, configuration files */
68 if (args->use_bytes_argv) {
69 status = PyConfig_SetBytesArgv(&config, args->argc, args->bytes_argv);
70 }
71 else {
72 status = PyConfig_SetArgv(&config, args->argc, args->wchar_argv);
73 }
74 if (_PyStatus_EXCEPTION(status)) {
75 goto done;
76 }
77
78 status = Py_InitializeFromConfig(&config);
79 if (_PyStatus_EXCEPTION(status)) {
80 goto done;
81 }
82 status = _PyStatus_OK();
83
84 done:
85 PyConfig_Clear(&config);
86 return status;
87 }
88
89
90 /* --- pymain_run_python() ---------------------------------------- */
91
92 /* Non-zero if filename, command (-c) or module (-m) is set
93 on the command line */
config_run_code(const PyConfig * config)94 static inline int config_run_code(const PyConfig *config)
95 {
96 return (config->run_command != NULL
97 || config->run_filename != NULL
98 || config->run_module != NULL);
99 }
100
101
102 /* Return non-zero is stdin is a TTY or if -i command line option is used */
103 static int
stdin_is_interactive(const PyConfig * config)104 stdin_is_interactive(const PyConfig *config)
105 {
106 return (isatty(fileno(stdin)) || config->interactive);
107 }
108
109
110 /* Display the current Python exception and return an exitcode */
111 static int
pymain_err_print(int * exitcode_p)112 pymain_err_print(int *exitcode_p)
113 {
114 int exitcode;
115 if (_Py_HandleSystemExit(&exitcode)) {
116 *exitcode_p = exitcode;
117 return 1;
118 }
119
120 PyErr_Print();
121 return 0;
122 }
123
124
125 static int
pymain_exit_err_print(void)126 pymain_exit_err_print(void)
127 {
128 int exitcode = 1;
129 pymain_err_print(&exitcode);
130 return exitcode;
131 }
132
133
134 /* Write an exitcode into *exitcode and return 1 if we have to exit Python.
135 Return 0 otherwise. */
136 static int
pymain_get_importer(const wchar_t * filename,PyObject ** importer_p,int * exitcode)137 pymain_get_importer(const wchar_t *filename, PyObject **importer_p, int *exitcode)
138 {
139 PyObject *sys_path0 = NULL, *importer;
140
141 sys_path0 = PyUnicode_FromWideChar(filename, wcslen(filename));
142 if (sys_path0 == NULL) {
143 goto error;
144 }
145
146 importer = PyImport_GetImporter(sys_path0);
147 if (importer == NULL) {
148 goto error;
149 }
150
151 if (importer == Py_None) {
152 Py_DECREF(sys_path0);
153 Py_DECREF(importer);
154 return 0;
155 }
156
157 Py_DECREF(importer);
158 *importer_p = sys_path0;
159 return 0;
160
161 error:
162 Py_XDECREF(sys_path0);
163
164 PySys_WriteStderr("Failed checking if argv[0] is an import path entry\n");
165 return pymain_err_print(exitcode);
166 }
167
168
169 static int
pymain_sys_path_add_path0(PyInterpreterState * interp,PyObject * path0)170 pymain_sys_path_add_path0(PyInterpreterState *interp, PyObject *path0)
171 {
172 _Py_IDENTIFIER(path);
173 PyObject *sys_path;
174 PyObject *sysdict = interp->sysdict;
175 if (sysdict != NULL) {
176 sys_path = _PyDict_GetItemIdWithError(sysdict, &PyId_path);
177 if (sys_path == NULL && PyErr_Occurred()) {
178 return -1;
179 }
180 }
181 else {
182 sys_path = NULL;
183 }
184 if (sys_path == NULL) {
185 PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path");
186 return -1;
187 }
188
189 if (PyList_Insert(sys_path, 0, path0)) {
190 return -1;
191 }
192 return 0;
193 }
194
195
196 static void
pymain_header(const PyConfig * config)197 pymain_header(const PyConfig *config)
198 {
199 if (config->quiet) {
200 return;
201 }
202
203 if (!config->verbose && (config_run_code(config) || !stdin_is_interactive(config))) {
204 return;
205 }
206
207 fprintf(stderr, "Python %s on %s\n", Py_GetVersion(), Py_GetPlatform());
208 if (config->site_import) {
209 fprintf(stderr, "%s\n", COPYRIGHT);
210 }
211 }
212
213
214 static void
pymain_import_readline(const PyConfig * config)215 pymain_import_readline(const PyConfig *config)
216 {
217 if (config->isolated) {
218 return;
219 }
220 if (!config->inspect && config_run_code(config)) {
221 return;
222 }
223 if (!isatty(fileno(stdin))) {
224 return;
225 }
226
227 PyObject *mod = PyImport_ImportModule("readline");
228 if (mod == NULL) {
229 PyErr_Clear();
230 }
231 else {
232 Py_DECREF(mod);
233 }
234 }
235
236
237 static int
pymain_run_command(wchar_t * command,PyCompilerFlags * cf)238 pymain_run_command(wchar_t *command, PyCompilerFlags *cf)
239 {
240 PyObject *unicode, *bytes;
241 int ret;
242
243 unicode = PyUnicode_FromWideChar(command, -1);
244 if (unicode == NULL) {
245 goto error;
246 }
247
248 if (PySys_Audit("cpython.run_command", "O", unicode) < 0) {
249 return pymain_exit_err_print();
250 }
251
252 bytes = PyUnicode_AsUTF8String(unicode);
253 Py_DECREF(unicode);
254 if (bytes == NULL) {
255 goto error;
256 }
257
258 ret = PyRun_SimpleStringFlags(PyBytes_AsString(bytes), cf);
259 Py_DECREF(bytes);
260 return (ret != 0);
261
262 error:
263 PySys_WriteStderr("Unable to decode the command from the command line:\n");
264 return pymain_exit_err_print();
265 }
266
267
268 static int
pymain_run_module(const wchar_t * modname,int set_argv0)269 pymain_run_module(const wchar_t *modname, int set_argv0)
270 {
271 PyObject *module, *runpy, *runmodule, *runargs, *result;
272 if (PySys_Audit("cpython.run_module", "u", modname) < 0) {
273 return pymain_exit_err_print();
274 }
275 runpy = PyImport_ImportModule("runpy");
276 if (runpy == NULL) {
277 fprintf(stderr, "Could not import runpy module\n");
278 return pymain_exit_err_print();
279 }
280 runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
281 if (runmodule == NULL) {
282 fprintf(stderr, "Could not access runpy._run_module_as_main\n");
283 Py_DECREF(runpy);
284 return pymain_exit_err_print();
285 }
286 module = PyUnicode_FromWideChar(modname, wcslen(modname));
287 if (module == NULL) {
288 fprintf(stderr, "Could not convert module name to unicode\n");
289 Py_DECREF(runpy);
290 Py_DECREF(runmodule);
291 return pymain_exit_err_print();
292 }
293 runargs = Py_BuildValue("(Oi)", module, set_argv0);
294 if (runargs == NULL) {
295 fprintf(stderr,
296 "Could not create arguments for runpy._run_module_as_main\n");
297 Py_DECREF(runpy);
298 Py_DECREF(runmodule);
299 Py_DECREF(module);
300 return pymain_exit_err_print();
301 }
302 result = PyObject_Call(runmodule, runargs, NULL);
303 Py_DECREF(runpy);
304 Py_DECREF(runmodule);
305 Py_DECREF(module);
306 Py_DECREF(runargs);
307 if (result == NULL) {
308 return pymain_exit_err_print();
309 }
310 Py_DECREF(result);
311 return 0;
312 }
313
314
315 static int
pymain_run_file(PyConfig * config,PyCompilerFlags * cf)316 pymain_run_file(PyConfig *config, PyCompilerFlags *cf)
317 {
318 const wchar_t *filename = config->run_filename;
319 if (PySys_Audit("cpython.run_file", "u", filename) < 0) {
320 return pymain_exit_err_print();
321 }
322 FILE *fp = _Py_wfopen(filename, L"rb");
323 if (fp == NULL) {
324 char *cfilename_buffer;
325 const char *cfilename;
326 int err = errno;
327 cfilename_buffer = _Py_EncodeLocaleRaw(filename, NULL);
328 if (cfilename_buffer != NULL)
329 cfilename = cfilename_buffer;
330 else
331 cfilename = "<unprintable file name>";
332 fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n",
333 config->program_name, cfilename, err, strerror(err));
334 PyMem_RawFree(cfilename_buffer);
335 return 2;
336 }
337
338 if (config->skip_source_first_line) {
339 int ch;
340 /* Push back first newline so line numbers remain the same */
341 while ((ch = getc(fp)) != EOF) {
342 if (ch == '\n') {
343 (void)ungetc(ch, fp);
344 break;
345 }
346 }
347 }
348
349 struct _Py_stat_struct sb;
350 if (_Py_fstat_noraise(fileno(fp), &sb) == 0 && S_ISDIR(sb.st_mode)) {
351 fprintf(stderr,
352 "%ls: '%ls' is a directory, cannot continue\n",
353 config->program_name, filename);
354 fclose(fp);
355 return 1;
356 }
357
358 /* call pending calls like signal handlers (SIGINT) */
359 if (Py_MakePendingCalls() == -1) {
360 fclose(fp);
361 return pymain_exit_err_print();
362 }
363
364 PyObject *unicode, *bytes = NULL;
365 const char *filename_str;
366
367 unicode = PyUnicode_FromWideChar(filename, wcslen(filename));
368 if (unicode != NULL) {
369 bytes = PyUnicode_EncodeFSDefault(unicode);
370 Py_DECREF(unicode);
371 }
372 if (bytes != NULL) {
373 filename_str = PyBytes_AsString(bytes);
374 }
375 else {
376 PyErr_Clear();
377 filename_str = "<filename encoding error>";
378 }
379
380 /* PyRun_AnyFileExFlags(closeit=1) calls fclose(fp) before running code */
381 int run = PyRun_AnyFileExFlags(fp, filename_str, 1, cf);
382 Py_XDECREF(bytes);
383 return (run != 0);
384 }
385
386
387 static int
pymain_run_startup(PyConfig * config,PyCompilerFlags * cf,int * exitcode)388 pymain_run_startup(PyConfig *config, PyCompilerFlags *cf, int *exitcode)
389 {
390 const char *startup = _Py_GetEnv(config->use_environment, "PYTHONSTARTUP");
391 if (startup == NULL) {
392 return 0;
393 }
394 if (PySys_Audit("cpython.run_startup", "s", startup) < 0) {
395 return pymain_err_print(exitcode);
396 }
397
398 FILE *fp = _Py_fopen(startup, "r");
399 if (fp == NULL) {
400 int save_errno = errno;
401 PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
402
403 errno = save_errno;
404 PyErr_SetFromErrnoWithFilename(PyExc_OSError, startup);
405
406 return pymain_err_print(exitcode);
407 }
408
409 (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
410 PyErr_Clear();
411 fclose(fp);
412 return 0;
413 }
414
415
416 /* Write an exitcode into *exitcode and return 1 if we have to exit Python.
417 Return 0 otherwise. */
418 static int
pymain_run_interactive_hook(int * exitcode)419 pymain_run_interactive_hook(int *exitcode)
420 {
421 PyObject *sys, *hook, *result;
422 sys = PyImport_ImportModule("sys");
423 if (sys == NULL) {
424 goto error;
425 }
426
427 hook = PyObject_GetAttrString(sys, "__interactivehook__");
428 Py_DECREF(sys);
429 if (hook == NULL) {
430 PyErr_Clear();
431 return 0;
432 }
433
434 if (PySys_Audit("cpython.run_interactivehook", "O", hook) < 0) {
435 goto error;
436 }
437
438 result = _PyObject_CallNoArg(hook);
439 Py_DECREF(hook);
440 if (result == NULL) {
441 goto error;
442 }
443 Py_DECREF(result);
444
445 return 0;
446
447 error:
448 PySys_WriteStderr("Failed calling sys.__interactivehook__\n");
449 return pymain_err_print(exitcode);
450 }
451
452
453 static int
pymain_run_stdin(PyConfig * config,PyCompilerFlags * cf)454 pymain_run_stdin(PyConfig *config, PyCompilerFlags *cf)
455 {
456 if (stdin_is_interactive(config)) {
457 config->inspect = 0;
458 Py_InspectFlag = 0; /* do exit on SystemExit */
459
460 int exitcode;
461 if (pymain_run_startup(config, cf, &exitcode)) {
462 return exitcode;
463 }
464
465 if (pymain_run_interactive_hook(&exitcode)) {
466 return exitcode;
467 }
468 }
469
470 /* call pending calls like signal handlers (SIGINT) */
471 if (Py_MakePendingCalls() == -1) {
472 return pymain_exit_err_print();
473 }
474
475 if (PySys_Audit("cpython.run_stdin", NULL) < 0) {
476 return pymain_exit_err_print();
477 }
478
479 int run = PyRun_AnyFileExFlags(stdin, "<stdin>", 0, cf);
480 return (run != 0);
481 }
482
483
484 static void
pymain_repl(PyConfig * config,PyCompilerFlags * cf,int * exitcode)485 pymain_repl(PyConfig *config, PyCompilerFlags *cf, int *exitcode)
486 {
487 /* Check this environment variable at the end, to give programs the
488 opportunity to set it from Python. */
489 if (!config->inspect && _Py_GetEnv(config->use_environment, "PYTHONINSPECT")) {
490 config->inspect = 1;
491 Py_InspectFlag = 1;
492 }
493
494 if (!(config->inspect && stdin_is_interactive(config) && config_run_code(config))) {
495 return;
496 }
497
498 config->inspect = 0;
499 Py_InspectFlag = 0;
500 if (pymain_run_interactive_hook(exitcode)) {
501 return;
502 }
503
504 int res = PyRun_AnyFileFlags(stdin, "<stdin>", cf);
505 *exitcode = (res != 0);
506 }
507
508
509 static void
pymain_run_python(int * exitcode)510 pymain_run_python(int *exitcode)
511 {
512 PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();
513 /* pymain_run_stdin() modify the config */
514 PyConfig *config = &interp->config;
515
516 PyObject *main_importer_path = NULL;
517 if (config->run_filename != NULL) {
518 /* If filename is a package (ex: directory or ZIP file) which contains
519 __main__.py, main_importer_path is set to filename and will be
520 prepended to sys.path.
521
522 Otherwise, main_importer_path is left unchanged. */
523 if (pymain_get_importer(config->run_filename, &main_importer_path,
524 exitcode)) {
525 return;
526 }
527 }
528
529 if (main_importer_path != NULL) {
530 if (pymain_sys_path_add_path0(interp, main_importer_path) < 0) {
531 goto error;
532 }
533 }
534 else if (!config->isolated) {
535 PyObject *path0 = NULL;
536 int res = _PyPathConfig_ComputeSysPath0(&config->argv, &path0);
537 if (res < 0) {
538 goto error;
539 }
540
541 if (res > 0) {
542 if (pymain_sys_path_add_path0(interp, path0) < 0) {
543 Py_DECREF(path0);
544 goto error;
545 }
546 Py_DECREF(path0);
547 }
548 }
549
550 PyCompilerFlags cf = _PyCompilerFlags_INIT;
551
552 pymain_header(config);
553 pymain_import_readline(config);
554
555 if (config->run_command) {
556 *exitcode = pymain_run_command(config->run_command, &cf);
557 }
558 else if (config->run_module) {
559 *exitcode = pymain_run_module(config->run_module, 1);
560 }
561 else if (main_importer_path != NULL) {
562 *exitcode = pymain_run_module(L"__main__", 0);
563 }
564 else if (config->run_filename != NULL) {
565 *exitcode = pymain_run_file(config, &cf);
566 }
567 else {
568 *exitcode = pymain_run_stdin(config, &cf);
569 }
570
571 pymain_repl(config, &cf, exitcode);
572 goto done;
573
574 error:
575 *exitcode = pymain_exit_err_print();
576
577 done:
578 Py_XDECREF(main_importer_path);
579 }
580
581
582 /* --- pymain_main() ---------------------------------------------- */
583
584 static void
pymain_free(void)585 pymain_free(void)
586 {
587 _PyImport_Fini2();
588
589 /* Free global variables which cannot be freed in Py_Finalize():
590 configuration options set before Py_Initialize() which should
591 remain valid after Py_Finalize(), since
592 Py_Initialize()-Py_Finalize() can be called multiple times. */
593 _PyPathConfig_ClearGlobal();
594 _Py_ClearStandardStreamEncoding();
595 _Py_ClearArgcArgv();
596 _PyRuntime_Finalize();
597 }
598
599
600 static int
exit_sigint(void)601 exit_sigint(void)
602 {
603 /* bpo-1054041: We need to exit via the
604 * SIG_DFL handler for SIGINT if KeyboardInterrupt went unhandled.
605 * If we don't, a calling process such as a shell may not know
606 * about the user's ^C. https://www.cons.org/cracauer/sigint.html */
607 #if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
608 if (PyOS_setsig(SIGINT, SIG_DFL) == SIG_ERR) {
609 perror("signal"); /* Impossible in normal environments. */
610 } else {
611 kill(getpid(), SIGINT);
612 }
613 /* If setting SIG_DFL failed, or kill failed to terminate us,
614 * there isn't much else we can do aside from an error code. */
615 #endif /* HAVE_GETPID && !MS_WINDOWS */
616 #ifdef MS_WINDOWS
617 /* cmd.exe detects this, prints ^C, and offers to terminate. */
618 /* https://msdn.microsoft.com/en-us/library/cc704588.aspx */
619 return STATUS_CONTROL_C_EXIT;
620 #else
621 return SIGINT + 128;
622 #endif /* !MS_WINDOWS */
623 }
624
625
626 static void _Py_NO_RETURN
pymain_exit_error(PyStatus status)627 pymain_exit_error(PyStatus status)
628 {
629 if (_PyStatus_IS_EXIT(status)) {
630 /* If it's an error rather than a regular exit, leave Python runtime
631 alive: Py_ExitStatusException() uses the current exception and use
632 sys.stdout in this case. */
633 pymain_free();
634 }
635 Py_ExitStatusException(status);
636 }
637
638
639 int
Py_RunMain(void)640 Py_RunMain(void)
641 {
642 int exitcode = 0;
643
644 pymain_run_python(&exitcode);
645
646 if (Py_FinalizeEx() < 0) {
647 /* Value unlikely to be confused with a non-error exit status or
648 other special meaning */
649 exitcode = 120;
650 }
651
652 pymain_free();
653
654 if (_Py_UnhandledKeyboardInterrupt) {
655 exitcode = exit_sigint();
656 }
657
658 return exitcode;
659 }
660
661
662 static int
pymain_main(_PyArgv * args)663 pymain_main(_PyArgv *args)
664 {
665 PyStatus status = pymain_init(args);
666 if (_PyStatus_IS_EXIT(status)) {
667 pymain_free();
668 return status.exitcode;
669 }
670 if (_PyStatus_EXCEPTION(status)) {
671 pymain_exit_error(status);
672 }
673
674 return Py_RunMain();
675 }
676
677
678 int
Py_Main(int argc,wchar_t ** argv)679 Py_Main(int argc, wchar_t **argv)
680 {
681 _PyArgv args = {
682 .argc = argc,
683 .use_bytes_argv = 0,
684 .bytes_argv = NULL,
685 .wchar_argv = argv};
686 return pymain_main(&args);
687 }
688
689
690 int
Py_BytesMain(int argc,char ** argv)691 Py_BytesMain(int argc, char **argv)
692 {
693 _PyArgv args = {
694 .argc = argc,
695 .use_bytes_argv = 1,
696 .bytes_argv = argv,
697 .wchar_argv = NULL};
698 return pymain_main(&args);
699 }
700
701 #ifdef __cplusplus
702 }
703 #endif
704