#include "Python.h"

#include "osdefs.h"

#include <locale.h>

#ifdef MS_WINDOWS

# include <malloc.h>

# include <windows.h>

extern int winerror_to_errno(int);

#endif

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#endif

#ifdef HAVE_SYS_IOCTL_H

#include <sys/ioctl.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif /* HAVE_FCNTL_H */

#ifdef O_CLOEXEC

/* Does open() support the O_CLOEXEC flag? Possible values:

-1: unknown

0: open() ignores O_CLOEXEC flag, ex: Linux kernel older than 2.6.23

1: open() supports O_CLOEXEC flag, close-on-exec is set

The flag is used by _Py_open(), _Py_open_noraise(), io.FileIO

and os.open(). */

int _Py_open_cloexec_works = -1;

#endif

PyObject *

_Py_device_encoding(int fd)

{

#if defined(MS_WINDOWS)

UINT cp;

#endif

int valid;

_Py_BEGIN_SUPPRESS_IPH

valid = isatty(fd);

_Py_END_SUPPRESS_IPH

if (!valid)

Py_RETURN_NONE;

#if defined(MS_WINDOWS)

if (fd == 0)

cp = GetConsoleCP();

else if (fd == 1 || fd == 2)

cp = GetConsoleOutputCP();

else

cp = 0;

/* GetConsoleCP() and GetConsoleOutputCP() return 0 if the application

has no console */

if (cp != 0)

return PyUnicode_FromFormat("cp%u", (unsigned int)cp);

#elif defined(CODESET)

{

char *codeset = nl_langinfo(CODESET);

if (codeset != NULL && codeset[0] != 0)

return PyUnicode_FromString(codeset);

}

#endif

Py_RETURN_NONE;

}

#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(MS_WINDOWS)

#define USE_FORCE_ASCII

extern int _Py_normalize_encoding(const char *, char *, size_t);

/* Workaround FreeBSD and OpenIndiana locale encoding issue with the C locale.

On these operating systems, nl_langinfo(CODESET) announces an alias of the

ASCII encoding, whereas mbstowcs() and wcstombs() functions use the

ISO-8859-1 encoding. The problem is that os.fsencode() and os.fsdecode() use

locale.getpreferredencoding() codec. For example, if command line arguments

are decoded by mbstowcs() and encoded back by os.fsencode(), we get a

UnicodeEncodeError instead of retrieving the original byte string.

The workaround is enabled if setlocale(LC_CTYPE, NULL) returns "C",

nl_langinfo(CODESET) announces "ascii" (or an alias to ASCII), and at least

one byte in range 0x80-0xff can be decoded from the locale encoding. The

workaround is also enabled on error, for example if getting the locale

failed.

Values of force_ascii:

1: the workaround is used: Py_EncodeLocale() uses

encode_ascii_surrogateescape() and Py_DecodeLocale() uses

decode_ascii()

0: the workaround is not used: Py_EncodeLocale() uses wcstombs() and

Py_DecodeLocale() uses mbstowcs()

-1: unknown, need to call check_force_ascii() to get the value

*/

static int force_ascii = -1;

static int

check_force_ascii(void)

{

char *loc;

#if defined(HAVE_LANGINFO_H) && defined(CODESET)

char *codeset, **alias;

char encoding[20]; /* longest name: "iso_646.irv_1991\0" */

int is_ascii;

unsigned int i;

char* ascii_aliases[] = {

"ascii",

/* Aliases from Lib/encodings/aliases.py */

"646",

"ansi_x3.4_1968",

"ansi_x3.4_1986",

"ansi_x3_4_1968",

"cp367",

"csascii",

"ibm367",

"iso646_us",

"iso_646.irv_1991",

"iso_ir_6",

"us",

"us_ascii",

NULL

};

#endif

loc = setlocale(LC_CTYPE, NULL);

if (loc == NULL)

goto error;

if (strcmp(loc, "C") != 0) {

/* the LC_CTYPE locale is different than C */

return 0;

}

#if defined(HAVE_LANGINFO_H) && defined(CODESET)

codeset = nl_langinfo(CODESET);

if (!codeset || codeset[0] == '\0') {

/* CODESET is not set or empty */

goto error;

}

if (!_Py_normalize_encoding(codeset, encoding, sizeof(encoding)))

goto error;

is_ascii = 0;

for (alias=ascii_aliases; *alias != NULL; alias++) {

if (strcmp(encoding, *alias) == 0) {

is_ascii = 1;

break;

}

}

if (!is_ascii) {

/* nl_langinfo(CODESET) is not "ascii" or an alias of ASCII */

return 0;

}

for (i=0x80; i<0xff; i++) {

unsigned char ch;

wchar_t wch;

size_t res;

ch = (unsigned char)i;

res = mbstowcs(&wch, (char*)&ch, 1);

if (res != (size_t)-1) {

/* decoding a non-ASCII character from the locale encoding succeed:

the locale encoding is not ASCII, force ASCII */

return 1;

}

}

/* None of the bytes in the range 0x80-0xff can be decoded from the locale

encoding: the locale encoding is really ASCII */

return 0;

#else

/* nl_langinfo(CODESET) is not available: always force ASCII */

return 1;

#endif

error:

/* if an error occurred, force the ASCII encoding */

return 1;

}

static int

encode_ascii(const wchar_t *text, char **str,

size_t *error_pos, const char **reason,

int raw_malloc, int surrogateescape)

{

char *result = NULL, *out;

size_t len, i;

wchar_t ch;

len = wcslen(text);

/* +1 for NULL byte */

if (raw_malloc) {

result = PyMem_RawMalloc(len + 1);

}

else {

result = PyMem_Malloc(len + 1);

}

if (result == NULL) {

return -1;

}

out = result;

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

ch = text[i];

if (ch <= 0x7f) {

/* ASCII character */

*out++ = (char)ch;

}

else if (surrogateescape && 0xdc80 <= ch && ch <= 0xdcff) {

/* UTF-8b surrogate */

*out++ = (char)(ch - 0xdc00);

}

else {

if (raw_malloc) {

PyMem_RawFree(result);

}

else {

PyMem_Free(result);

}

if (error_pos != NULL) {

*error_pos = i;

}

if (reason) {

*reason = "encoding error";

}

return -2;

}

}

*out = '\0';

*str = result;

return 0;

}

#endif /* !defined(__APPLE__) && !defined(__ANDROID__) && !defined(MS_WINDOWS) */

#if !defined(HAVE_MBRTOWC) || defined(USE_FORCE_ASCII)

static int

decode_ascii(const char *arg, wchar_t **wstr, size_t *wlen,

const char **reason, int surrogateescape)

{

wchar_t *res;

unsigned char *in;

wchar_t *out;

size_t argsize = strlen(arg) + 1;

if (argsize > PY_SSIZE_T_MAX / sizeof(wchar_t)) {

return -1;

}

res = PyMem_RawMalloc(argsize * sizeof(wchar_t));

if (!res) {

return -1;

}

out = res;

for (in = (unsigned char*)arg; *in; in++) {

unsigned char ch = *in;

if (ch < 128) {

*out++ = ch;

}

else {

if (!surrogateescape) {

PyMem_RawFree(res);

if (wlen) {

*wlen = in - (unsigned char*)arg;

}

if (reason) {

*reason = "decoding error";

}

return -2;

}

*out++ = 0xdc00 + ch;

}

}

*out = 0;

if (wlen != NULL) {

*wlen = out - res;

}

*wstr = res;

return 0;

}

#endif /* !HAVE_MBRTOWC */

static int

decode_current_locale(const char* arg, wchar_t **wstr, size_t *wlen,

const char **reason, int surrogateescape)

{

wchar_t *res;

size_t argsize;

size_t count;

#ifdef HAVE_MBRTOWC

unsigned char *in;

wchar_t *out;

mbstate_t mbs;

#endif

#ifdef HAVE_BROKEN_MBSTOWCS

/* Some platforms have a broken implementation of

* mbstowcs which does not count the characters that

* would result from conversion. Use an upper bound.

*/

argsize = strlen(arg);

#else

argsize = mbstowcs(NULL, arg, 0);

#endif

if (argsize != (size_t)-1) {

if (argsize > PY_SSIZE_T_MAX / sizeof(wchar_t) - 1) {

return -1;

}

res = (wchar_t *)PyMem_RawMalloc((argsize + 1) * sizeof(wchar_t));

if (!res) {

return -1;

}

count = mbstowcs(res, arg, argsize + 1);

if (count != (size_t)-1) {

wchar_t *tmp;

/* Only use the result if it contains no

surrogate characters. */

for (tmp = res; *tmp != 0 &&

!Py_UNICODE_IS_SURROGATE(*tmp); tmp++)

;

if (*tmp == 0) {

if (wlen != NULL) {

*wlen = count;

}

*wstr = res;

return 0;

}

}

PyMem_RawFree(res);

}

/* Conversion failed. Fall back to escaping with surrogateescape. */

#ifdef HAVE_MBRTOWC

/* Try conversion with mbrtwoc (C99), and escape non-decodable bytes. */

/* Overallocate; as multi-byte characters are in the argument, the

actual output could use less memory. */

argsize = strlen(arg) + 1;

if (argsize > PY_SSIZE_T_MAX / sizeof(wchar_t)) {

return -1;

}

res = (wchar_t*)PyMem_RawMalloc(argsize * sizeof(wchar_t));

if (!res) {

return -1;

}

in = (unsigned char*)arg;

out = res;

memset(&mbs, 0, sizeof mbs);

while (argsize) {

size_t converted = mbrtowc(out, (char*)in, argsize, &mbs);

if (converted == 0) {

/* Reached end of string; null char stored. */

break;

}

if (converted == (size_t)-2) {

/* Incomplete character. This should never happen,

since we provide everything that we have -

unless there is a bug in the C library, or I

misunderstood how mbrtowc works. */

goto decode_error;

}

if (converted == (size_t)-1) {

if (!surrogateescape) {

goto decode_error;

}

/* Conversion error. Escape as UTF-8b, and start over

in the initial shift state. */

*out++ = 0xdc00 + *in++;

argsize--;

memset(&mbs, 0, sizeof mbs);

continue;

}

if (Py_UNICODE_IS_SURROGATE(*out)) {

if (!surrogateescape) {

goto decode_error;

}

/* Surrogate character. Escape the original

byte sequence with surrogateescape. */

argsize -= converted;

while (converted--) {

*out++ = 0xdc00 + *in++;

}

continue;

}

/* successfully converted some bytes */

in += converted;

argsize -= converted;

out++;

}

if (wlen != NULL) {

*wlen = out - res;

}

*wstr = res;

return 0;

decode_error:

PyMem_RawFree(res);

if (wlen) {

*wlen = in - (unsigned char*)arg;

}

if (reason) {

*reason = "decoding error";

}

return -2;

#else /* HAVE_MBRTOWC */

/* Cannot use C locale for escaping; manually escape as if charset

is ASCII (i.e. escape all bytes > 128. This will still roundtrip

correctly in the locale's charset, which must be an ASCII superset. */

return decode_ascii(arg, wstr, wlen, reason, surrogateescape);

#endif /* HAVE_MBRTOWC */

}

/* Decode a byte string from the locale encoding.

Use the strict error handler if 'surrogateescape' is zero. Use the

surrogateescape error handler if 'surrogateescape' is non-zero: undecodable

bytes are decoded as characters in range U+DC80..U+DCFF. If a byte sequence

can be decoded as a surrogate character, escape the bytes using the

surrogateescape error handler instead of decoding them.

On sucess, return 0 and write the newly allocated wide character string into

*wstr (use PyMem_RawFree() to free the memory). If wlen is not NULL, write

the number of wide characters excluding the null character into *wlen.

On memory allocation failure, return -1.

On decoding error, return -2. If wlen is not NULL, write the start of

invalid byte sequence in the input string into *wlen. If reason is not NULL,

write the decoding error message into *reason.

Use the Py_EncodeLocaleEx() function to encode the character string back to

a byte string. */

int

_Py_DecodeLocaleEx(const char* arg, wchar_t **wstr, size_t *wlen,

const char **reason,

int current_locale, int surrogateescape)

{

if (current_locale) {

#ifdef __ANDROID__

return _Py_DecodeUTF8Ex(arg, strlen(arg), wstr, wlen, reason,

surrogateescape);

#else

return decode_current_locale(arg, wstr, wlen, reason, surrogateescape);

#endif

}

#if defined(__APPLE__) || defined(__ANDROID__)

return _Py_DecodeUTF8Ex(arg, strlen(arg), wstr, wlen, reason,

surrogateescape);

#else

if (Py_UTF8Mode == 1) {

return _Py_DecodeUTF8Ex(arg, strlen(arg), wstr, wlen, reason,

surrogateescape);

}

#ifdef USE_FORCE_ASCII

if (force_ascii == -1) {

force_ascii = check_force_ascii();

}

if (force_ascii) {

/* force ASCII encoding to workaround mbstowcs() issue */

return decode_ascii(arg, wstr, wlen, reason, surrogateescape);

}

#endif

return decode_current_locale(arg, wstr, wlen, reason, surrogateescape);

#endif /* __APPLE__ or __ANDROID__ */

}

/* Decode a byte string from the locale encoding with the

surrogateescape error handler: undecodable bytes are decoded as characters

in range U+DC80..U+DCFF. If a byte sequence can be decoded as a surrogate

character, escape the bytes using the surrogateescape error handler instead

of decoding them.

Return a pointer to a newly allocated wide character string, use

PyMem_RawFree() to free the memory. If size is not NULL, write the number of

wide characters excluding the null character into *size

Return NULL on decoding error or memory allocation error. If *size* is not

NULL, *size is set to (size_t)-1 on memory error or set to (size_t)-2 on

decoding error.

Decoding errors should never happen, unless there is a bug in the C

library.

Use the Py_EncodeLocale() function to encode the character string back to a

byte string. */

wchar_t*

Py_DecodeLocale(const char* arg, size_t *wlen)

{

wchar_t *wstr;

int res = _Py_DecodeLocaleEx(arg, &wstr, wlen, NULL, 0, 1);

if (res != 0) {

if (wlen != NULL) {

*wlen = (size_t)res;

}

return NULL;

}

return wstr;

}

static int

encode_current_locale(const wchar_t *text, char **str,

size_t *error_pos, const char **reason,

int raw_malloc, int surrogateescape)

{

const size_t len = wcslen(text);

char *result = NULL, *bytes = NULL;

size_t i, size, converted;

wchar_t c, buf[2];

/* The function works in two steps:

1. compute the length of the output buffer in bytes (size)

2. outputs the bytes */

size = 0;

buf[1] = 0;

while (1) {

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

c = text[i];

if (c >= 0xdc80 && c <= 0xdcff) {

if (!surrogateescape) {

goto encode_error;

}

/* UTF-8b surrogate */

if (bytes != NULL) {

*bytes++ = c - 0xdc00;

size--;

}

else {

size++;

}

continue;

}

else {

buf[0] = c;

if (bytes != NULL) {

converted = wcstombs(bytes, buf, size);

}

else {

converted = wcstombs(NULL, buf, 0);

}

if (converted == (size_t)-1) {

goto encode_error;

}

if (bytes != NULL) {

bytes += converted;

size -= converted;

}

else {

size += converted;

}

}

}

if (result != NULL) {

*bytes = '\0';

break;

}

size += 1; /* nul byte at the end */

if (raw_malloc) {

result = PyMem_RawMalloc(size);

}

else {

result = PyMem_Malloc(size);

}

if (result == NULL) {

return -1;

}

bytes = result;

}

*str = result;

return 0;

encode_error:

if (raw_malloc) {

PyMem_RawFree(result);

}

else {

PyMem_Free(result);

}

if (error_pos != NULL) {

*error_pos = i;

}

if (reason) {

*reason = "encoding error";

}

return -2;

}

static int

encode_locale_ex(const wchar_t *text, char **str, size_t *error_pos,

const char **reason,

int raw_malloc, int current_locale, int surrogateescape)

{

if (current_locale) {

#ifdef __ANDROID__

return _Py_EncodeUTF8Ex(text, str, error_pos, reason,

raw_malloc, surrogateescape);

#else

return encode_current_locale(text, str, error_pos, reason,

raw_malloc, surrogateescape);

#endif

}

#if defined(__APPLE__) || defined(__ANDROID__)

return _Py_EncodeUTF8Ex(text, str, error_pos, reason,

raw_malloc, surrogateescape);

#else /* __APPLE__ */

if (Py_UTF8Mode == 1) {

return _Py_EncodeUTF8Ex(text, str, error_pos, reason,

raw_malloc, surrogateescape);

}

#ifdef USE_FORCE_ASCII

if (force_ascii == -1) {

force_ascii = check_force_ascii();

}

if (force_ascii) {

return encode_ascii(text, str, error_pos, reason,

raw_malloc, surrogateescape);

}

#endif

return encode_current_locale(text, str, error_pos, reason,

raw_malloc, surrogateescape);

#endif /* __APPLE__ or __ANDROID__ */

}

static char*

encode_locale(const wchar_t *text, size_t *error_pos,

int raw_malloc, int current_locale)

{

char *str;

int res = encode_locale_ex(text, &str, error_pos, NULL,

raw_malloc, current_locale, 1);

if (res != -2 && error_pos) {

*error_pos = (size_t)-1;

}

if (res != 0) {

return NULL;

}

return str;

}

/* Encode a wide character string to the locale encoding with the

surrogateescape error handler: surrogate characters in the range

U+DC80..U+DCFF are converted to bytes 0x80..0xFF.

Return a pointer to a newly allocated byte string, use PyMem_Free() to free

the memory. Return NULL on encoding or memory allocation error.

If error_pos is not NULL, *error_pos is set to (size_t)-1 on success, or set

to the index of the invalid character on encoding error.

Use the Py_DecodeLocale() function to decode the bytes string back to a wide

character string. */

char*

Py_EncodeLocale(const wchar_t *text, size_t *error_pos)

{

return encode_locale(text, error_pos, 0, 0);

}

/* Similar to Py_EncodeLocale(), but result must be freed by PyMem_RawFree()

instead of PyMem_Free(). */

char*

_Py_EncodeLocaleRaw(const wchar_t *text, size_t *error_pos)

{

return encode_locale(text, error_pos, 1, 0);

}

int

_Py_EncodeLocaleEx(const wchar_t *text, char **str,

size_t *error_pos, const char **reason,

int current_locale, int surrogateescape)

{

return encode_locale_ex(text, str, error_pos, reason, 1,

current_locale, surrogateescape);

}

#ifdef MS_WINDOWS

static __int64 secs_between_epochs = 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */

static void

FILE_TIME_to_time_t_nsec(FILETIME *in_ptr, time_t *time_out, int* nsec_out)

{

/* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */

/* Cannot simply cast and dereference in_ptr,

since it might not be aligned properly */

__int64 in;

memcpy(&in, in_ptr, sizeof(in));

*nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */

*time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, time_t);

}

void

_Py_time_t_to_FILE_TIME(time_t time_in, int nsec_in, FILETIME *out_ptr)

{

/* XXX endianness */

__int64 out;

out = time_in + secs_between_epochs;

out = out * 10000000 + nsec_in / 100;

memcpy(out_ptr, &out, sizeof(out));

}

/* Below, we *know* that ugo+r is 0444 */

#if _S_IREAD != 0400

#error Unsupported C library

#endif

static int

attributes_to_mode(DWORD attr)

{

int m = 0;

if (attr & FILE_ATTRIBUTE_DIRECTORY)

m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */

else

m |= _S_IFREG;

if (attr & FILE_ATTRIBUTE_READONLY)

m |= 0444;

else

m |= 0666;

return m;

}

void

_Py_attribute_data_to_stat(BY_HANDLE_FILE_INFORMATION *info, ULONG reparse_tag,

struct _Py_stat_struct *result)

{

memset(result, 0, sizeof(*result));

result->st_mode = attributes_to_mode(info->dwFileAttributes);

result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow;

result->st_dev = info->dwVolumeSerialNumber;

result->st_rdev = result->st_dev;

FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);

FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);

FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);

result->st_nlink = info->nNumberOfLinks;

result->st_ino = (((uint64_t)info->nFileIndexHigh) << 32) + info->nFileIndexLow;

if (reparse_tag == IO_REPARSE_TAG_SYMLINK) {

/* first clear the S_IFMT bits */

result->st_mode ^= (result->st_mode & S_IFMT);

/* now set the bits that make this a symlink */

result->st_mode |= S_IFLNK;

}

result->st_file_attributes = info->dwFileAttributes;

}

#endif

/* Return information about a file.

On POSIX, use fstat().

On Windows, use GetFileType() and GetFileInformationByHandle() which support

files larger than 2 GiB. fstat() may fail with EOVERFLOW on files larger

than 2 GiB because the file size type is a signed 32-bit integer: see issue

#23152.

On Windows, set the last Windows error and return nonzero on error. On

POSIX, set errno and return nonzero on error. Fill status and return 0 on

success. */

int

_Py_fstat_noraise(int fd, struct _Py_stat_struct *status)

{

#ifdef MS_WINDOWS

BY_HANDLE_FILE_INFORMATION info;

HANDLE h;

int type;

_Py_BEGIN_SUPPRESS_IPH

h = (HANDLE)_get_osfhandle(fd);

_Py_END_SUPPRESS_IPH

if (h == INVALID_HANDLE_VALUE) {

/* errno is already set by _get_osfhandle, but we also set

the Win32 error for callers who expect that */

SetLastError(ERROR_INVALID_HANDLE);

return -1;

}

memset(status, 0, sizeof(*status));

type = GetFileType(h);

if (type == FILE_TYPE_UNKNOWN) {

DWORD error = GetLastError();

if (error != 0) {

errno = winerror_to_errno(error);

return -1;

}

/* else: valid but unknown file */

}

if (type != FILE_TYPE_DISK) {

if (type == FILE_TYPE_CHAR)

status->st_mode = _S_IFCHR;

else if (type == FILE_TYPE_PIPE)

status->st_mode = _S_IFIFO;

return 0;

}

if (!GetFileInformationByHandle(h, &info)) {

/* The Win32 error is already set, but we also set errno for

callers who expect it */

errno = winerror_to_errno(GetLastError());

return -1;

}

_Py_attribute_data_to_stat(&info, 0, status);

/* specific to fstat() */

status->st_ino = (((uint64_t)info.nFileIndexHigh) << 32) + info.nFileIndexLow;

return 0;

#else

return fstat(fd, status);

#endif

}

/* Return information about a file.

On POSIX, use fstat().

On Windows, use GetFileType() and GetFileInformationByHandle() which support

files larger than 2 GiB. fstat() may fail with EOVERFLOW on files larger

than 2 GiB because the file size type is a signed 32-bit integer: see issue

#23152.

Raise an exception and return -1 on error. On Windows, set the last Windows

error on error. On POSIX, set errno on error. Fill status and return 0 on

success.

Release the GIL to call GetFileType() and GetFileInformationByHandle(), or

to call fstat(). The caller must hold the GIL. */

int

_Py_fstat(int fd, struct _Py_stat_struct *status)

{

int res;

assert(PyGILState_Check());

Py_BEGIN_ALLOW_THREADS

res = _Py_fstat_noraise(fd, status);

Py_END_ALLOW_THREADS

if (res != 0) {

#ifdef MS_WINDOWS

PyErr_SetFromWindowsErr(0);

#else

PyErr_SetFromErrno(PyExc_OSError);

#endif

return -1;

}

return 0;

}

/* Call _wstat() on Windows, or encode the path to the filesystem encoding and

call stat() otherwise. Only fill st_mode attribute on Windows.

Return 0 on success, -1 on _wstat() / stat() error, -2 if an exception was

raised. */

int

_Py_stat(PyObject *path, struct stat *statbuf)

{

#ifdef MS_WINDOWS

int err;

struct _stat wstatbuf;

const wchar_t *wpath;

wpath = _PyUnicode_AsUnicode(path);

if (wpath == NULL)

return -2;

err = _wstat(wpath, &wstatbuf);

if (!err)

statbuf->st_mode = wstatbuf.st_mode;

return err;

#else

int ret;

PyObject *bytes;

char *cpath;

bytes = PyUnicode_EncodeFSDefault(path);

if (bytes == NULL)

return -2;

/* check for embedded null bytes */

if (PyBytes_AsStringAndSize(bytes, &cpath, NULL) == -1) {

Py_DECREF(bytes);

return -2;

}

ret = stat(cpath, statbuf);

Py_DECREF(bytes);

return ret;

#endif

}

/* This function MUST be kept async-signal-safe on POSIX when raise=0. */

static int

get_inheritable(int fd, int raise)

{

#ifdef MS_WINDOWS

HANDLE handle;

DWORD flags;

_Py_BEGIN_SUPPRESS_IPH

handle = (HANDLE)_get_osfhandle(fd);

_Py_END_SUPPRESS_IPH

if (handle == INVALID_HANDLE_VALUE) {

if (raise)

PyErr_SetFromErrno(PyExc_OSError);

return -1;

}

if (!GetHandleInformation(handle, &flags)) {

if (raise)

PyErr_SetFromWindowsErr(0);

return -1;

}

return (flags & HANDLE_FLAG_INHERIT);

#else

int flags;

flags = fcntl(fd, F_GETFD, 0);

if (flags == -1) {

if (raise)

PyErr_SetFromErrno(PyExc_OSError);

return -1;

}

return !(flags & FD_CLOEXEC);

#endif

}

/* Get the inheritable flag of the specified file descriptor.

Return 1 if the file descriptor can be inherited, 0 if it cannot,

raise an exception and return -1 on error. */

int

_Py_get_inheritable(int fd)

{

return get_inheritable(fd, 1);

}

/* This function MUST be kept async-signal-safe on POSIX when raise=0. */

static int

set_inheritable(int fd, int inheritable, int raise, int *atomic_flag_works)

{

#ifdef MS_WINDOWS

HANDLE handle;

DWORD flags;

#else

#if defined(HAVE_SYS_IOCTL_H) && defined(FIOCLEX) && defined(FIONCLEX)

static int ioctl_works = -1;

int request;

int err;

#endif

int flags, new_flags;

int res;

#endif

/* atomic_flag_works can only be used to make the file descriptor

non-inheritable */

assert(!(atomic_flag_works != NULL && inheritable));

if (atomic_flag_works != NULL && !inheritable) {

if (*atomic_flag_works == -1) {

int isInheritable = get_inheritable(fd, raise);

if (isInheritable == -1)

return -1;

*atomic_flag_works = !isInheritable;

}

if (*atomic_flag_works)

return 0;

}

#ifdef MS_WINDOWS

_Py_BEGIN_SUPPRESS_IPH

handle = (HANDLE)_get_osfhandle(fd);

_Py_END_SUPPRESS_IPH

if (handle == INVALID_HANDLE_VALUE) {