Line data Source code
1 : #include "Python.h"
2 : #include "pycore_fileutils.h" // DECODE_LOCALE_ERR
3 : #include "pycore_getopt.h" // _PyOS_GetOpt()
4 : #include "pycore_initconfig.h" // _PyArgv
5 : #include "pycore_pymem.h" // _PyMem_GetAllocatorName()
6 : #include "pycore_runtime.h" // _PyRuntime_Initialize()
7 :
8 : #include <locale.h> // setlocale()
9 : #include <stdlib.h> // getenv()
10 :
11 :
12 : /* Forward declarations */
13 : static void
14 : preconfig_copy(PyPreConfig *config, const PyPreConfig *config2);
15 :
16 :
17 : /* --- File system encoding/errors -------------------------------- */
18 :
19 : const char *Py_FileSystemDefaultEncoding = NULL;
20 : int Py_HasFileSystemDefaultEncoding = 0;
21 : const char *Py_FileSystemDefaultEncodeErrors = NULL;
22 : int _Py_HasFileSystemDefaultEncodeErrors = 0;
23 :
24 : void
25 6081 : _Py_ClearFileSystemEncoding(void)
26 : {
27 : _Py_COMP_DIAG_PUSH
28 : _Py_COMP_DIAG_IGNORE_DEPR_DECLS
29 6081 : if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) {
30 3122 : PyMem_RawFree((char*)Py_FileSystemDefaultEncoding);
31 3122 : Py_FileSystemDefaultEncoding = NULL;
32 : }
33 6081 : if (!_Py_HasFileSystemDefaultEncodeErrors && Py_FileSystemDefaultEncodeErrors) {
34 3122 : PyMem_RawFree((char*)Py_FileSystemDefaultEncodeErrors);
35 3122 : Py_FileSystemDefaultEncodeErrors = NULL;
36 : }
37 : _Py_COMP_DIAG_POP
38 6081 : }
39 :
40 :
41 : /* Set Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors
42 : global configuration variables to PyConfig.filesystem_encoding and
43 : PyConfig.filesystem_errors (encoded to UTF-8).
44 :
45 : Function called by _PyUnicode_InitEncodings(). */
46 : int
47 3130 : _Py_SetFileSystemEncoding(const char *encoding, const char *errors)
48 : {
49 3130 : char *encoding2 = _PyMem_RawStrdup(encoding);
50 3130 : if (encoding2 == NULL) {
51 0 : return -1;
52 : }
53 :
54 3130 : char *errors2 = _PyMem_RawStrdup(errors);
55 3130 : if (errors2 == NULL) {
56 0 : PyMem_RawFree(encoding2);
57 0 : return -1;
58 : }
59 :
60 3130 : _Py_ClearFileSystemEncoding();
61 :
62 : _Py_COMP_DIAG_PUSH
63 : _Py_COMP_DIAG_IGNORE_DEPR_DECLS
64 3130 : Py_FileSystemDefaultEncoding = encoding2;
65 3130 : Py_HasFileSystemDefaultEncoding = 0;
66 :
67 3130 : Py_FileSystemDefaultEncodeErrors = errors2;
68 3130 : _Py_HasFileSystemDefaultEncodeErrors = 0;
69 : _Py_COMP_DIAG_POP
70 3130 : return 0;
71 : }
72 :
73 :
74 : /* --- _PyArgv ---------------------------------------------------- */
75 :
76 : /* Decode bytes_argv using Py_DecodeLocale() */
77 : PyStatus
78 5928 : _PyArgv_AsWstrList(const _PyArgv *args, PyWideStringList *list)
79 : {
80 5928 : PyWideStringList wargv = _PyWideStringList_INIT;
81 5928 : if (args->use_bytes_argv) {
82 5868 : size_t size = sizeof(wchar_t*) * args->argc;
83 5868 : wargv.items = (wchar_t **)PyMem_RawMalloc(size);
84 5868 : if (wargv.items == NULL) {
85 0 : return _PyStatus_NO_MEMORY();
86 : }
87 :
88 42839 : for (Py_ssize_t i = 0; i < args->argc; i++) {
89 : size_t len;
90 36971 : wchar_t *arg = Py_DecodeLocale(args->bytes_argv[i], &len);
91 36971 : if (arg == NULL) {
92 0 : _PyWideStringList_Clear(&wargv);
93 0 : return DECODE_LOCALE_ERR("command line arguments", len);
94 : }
95 36971 : wargv.items[i] = arg;
96 36971 : wargv.length++;
97 : }
98 :
99 5868 : _PyWideStringList_Clear(list);
100 5868 : *list = wargv;
101 : }
102 : else {
103 60 : wargv.length = args->argc;
104 60 : wargv.items = (wchar_t **)args->wchar_argv;
105 60 : if (_PyWideStringList_Copy(list, &wargv) < 0) {
106 0 : return _PyStatus_NO_MEMORY();
107 : }
108 : }
109 5928 : return _PyStatus_OK();
110 : }
111 :
112 :
113 : /* --- _PyPreCmdline ------------------------------------------------- */
114 :
115 : void
116 6033 : _PyPreCmdline_Clear(_PyPreCmdline *cmdline)
117 : {
118 6033 : _PyWideStringList_Clear(&cmdline->argv);
119 6033 : _PyWideStringList_Clear(&cmdline->xoptions);
120 6033 : }
121 :
122 :
123 : PyStatus
124 3019 : _PyPreCmdline_SetArgv(_PyPreCmdline *cmdline, const _PyArgv *args)
125 : {
126 3019 : return _PyArgv_AsWstrList(args, &cmdline->argv);
127 : }
128 :
129 :
130 : static void
131 6140 : precmdline_get_preconfig(_PyPreCmdline *cmdline, const PyPreConfig *config)
132 : {
133 : #define COPY_ATTR(ATTR) \
134 : if (config->ATTR != -1) { \
135 : cmdline->ATTR = config->ATTR; \
136 : }
137 :
138 6140 : COPY_ATTR(isolated);
139 6140 : COPY_ATTR(use_environment);
140 6140 : COPY_ATTR(dev_mode);
141 :
142 : #undef COPY_ATTR
143 6140 : }
144 :
145 :
146 : static void
147 3091 : precmdline_set_preconfig(const _PyPreCmdline *cmdline, PyPreConfig *config)
148 : {
149 : #define COPY_ATTR(ATTR) \
150 : config->ATTR = cmdline->ATTR
151 :
152 3091 : COPY_ATTR(isolated);
153 3091 : COPY_ATTR(use_environment);
154 3091 : COPY_ATTR(dev_mode);
155 :
156 : #undef COPY_ATTR
157 3091 : }
158 :
159 :
160 : PyStatus
161 3049 : _PyPreCmdline_SetConfig(const _PyPreCmdline *cmdline, PyConfig *config)
162 : {
163 : #define COPY_ATTR(ATTR) \
164 : config->ATTR = cmdline->ATTR
165 :
166 3049 : PyStatus status = _PyWideStringList_Extend(&config->xoptions, &cmdline->xoptions);
167 3049 : if (_PyStatus_EXCEPTION(status)) {
168 0 : return status;
169 : }
170 :
171 3049 : COPY_ATTR(isolated);
172 3049 : COPY_ATTR(use_environment);
173 3049 : COPY_ATTR(dev_mode);
174 3049 : COPY_ATTR(warn_default_encoding);
175 3049 : return _PyStatus_OK();
176 :
177 : #undef COPY_ATTR
178 : }
179 :
180 :
181 : /* Parse the command line arguments */
182 : static PyStatus
183 5992 : precmdline_parse_cmdline(_PyPreCmdline *cmdline)
184 : {
185 5992 : const PyWideStringList *argv = &cmdline->argv;
186 :
187 5992 : _PyOS_ResetGetOpt();
188 : /* Don't log parsing errors into stderr here: PyConfig_Read()
189 : is responsible for that */
190 5992 : _PyOS_opterr = 0;
191 13743 : do {
192 19735 : int longindex = -1;
193 19735 : int c = _PyOS_GetOpt(argv->length, argv->items, &longindex);
194 :
195 19735 : if (c == EOF || c == 'c' || c == 'm') {
196 : break;
197 : }
198 :
199 13743 : switch (c) {
200 2385 : case 'E':
201 2385 : cmdline->use_environment = 0;
202 2385 : break;
203 :
204 1431 : case 'I':
205 1431 : cmdline->isolated = 1;
206 1431 : break;
207 :
208 2762 : case 'X':
209 : {
210 2762 : PyStatus status = PyWideStringList_Append(&cmdline->xoptions,
211 : _PyOS_optarg);
212 2762 : if (_PyStatus_EXCEPTION(status)) {
213 0 : return status;
214 : }
215 2762 : break;
216 : }
217 :
218 7165 : default:
219 : /* ignore other argument:
220 : handled by PyConfig_Read() */
221 7165 : break;
222 : }
223 : } while (1);
224 :
225 5992 : return _PyStatus_OK();
226 : }
227 :
228 :
229 : PyStatus
230 6140 : _PyPreCmdline_Read(_PyPreCmdline *cmdline, const PyPreConfig *preconfig)
231 : {
232 6140 : precmdline_get_preconfig(cmdline, preconfig);
233 :
234 6140 : if (preconfig->parse_argv) {
235 5992 : PyStatus status = precmdline_parse_cmdline(cmdline);
236 5992 : if (_PyStatus_EXCEPTION(status)) {
237 0 : return status;
238 : }
239 : }
240 :
241 : /* isolated, use_environment */
242 6140 : if (cmdline->isolated < 0) {
243 0 : cmdline->isolated = 0;
244 : }
245 6140 : if (cmdline->isolated > 0) {
246 1492 : cmdline->use_environment = 0;
247 : }
248 6140 : if (cmdline->use_environment < 0) {
249 0 : cmdline->use_environment = 0;
250 : }
251 :
252 : /* dev_mode */
253 6140 : if ((cmdline->dev_mode < 0)
254 2953 : && (_Py_get_xoption(&cmdline->xoptions, L"dev")
255 2930 : || _Py_GetEnv(cmdline->use_environment, "PYTHONDEVMODE")))
256 : {
257 26 : cmdline->dev_mode = 1;
258 : }
259 6140 : if (cmdline->dev_mode < 0) {
260 2927 : cmdline->dev_mode = 0;
261 : }
262 :
263 : // warn_default_encoding
264 6140 : if (_Py_get_xoption(&cmdline->xoptions, L"warn_default_encoding")
265 6134 : || _Py_GetEnv(cmdline->use_environment, "PYTHONWARNDEFAULTENCODING"))
266 : {
267 6 : cmdline->warn_default_encoding = 1;
268 : }
269 :
270 6140 : assert(cmdline->use_environment >= 0);
271 6140 : assert(cmdline->isolated >= 0);
272 6140 : assert(cmdline->dev_mode >= 0);
273 6140 : assert(cmdline->warn_default_encoding >= 0);
274 :
275 6140 : return _PyStatus_OK();
276 : }
277 :
278 :
279 : /* --- PyPreConfig ----------------------------------------------- */
280 :
281 :
282 : void
283 17969 : _PyPreConfig_InitCompatConfig(PyPreConfig *config)
284 : {
285 17969 : memset(config, 0, sizeof(*config));
286 :
287 17969 : config->_config_init = (int)_PyConfig_INIT_COMPAT;
288 17969 : config->parse_argv = 0;
289 17969 : config->isolated = -1;
290 17969 : config->use_environment = -1;
291 17969 : config->configure_locale = 1;
292 :
293 : /* bpo-36443: C locale coercion (PEP 538) and UTF-8 Mode (PEP 540)
294 : are disabled by default using the Compat configuration.
295 :
296 : Py_UTF8Mode=1 enables the UTF-8 mode. PYTHONUTF8 environment variable
297 : is ignored (even if use_environment=1). */
298 17969 : config->utf8_mode = 0;
299 17969 : config->coerce_c_locale = 0;
300 17969 : config->coerce_c_locale_warn = 0;
301 :
302 17969 : config->dev_mode = -1;
303 17969 : config->allocator = PYMEM_ALLOCATOR_NOT_SET;
304 : #ifdef MS_WINDOWS
305 : config->legacy_windows_fs_encoding = -1;
306 : #endif
307 17969 : }
308 :
309 :
310 : void
311 17881 : PyPreConfig_InitPythonConfig(PyPreConfig *config)
312 : {
313 17881 : _PyPreConfig_InitCompatConfig(config);
314 :
315 17881 : config->_config_init = (int)_PyConfig_INIT_PYTHON;
316 17881 : config->isolated = 0;
317 17881 : config->parse_argv = 1;
318 17881 : config->use_environment = 1;
319 : /* Set to -1 to enable C locale coercion (PEP 538) and UTF-8 Mode (PEP 540)
320 : depending on the LC_CTYPE locale, PYTHONUTF8 and PYTHONCOERCECLOCALE
321 : environment variables. */
322 17881 : config->coerce_c_locale = -1;
323 17881 : config->coerce_c_locale_warn = -1;
324 17881 : config->utf8_mode = -1;
325 : #ifdef MS_WINDOWS
326 : config->legacy_windows_fs_encoding = 0;
327 : #endif
328 17881 : }
329 :
330 :
331 : void
332 29 : PyPreConfig_InitIsolatedConfig(PyPreConfig *config)
333 : {
334 29 : _PyPreConfig_InitCompatConfig(config);
335 :
336 29 : config->_config_init = (int)_PyConfig_INIT_ISOLATED;
337 29 : config->configure_locale = 0;
338 29 : config->isolated = 1;
339 29 : config->use_environment = 0;
340 29 : config->utf8_mode = 0;
341 29 : config->dev_mode = 0;
342 : #ifdef MS_WINDOWS
343 : config->legacy_windows_fs_encoding = 0;
344 : #endif
345 29 : }
346 :
347 :
348 : PyStatus
349 12000 : _PyPreConfig_InitFromPreConfig(PyPreConfig *config,
350 : const PyPreConfig *config2)
351 : {
352 12000 : PyPreConfig_InitPythonConfig(config);
353 12000 : preconfig_copy(config, config2);
354 12000 : return _PyStatus_OK();
355 : }
356 :
357 :
358 : void
359 112 : _PyPreConfig_InitFromConfig(PyPreConfig *preconfig, const PyConfig *config)
360 : {
361 112 : _PyConfigInitEnum config_init = (_PyConfigInitEnum)config->_config_init;
362 112 : switch (config_init) {
363 30 : case _PyConfig_INIT_PYTHON:
364 30 : PyPreConfig_InitPythonConfig(preconfig);
365 30 : break;
366 27 : case _PyConfig_INIT_ISOLATED:
367 27 : PyPreConfig_InitIsolatedConfig(preconfig);
368 27 : break;
369 55 : case _PyConfig_INIT_COMPAT:
370 : default:
371 55 : _PyPreConfig_InitCompatConfig(preconfig);
372 : }
373 :
374 112 : _PyPreConfig_GetConfig(preconfig, config);
375 112 : }
376 :
377 :
378 : static void
379 24149 : preconfig_copy(PyPreConfig *config, const PyPreConfig *config2)
380 : {
381 : #define COPY_ATTR(ATTR) config->ATTR = config2->ATTR
382 :
383 24149 : COPY_ATTR(_config_init);
384 24149 : COPY_ATTR(parse_argv);
385 24149 : COPY_ATTR(isolated);
386 24149 : COPY_ATTR(use_environment);
387 24149 : COPY_ATTR(configure_locale);
388 24149 : COPY_ATTR(dev_mode);
389 24149 : COPY_ATTR(coerce_c_locale);
390 24149 : COPY_ATTR(coerce_c_locale_warn);
391 24149 : COPY_ATTR(utf8_mode);
392 24149 : COPY_ATTR(allocator);
393 : #ifdef MS_WINDOWS
394 : COPY_ATTR(legacy_windows_fs_encoding);
395 : #endif
396 :
397 : #undef COPY_ATTR
398 24149 : }
399 :
400 :
401 : PyObject*
402 41 : _PyPreConfig_AsDict(const PyPreConfig *config)
403 : {
404 : PyObject *dict;
405 :
406 41 : dict = PyDict_New();
407 41 : if (dict == NULL) {
408 0 : return NULL;
409 : }
410 :
411 : #define SET_ITEM_INT(ATTR) \
412 : do { \
413 : PyObject *obj = PyLong_FromLong(config->ATTR); \
414 : if (obj == NULL) { \
415 : goto fail; \
416 : } \
417 : int res = PyDict_SetItemString(dict, #ATTR, obj); \
418 : Py_DECREF(obj); \
419 : if (res < 0) { \
420 : goto fail; \
421 : } \
422 : } while (0)
423 :
424 41 : SET_ITEM_INT(_config_init);
425 41 : SET_ITEM_INT(parse_argv);
426 41 : SET_ITEM_INT(isolated);
427 41 : SET_ITEM_INT(use_environment);
428 41 : SET_ITEM_INT(configure_locale);
429 41 : SET_ITEM_INT(coerce_c_locale);
430 41 : SET_ITEM_INT(coerce_c_locale_warn);
431 41 : SET_ITEM_INT(utf8_mode);
432 : #ifdef MS_WINDOWS
433 : SET_ITEM_INT(legacy_windows_fs_encoding);
434 : #endif
435 41 : SET_ITEM_INT(dev_mode);
436 41 : SET_ITEM_INT(allocator);
437 41 : return dict;
438 :
439 0 : fail:
440 0 : Py_DECREF(dict);
441 0 : return NULL;
442 :
443 : #undef SET_ITEM_INT
444 : }
445 :
446 :
447 : void
448 3161 : _PyPreConfig_GetConfig(PyPreConfig *preconfig, const PyConfig *config)
449 : {
450 : #define COPY_ATTR(ATTR) \
451 : if (config->ATTR != -1) { \
452 : preconfig->ATTR = config->ATTR; \
453 : }
454 :
455 3161 : COPY_ATTR(parse_argv);
456 3161 : COPY_ATTR(isolated);
457 3161 : COPY_ATTR(use_environment);
458 3161 : COPY_ATTR(dev_mode);
459 :
460 : #undef COPY_ATTR
461 3161 : }
462 :
463 :
464 : static void
465 2984 : preconfig_get_global_vars(PyPreConfig *config)
466 : {
467 2984 : if (config->_config_init != _PyConfig_INIT_COMPAT) {
468 : /* Python and Isolated configuration ignore global variables */
469 2925 : return;
470 : }
471 :
472 : #define COPY_FLAG(ATTR, VALUE) \
473 : if (config->ATTR < 0) { \
474 : config->ATTR = VALUE; \
475 : }
476 : #define COPY_NOT_FLAG(ATTR, VALUE) \
477 : if (config->ATTR < 0) { \
478 : config->ATTR = !(VALUE); \
479 : }
480 :
481 : _Py_COMP_DIAG_PUSH
482 : _Py_COMP_DIAG_IGNORE_DEPR_DECLS
483 59 : COPY_FLAG(isolated, Py_IsolatedFlag);
484 59 : COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
485 59 : if (Py_UTF8Mode > 0) {
486 1 : config->utf8_mode = Py_UTF8Mode;
487 : }
488 : #ifdef MS_WINDOWS
489 : COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
490 : #endif
491 : _Py_COMP_DIAG_POP
492 :
493 : #undef COPY_FLAG
494 : #undef COPY_NOT_FLAG
495 : }
496 :
497 :
498 : static void
499 2983 : preconfig_set_global_vars(const PyPreConfig *config)
500 : {
501 : #define COPY_FLAG(ATTR, VAR) \
502 : if (config->ATTR >= 0) { \
503 : VAR = config->ATTR; \
504 : }
505 : #define COPY_NOT_FLAG(ATTR, VAR) \
506 : if (config->ATTR >= 0) { \
507 : VAR = !config->ATTR; \
508 : }
509 :
510 : _Py_COMP_DIAG_PUSH
511 : _Py_COMP_DIAG_IGNORE_DEPR_DECLS
512 2983 : COPY_FLAG(isolated, Py_IsolatedFlag);
513 2983 : COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
514 : #ifdef MS_WINDOWS
515 : COPY_FLAG(legacy_windows_fs_encoding, Py_LegacyWindowsFSEncodingFlag);
516 : #endif
517 2983 : COPY_FLAG(utf8_mode, Py_UTF8Mode);
518 : _Py_COMP_DIAG_POP
519 :
520 : #undef COPY_FLAG
521 : #undef COPY_NOT_FLAG
522 2983 : }
523 :
524 :
525 : const char*
526 46760 : _Py_GetEnv(int use_environment, const char *name)
527 : {
528 46760 : assert(use_environment >= 0);
529 :
530 46760 : if (!use_environment) {
531 22322 : return NULL;
532 : }
533 :
534 24438 : const char *var = getenv(name);
535 24438 : if (var && var[0] != '\0') {
536 451 : return var;
537 : }
538 : else {
539 23987 : return NULL;
540 : }
541 : }
542 :
543 :
544 : int
545 38 : _Py_str_to_int(const char *str, int *result)
546 : {
547 38 : const char *endptr = str;
548 38 : errno = 0;
549 38 : long value = strtol(str, (char **)&endptr, 10);
550 38 : if (*endptr != '\0' || errno == ERANGE) {
551 4 : return -1;
552 : }
553 34 : if (value < INT_MIN || value > INT_MAX) {
554 0 : return -1;
555 : }
556 :
557 34 : *result = (int)value;
558 34 : return 0;
559 : }
560 :
561 :
562 : void
563 7469 : _Py_get_env_flag(int use_environment, int *flag, const char *name)
564 : {
565 7469 : const char *var = _Py_GetEnv(use_environment, name);
566 7469 : if (!var) {
567 7438 : return;
568 : }
569 : int value;
570 31 : if (_Py_str_to_int(var, &value) < 0 || value < 0) {
571 : /* PYTHONDEBUG=text and PYTHONDEBUG=-2 behave as PYTHONDEBUG=1 */
572 4 : value = 1;
573 : }
574 31 : if (*flag < value) {
575 26 : *flag = value;
576 : }
577 : }
578 :
579 :
580 : const wchar_t*
581 36125 : _Py_get_xoption(const PyWideStringList *xoptions, const wchar_t *name)
582 : {
583 50737 : for (Py_ssize_t i=0; i < xoptions->length; i++) {
584 15914 : const wchar_t *option = xoptions->items[i];
585 : size_t len;
586 15914 : wchar_t *sep = wcschr(option, L'=');
587 15914 : if (sep != NULL) {
588 1370 : len = (sep - option);
589 : }
590 : else {
591 14544 : len = wcslen(option);
592 : }
593 15914 : if (wcsncmp(option, name, len) == 0 && name[len] == L'\0') {
594 1302 : return option;
595 : }
596 : }
597 34823 : return NULL;
598 : }
599 :
600 :
601 : static PyStatus
602 3091 : preconfig_init_utf8_mode(PyPreConfig *config, const _PyPreCmdline *cmdline)
603 : {
604 : #ifdef MS_WINDOWS
605 : if (config->legacy_windows_fs_encoding) {
606 : config->utf8_mode = 0;
607 : }
608 : #endif
609 :
610 3091 : if (config->utf8_mode >= 0) {
611 195 : return _PyStatus_OK();
612 : }
613 :
614 : const wchar_t *xopt;
615 2896 : xopt = _Py_get_xoption(&cmdline->xoptions, L"utf8");
616 2896 : if (xopt) {
617 132 : wchar_t *sep = wcschr(xopt, L'=');
618 132 : if (sep) {
619 93 : xopt = sep + 1;
620 93 : if (wcscmp(xopt, L"1") == 0) {
621 3 : config->utf8_mode = 1;
622 : }
623 90 : else if (wcscmp(xopt, L"0") == 0) {
624 90 : config->utf8_mode = 0;
625 : }
626 : else {
627 0 : return _PyStatus_ERR("invalid -X utf8 option value");
628 : }
629 : }
630 : else {
631 39 : config->utf8_mode = 1;
632 : }
633 132 : return _PyStatus_OK();
634 : }
635 :
636 2764 : const char *opt = _Py_GetEnv(config->use_environment, "PYTHONUTF8");
637 2764 : if (opt) {
638 11 : if (strcmp(opt, "1") == 0) {
639 9 : config->utf8_mode = 1;
640 : }
641 2 : else if (strcmp(opt, "0") == 0) {
642 1 : config->utf8_mode = 0;
643 : }
644 : else {
645 1 : return _PyStatus_ERR("invalid PYTHONUTF8 environment "
646 : "variable value");
647 : }
648 10 : return _PyStatus_OK();
649 : }
650 :
651 :
652 : #ifndef MS_WINDOWS
653 2753 : if (config->utf8_mode < 0) {
654 : /* The C locale and the POSIX locale enable the UTF-8 Mode (PEP 540) */
655 2753 : const char *ctype_loc = setlocale(LC_CTYPE, NULL);
656 2753 : if (ctype_loc != NULL
657 2753 : && (strcmp(ctype_loc, "C") == 0
658 2739 : || strcmp(ctype_loc, "POSIX") == 0))
659 : {
660 14 : config->utf8_mode = 1;
661 : }
662 : }
663 : #endif
664 :
665 2753 : if (config->utf8_mode < 0) {
666 2739 : config->utf8_mode = 0;
667 : }
668 2753 : return _PyStatus_OK();
669 : }
670 :
671 :
672 : static void
673 3091 : preconfig_init_coerce_c_locale(PyPreConfig *config)
674 : {
675 3091 : if (!config->configure_locale) {
676 31 : config->coerce_c_locale = 0;
677 31 : config->coerce_c_locale_warn = 0;
678 31 : return;
679 : }
680 :
681 3060 : const char *env = _Py_GetEnv(config->use_environment, "PYTHONCOERCECLOCALE");
682 3060 : if (env) {
683 145 : if (strcmp(env, "0") == 0) {
684 82 : if (config->coerce_c_locale < 0) {
685 57 : config->coerce_c_locale = 0;
686 : }
687 : }
688 63 : else if (strcmp(env, "warn") == 0) {
689 21 : if (config->coerce_c_locale_warn < 0) {
690 21 : config->coerce_c_locale_warn = 1;
691 : }
692 : }
693 : else {
694 42 : if (config->coerce_c_locale < 0) {
695 21 : config->coerce_c_locale = 1;
696 : }
697 : }
698 : }
699 :
700 : /* Test if coerce_c_locale equals to -1 or equals to 1:
701 : PYTHONCOERCECLOCALE=1 doesn't imply that the C locale is always coerced.
702 : It is only coerced if if the LC_CTYPE locale is "C". */
703 3060 : if (config->coerce_c_locale < 0 || config->coerce_c_locale == 1) {
704 : /* The C locale enables the C locale coercion (PEP 538) */
705 2838 : if (_Py_LegacyLocaleDetected(0)) {
706 48 : config->coerce_c_locale = 2;
707 : }
708 : else {
709 2790 : config->coerce_c_locale = 0;
710 : }
711 : }
712 :
713 3060 : if (config->coerce_c_locale_warn < 0) {
714 2980 : config->coerce_c_locale_warn = 0;
715 : }
716 : }
717 :
718 :
719 : static PyStatus
720 3090 : preconfig_init_allocator(PyPreConfig *config)
721 : {
722 3090 : if (config->allocator == PYMEM_ALLOCATOR_NOT_SET) {
723 : /* bpo-34247. The PYTHONMALLOC environment variable has the priority
724 : over PYTHONDEV env var and "-X dev" command line option.
725 : For example, PYTHONMALLOC=malloc PYTHONDEVMODE=1 sets the memory
726 : allocators to "malloc" (and not to "debug"). */
727 3089 : const char *envvar = _Py_GetEnv(config->use_environment, "PYTHONMALLOC");
728 3089 : if (envvar) {
729 : PyMemAllocatorName name;
730 11 : if (_PyMem_GetAllocatorName(envvar, &name) < 0) {
731 0 : return _PyStatus_ERR("PYTHONMALLOC: unknown allocator");
732 : }
733 11 : config->allocator = (int)name;
734 : }
735 : }
736 :
737 3090 : if (config->dev_mode && config->allocator == PYMEM_ALLOCATOR_NOT_SET) {
738 27 : config->allocator = PYMEM_ALLOCATOR_DEBUG;
739 : }
740 3090 : return _PyStatus_OK();
741 : }
742 :
743 :
744 : static PyStatus
745 3091 : preconfig_read(PyPreConfig *config, _PyPreCmdline *cmdline)
746 : {
747 : PyStatus status;
748 :
749 3091 : status = _PyPreCmdline_Read(cmdline, config);
750 3091 : if (_PyStatus_EXCEPTION(status)) {
751 0 : return status;
752 : }
753 :
754 3091 : precmdline_set_preconfig(cmdline, config);
755 :
756 : /* legacy_windows_fs_encoding, coerce_c_locale, utf8_mode */
757 : #ifdef MS_WINDOWS
758 : _Py_get_env_flag(config->use_environment,
759 : &config->legacy_windows_fs_encoding,
760 : "PYTHONLEGACYWINDOWSFSENCODING");
761 : #endif
762 :
763 3091 : preconfig_init_coerce_c_locale(config);
764 :
765 3091 : status = preconfig_init_utf8_mode(config, cmdline);
766 3091 : if (_PyStatus_EXCEPTION(status)) {
767 1 : return status;
768 : }
769 :
770 : /* allocator */
771 3090 : status = preconfig_init_allocator(config);
772 3090 : if (_PyStatus_EXCEPTION(status)) {
773 0 : return status;
774 : }
775 :
776 3090 : assert(config->coerce_c_locale >= 0);
777 3090 : assert(config->coerce_c_locale_warn >= 0);
778 : #ifdef MS_WINDOWS
779 : assert(config->legacy_windows_fs_encoding >= 0);
780 : #endif
781 3090 : assert(config->utf8_mode >= 0);
782 3090 : assert(config->isolated >= 0);
783 3090 : assert(config->use_environment >= 0);
784 3090 : assert(config->dev_mode >= 0);
785 :
786 3090 : return _PyStatus_OK();
787 : }
788 :
789 :
790 : /* Read the configuration from:
791 :
792 : - command line arguments
793 : - environment variables
794 : - Py_xxx global configuration variables
795 : - the LC_CTYPE locale */
796 : PyStatus
797 2984 : _PyPreConfig_Read(PyPreConfig *config, const _PyArgv *args)
798 : {
799 : PyStatus status;
800 :
801 2984 : status = _PyRuntime_Initialize();
802 2984 : if (_PyStatus_EXCEPTION(status)) {
803 0 : return status;
804 : }
805 :
806 2984 : preconfig_get_global_vars(config);
807 :
808 : /* Copy LC_CTYPE locale, since it's modified later */
809 2984 : const char *loc = setlocale(LC_CTYPE, NULL);
810 2984 : if (loc == NULL) {
811 0 : return _PyStatus_ERR("failed to LC_CTYPE locale");
812 : }
813 2984 : char *init_ctype_locale = _PyMem_RawStrdup(loc);
814 2984 : if (init_ctype_locale == NULL) {
815 0 : return _PyStatus_NO_MEMORY();
816 : }
817 :
818 : /* Save the config to be able to restore it if encodings change */
819 : PyPreConfig save_config;
820 :
821 2984 : status = _PyPreConfig_InitFromPreConfig(&save_config, config);
822 2984 : if (_PyStatus_EXCEPTION(status)) {
823 0 : return status;
824 : }
825 :
826 : /* Set LC_CTYPE to the user preferred locale */
827 2984 : if (config->configure_locale) {
828 2954 : _Py_SetLocaleFromEnv(LC_CTYPE);
829 : }
830 :
831 : PyPreConfig save_runtime_config;
832 2984 : preconfig_copy(&save_runtime_config, &_PyRuntime.preconfig);
833 :
834 2984 : _PyPreCmdline cmdline = _PyPreCmdline_INIT;
835 2984 : int locale_coerced = 0;
836 2984 : int loops = 0;
837 :
838 107 : while (1) {
839 3091 : int utf8_mode = config->utf8_mode;
840 :
841 : /* Watchdog to prevent an infinite loop */
842 3091 : loops++;
843 3091 : if (loops == 3) {
844 0 : status = _PyStatus_ERR("Encoding changed twice while "
845 : "reading the configuration");
846 0 : goto done;
847 : }
848 :
849 : /* bpo-34207: Py_DecodeLocale() and Py_EncodeLocale() depend
850 : on the utf8_mode and legacy_windows_fs_encoding members
851 : of _PyRuntime.preconfig. */
852 3091 : preconfig_copy(&_PyRuntime.preconfig, config);
853 :
854 3091 : if (args) {
855 : // Set command line arguments at each iteration. If they are bytes
856 : // strings, they are decoded from the new encoding.
857 3019 : status = _PyPreCmdline_SetArgv(&cmdline, args);
858 3019 : if (_PyStatus_EXCEPTION(status)) {
859 0 : goto done;
860 : }
861 : }
862 :
863 3091 : status = preconfig_read(config, &cmdline);
864 3091 : if (_PyStatus_EXCEPTION(status)) {
865 1 : goto done;
866 : }
867 :
868 : /* The legacy C locale assumes ASCII as the default text encoding, which
869 : * causes problems not only for the CPython runtime, but also other
870 : * components like GNU readline.
871 : *
872 : * Accordingly, when the CLI detects it, it attempts to coerce it to a
873 : * more capable UTF-8 based alternative.
874 : *
875 : * See the documentation of the PYTHONCOERCECLOCALE setting for more
876 : * details.
877 : */
878 3090 : int encoding_changed = 0;
879 3090 : if (config->coerce_c_locale && !locale_coerced) {
880 48 : locale_coerced = 1;
881 48 : _Py_CoerceLegacyLocale(0);
882 48 : encoding_changed = 1;
883 : }
884 :
885 3090 : if (utf8_mode == -1) {
886 2895 : if (config->utf8_mode == 1) {
887 : /* UTF-8 Mode enabled */
888 65 : encoding_changed = 1;
889 : }
890 : }
891 : else {
892 195 : if (config->utf8_mode != utf8_mode) {
893 0 : encoding_changed = 1;
894 : }
895 : }
896 :
897 3090 : if (!encoding_changed) {
898 2983 : break;
899 : }
900 :
901 : /* Reset the configuration before reading again the configuration,
902 : just keep UTF-8 Mode and coerce C locale value. */
903 107 : int new_utf8_mode = config->utf8_mode;
904 107 : int new_coerce_c_locale = config->coerce_c_locale;
905 107 : preconfig_copy(config, &save_config);
906 107 : config->utf8_mode = new_utf8_mode;
907 107 : config->coerce_c_locale = new_coerce_c_locale;
908 :
909 : /* The encoding changed: read again the configuration
910 : with the new encoding */
911 : }
912 2983 : status = _PyStatus_OK();
913 :
914 2984 : done:
915 : // Revert side effects
916 2984 : setlocale(LC_CTYPE, init_ctype_locale);
917 2984 : PyMem_RawFree(init_ctype_locale);
918 2984 : preconfig_copy(&_PyRuntime.preconfig, &save_runtime_config);
919 2984 : _PyPreCmdline_Clear(&cmdline);
920 2984 : return status;
921 : }
922 :
923 :
924 : /* Write the pre-configuration:
925 :
926 : - set the memory allocators
927 : - set Py_xxx global configuration variables
928 : - set the LC_CTYPE locale (coerce C locale, PEP 538) and set the UTF-8 mode
929 : (PEP 540)
930 :
931 : The applied configuration is written into _PyRuntime.preconfig.
932 : If the C locale cannot be coerced, set coerce_c_locale to 0.
933 :
934 : Do nothing if called after Py_Initialize(): ignore the new
935 : pre-configuration. */
936 : PyStatus
937 2983 : _PyPreConfig_Write(const PyPreConfig *src_config)
938 : {
939 : PyPreConfig config;
940 :
941 2983 : PyStatus status = _PyPreConfig_InitFromPreConfig(&config, src_config);
942 2983 : if (_PyStatus_EXCEPTION(status)) {
943 0 : return status;
944 : }
945 :
946 2983 : if (_PyRuntime.core_initialized) {
947 : /* bpo-34008: Calling this functions after Py_Initialize() ignores
948 : the new configuration. */
949 0 : return _PyStatus_OK();
950 : }
951 :
952 2983 : PyMemAllocatorName name = (PyMemAllocatorName)config.allocator;
953 2983 : if (name != PYMEM_ALLOCATOR_NOT_SET) {
954 38 : if (_PyMem_SetupAllocators(name) < 0) {
955 0 : return _PyStatus_ERR("Unknown PYTHONMALLOC allocator");
956 : }
957 : }
958 :
959 2983 : preconfig_set_global_vars(&config);
960 :
961 2983 : if (config.configure_locale) {
962 2953 : if (config.coerce_c_locale) {
963 48 : if (!_Py_CoerceLegacyLocale(config.coerce_c_locale_warn)) {
964 : /* C locale not coerced */
965 0 : config.coerce_c_locale = 0;
966 : }
967 : }
968 :
969 : /* Set LC_CTYPE to the user preferred locale */
970 2953 : _Py_SetLocaleFromEnv(LC_CTYPE);
971 : }
972 :
973 : /* Write the new pre-configuration into _PyRuntime */
974 2983 : preconfig_copy(&_PyRuntime.preconfig, &config);
975 :
976 2983 : return _PyStatus_OK();
977 : }
|
