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 int ret;
391 PyObject *startup_obj = NULL;
392 if (!config->use_environment) {
393 return 0;
394 }
395 #ifdef MS_WINDOWS
396 const wchar_t *wstartup = _wgetenv(L"PYTHONSTARTUP");
397 if (wstartup == NULL || wstartup[0] == L'\0') {
398 return 0;
399 }
400 PyObject *startup_bytes = NULL;
401 startup_obj = PyUnicode_FromWideChar(wstartup, wcslen(wstartup));
402 if (startup_obj == NULL) {
403 goto error;
404 }
405 startup_bytes = PyUnicode_EncodeFSDefault(startup_obj);
406 if (startup_bytes == NULL) {
407 goto error;
408 }
409 const char *startup = PyBytes_AS_STRING(startup_bytes);
410 #else
411 const char *startup = _Py_GetEnv(config->use_environment, "PYTHONSTARTUP");
412 if (startup == NULL) {
413 return 0;
414 }
415 startup_obj = PyUnicode_DecodeFSDefault(startup);
416 if (startup_obj == NULL) {
417 goto error;
418 }
419 #endif
420 if (PySys_Audit("cpython.run_startup", "O", startup_obj) < 0) {
421 goto error;
422 }
423
424 #ifdef MS_WINDOWS
425 FILE *fp = _Py_wfopen(wstartup, L"r");
426 #else
427 FILE *fp = _Py_fopen(startup, "r");
428 #endif
429 if (fp == NULL) {
430 int save_errno = errno;
431 PyErr_Clear();
432 PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
433
434 errno = save_errno;
435 PyErr_SetFromErrnoWithFilenameObjects(PyExc_OSError, startup_obj, NULL);
436 goto error;
437 }
438
439 (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
440 PyErr_Clear();
441 fclose(fp);
442 ret = 0;
443
444 done:
445 #ifdef MS_WINDOWS
446 Py_XDECREF(startup_bytes);
447 #endif
448 Py_XDECREF(startup_obj);
449 return ret;
450
451 error:
452 ret = pymain_err_print(exitcode);
453 goto done;
454 }
455
456
457 /* Write an exitcode into *exitcode and return 1 if we have to exit Python.
458 Return 0 otherwise. */
459 static int
pymain_run_interactive_hook(int * exitcode)460 pymain_run_interactive_hook(int *exitcode)
461 {
462 PyObject *sys, *hook, *result;
463 sys = PyImport_ImportModule("sys");
464 if (sys == NULL) {
465 goto error;
466 }
467
468 hook = PyObject_GetAttrString(sys, "__interactivehook__");
469 Py_DECREF(sys);
470 if (hook == NULL) {
471 PyErr_Clear();
472 return 0;
473 }
474
475 if (PySys_Audit("cpython.run_interactivehook", "O", hook) < 0) {
476 goto error;
477 }
478
479 result = _PyObject_CallNoArg(hook);
480 Py_DECREF(hook);
481 if (result == NULL) {
482 goto error;
483 }
484 Py_DECREF(result);
485
486 return 0;
487
488 error:
489 PySys_WriteStderr("Failed calling sys.__interactivehook__\n");
490 return pymain_err_print(exitcode);
491 }
492
493
494 static int
pymain_run_stdin(PyConfig * config,PyCompilerFlags * cf)495 pymain_run_stdin(PyConfig *config, PyCompilerFlags *cf)
496 {
497 if (stdin_is_interactive(config)) {
498 config->inspect = 0;
499 Py_InspectFlag = 0; /* do exit on SystemExit */
500
501 int exitcode;
502 if (pymain_run_startup(config, cf, &exitcode)) {
503 return exitcode;
504 }
505
506 if (pymain_run_interactive_hook(&exitcode)) {
507 return exitcode;
508 }
509 }
510
511 /* call pending calls like signal handlers (SIGINT) */
512 if (Py_MakePendingCalls() == -1) {
513 return pymain_exit_err_print();
514 }
515
516 if (PySys_Audit("cpython.run_stdin", NULL) < 0) {
517 return pymain_exit_err_print();
518 }
519
520 int run = PyRun_AnyFileExFlags(stdin, "<stdin>", 0, cf);
521 return (run != 0);
522 }
523
524
525 static void
pymain_repl(PyConfig * config,PyCompilerFlags * cf,int * exitcode)526 pymain_repl(PyConfig *config, PyCompilerFlags *cf, int *exitcode)
527 {
528 /* Check this environment variable at the end, to give programs the
529 opportunity to set it from Python. */
530 if (!config->inspect && _Py_GetEnv(config->use_environment, "PYTHONINSPECT")) {
531 config->inspect = 1;
532 Py_InspectFlag = 1;
533 }
534
535 if (!(config->inspect && stdin_is_interactive(config) && config_run_code(config))) {
536 return;
537 }
538
539 config->inspect = 0;
540 Py_InspectFlag = 0;
541 if (pymain_run_interactive_hook(exitcode)) {
542 return;
543 }
544
545 int res = PyRun_AnyFileFlags(stdin, "<stdin>", cf);
546 *exitcode = (res != 0);
547 }
548
549
550 static void
pymain_run_python(int * exitcode)551 pymain_run_python(int *exitcode)
552 {
553 PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();
554 /* pymain_run_stdin() modify the config */
555 PyConfig *config = &interp->config;
556
557 PyObject *main_importer_path = NULL;
558 if (config->run_filename != NULL) {
559 /* If filename is a package (ex: directory or ZIP file) which contains
560 __main__.py, main_importer_path is set to filename and will be
561 prepended to sys.path.
562
563 Otherwise, main_importer_path is left unchanged. */
564 if (pymain_get_importer(config->run_filename, &main_importer_path,
565 exitcode)) {
566 return;
567 }
568 }
569
570 if (main_importer_path != NULL) {
571 if (pymain_sys_path_add_path0(interp, main_importer_path) < 0) {
572 goto error;
573 }
574 }
575 else if (!config->isolated) {
576 PyObject *path0 = NULL;
577 int res = _PyPathConfig_ComputeSysPath0(&config->argv, &path0);
578 if (res < 0) {
579 goto error;
580 }
581
582 if (res > 0) {
583 if (pymain_sys_path_add_path0(interp, path0) < 0) {
584 Py_DECREF(path0);
585 goto error;
586 }
587 Py_DECREF(path0);
588 }
589 }
590
591 PyCompilerFlags cf = _PyCompilerFlags_INIT;
592
593 pymain_header(config);
594 pymain_import_readline(config);
595
596 if (config->run_command) {
597 *exitcode = pymain_run_command(config->run_command, &cf);
598 }
599 else if (config->run_module) {
600 *exitcode = pymain_run_module(config->run_module, 1);
601 }
602 else if (main_importer_path != NULL) {
603 *exitcode = pymain_run_module(L"__main__", 0);
604 }
605 else if (config->run_filename != NULL) {
606 *exitcode = pymain_run_file(config, &cf);
607 }
608 else {
609 *exitcode = pymain_run_stdin(config, &cf);
610 }
611
612 pymain_repl(config, &cf, exitcode);
613 goto done;
614
615 error:
616 *exitcode = pymain_exit_err_print();
617
618 done:
619 Py_XDECREF(main_importer_path);
620 }
621
622
623 /* --- pymain_main() ---------------------------------------------- */
624
625 static void
pymain_free(void)626 pymain_free(void)
627 {
628 _PyImport_Fini2();
629
630 /* Free global variables which cannot be freed in Py_Finalize():
631 configuration options set before Py_Initialize() which should
632 remain valid after Py_Finalize(), since
633 Py_Initialize()-Py_Finalize() can be called multiple times. */
634 _PyPathConfig_ClearGlobal();
635 _Py_ClearStandardStreamEncoding();
636 _Py_ClearArgcArgv();
637 _PyRuntime_Finalize();
638 }
639
640
641 static int
exit_sigint(void)642 exit_sigint(void)
643 {
644 /* bpo-1054041: We need to exit via the
645 * SIG_DFL handler for SIGINT if KeyboardInterrupt went unhandled.
646 * If we don't, a calling process such as a shell may not know
647 * about the user's ^C. https://www.cons.org/cracauer/sigint.html */
648 #if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
649 if (PyOS_setsig(SIGINT, SIG_DFL) == SIG_ERR) {
650 perror("signal"); /* Impossible in normal environments. */
651 } else {
652 kill(getpid(), SIGINT);
653 }
654 /* If setting SIG_DFL failed, or kill failed to terminate us,
655 * there isn't much else we can do aside from an error code. */
656 #endif /* HAVE_GETPID && !MS_WINDOWS */
657 #ifdef MS_WINDOWS
658 /* cmd.exe detects this, prints ^C, and offers to terminate. */
659 /* https://msdn.microsoft.com/en-us/library/cc704588.aspx */
660 return STATUS_CONTROL_C_EXIT;
661 #else
662 return SIGINT + 128;
663 #endif /* !MS_WINDOWS */
664 }
665
666
667 static void _Py_NO_RETURN
pymain_exit_error(PyStatus status)668 pymain_exit_error(PyStatus status)
669 {
670 if (_PyStatus_IS_EXIT(status)) {
671 /* If it's an error rather than a regular exit, leave Python runtime
672 alive: Py_ExitStatusException() uses the current exception and use
673 sys.stdout in this case. */
674 pymain_free();
675 }
676 Py_ExitStatusException(status);
677 }
678
679
680 int
Py_RunMain(void)681 Py_RunMain(void)
682 {
683 int exitcode = 0;
684
685 pymain_run_python(&exitcode);
686
687 if (Py_FinalizeEx() < 0) {
688 /* Value unlikely to be confused with a non-error exit status or
689 other special meaning */
690 exitcode = 120;
691 }
692
693 pymain_free();
694
695 if (_Py_UnhandledKeyboardInterrupt) {
696 exitcode = exit_sigint();
697 }
698
699 return exitcode;
700 }
701
702
703 static int
pymain_main(_PyArgv * args)704 pymain_main(_PyArgv *args)
705 {
706 PyStatus status = pymain_init(args);
707 if (_PyStatus_IS_EXIT(status)) {
708 pymain_free();
709 return status.exitcode;
710 }
711 if (_PyStatus_EXCEPTION(status)) {
712 pymain_exit_error(status);
713 }
714
715 return Py_RunMain();
716 }
717
718
719 int
Py_Main(int argc,wchar_t ** argv)720 Py_Main(int argc, wchar_t **argv)
721 {
722 _PyArgv args = {
723 .argc = argc,
724 .use_bytes_argv = 0,
725 .bytes_argv = NULL,
726 .wchar_argv = argv};
727 return pymain_main(&args);
728 }
729
730
731 int
Py_BytesMain(int argc,char ** argv)732 Py_BytesMain(int argc, char **argv)
733 {
734 _PyArgv args = {
735 .argc = argc,
736 .use_bytes_argv = 1,
737 .bytes_argv = argv,
738 .wchar_argv = NULL};
739 return pymain_main(&args);
740 }
741
742 #ifdef __cplusplus
743 }
744 #endif
745