/*

* Rewritten Python launcher for Windows

*

* This new rewrite properly handles PEP 514 and allows any registered Python

* runtime to be launched. It also enables auto-install of versions when they

* are requested but no installation can be found.

*/

#define __STDC_WANT_LIB_EXT1__ 1

#include <windows.h>

#include <pathcch.h>

#include <fcntl.h>

#include <io.h>

#include <shlobj.h>

#include <stdio.h>

#include <stdbool.h>

#include <tchar.h>

#include <assert.h>

#define MS_WINDOWS

#include "patchlevel.h"

#define MAXLEN PATHCCH_MAX_CCH

#define MSGSIZE 1024

#define RC_NO_STD_HANDLES 100

#define RC_CREATE_PROCESS 101

#define RC_BAD_VIRTUAL_PATH 102

#define RC_NO_PYTHON 103

#define RC_NO_MEMORY 104

#define RC_NO_SCRIPT 105

#define RC_NO_VENV_CFG 106

#define RC_BAD_VENV_CFG 107

#define RC_NO_COMMANDLINE 108

#define RC_INTERNAL_ERROR 109

#define RC_DUPLICATE_ITEM 110

#define RC_INSTALLING 111

#define RC_NO_PYTHON_AT_ALL 112

#define RC_NO_SHEBANG 113

#define RC_RECURSIVE_SHEBANG 114

static FILE * log_fp = NULL;

void

debug(wchar_t * format, ...)

{

va_list va;

if (log_fp != NULL) {

wchar_t buffer[MAXLEN];

int r = 0;

va_start(va, format);

r = vswprintf_s(buffer, MAXLEN, format, va);

va_end(va);

if (r <= 0) {

return;

}

fputws(buffer, log_fp);

while (r && isspace(buffer[r])) {

buffer[r--] = L'\0';

}

if (buffer[0]) {

OutputDebugStringW(buffer);

}

}

}

void

formatWinerror(int rc, wchar_t * message, int size)

{

FormatMessageW(

FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,

NULL, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

message, size, NULL);

}

void

winerror(int err, wchar_t * format, ... )

{

va_list va;

wchar_t message[MSGSIZE];

wchar_t win_message[MSGSIZE];

int len;

if (err == 0) {

err = GetLastError();

}

va_start(va, format);

len = _vsnwprintf_s(message, MSGSIZE, _TRUNCATE, format, va);

va_end(va);

formatWinerror(err, win_message, MSGSIZE);

if (len >= 0) {

_snwprintf_s(&message[len], MSGSIZE - len, _TRUNCATE, L": %s",

win_message);

}

#if !defined(_WINDOWS)

fwprintf(stderr, L"%s\n", message);

#else

MessageBoxW(NULL, message, L"Python Launcher is sorry to say ...",

MB_OK);

#endif

}

void

error(wchar_t * format, ... )

{

va_list va;

wchar_t message[MSGSIZE];

va_start(va, format);

_vsnwprintf_s(message, MSGSIZE, _TRUNCATE, format, va);

va_end(va);

#if !defined(_WINDOWS)

fwprintf(stderr, L"%s\n", message);

#else

MessageBoxW(NULL, message, L"Python Launcher is sorry to say ...",

MB_OK);

#endif

}

typedef BOOL (*PIsWow64Process2)(HANDLE, USHORT*, USHORT*);

USHORT

_getNativeMachine(void)

{

static USHORT _nativeMachine = IMAGE_FILE_MACHINE_UNKNOWN;

if (_nativeMachine == IMAGE_FILE_MACHINE_UNKNOWN) {

USHORT processMachine;

HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");

PIsWow64Process2 IsWow64Process2 = kernel32 ?

(PIsWow64Process2)GetProcAddress(kernel32, "IsWow64Process2") :

NULL;

if (!IsWow64Process2) {

BOOL wow64Process;

if (!IsWow64Process(NULL, &wow64Process)) {

winerror(0, L"Checking process type");

} else if (wow64Process) {

// We should always be a 32-bit executable, so if running

// under emulation, it must be a 64-bit host.

_nativeMachine = IMAGE_FILE_MACHINE_AMD64;

} else {

// Not running under emulation, and an old enough OS to not

// have IsWow64Process2, so assume it's x86.

_nativeMachine = IMAGE_FILE_MACHINE_I386;

}

} else if (!IsWow64Process2(NULL, &processMachine, &_nativeMachine)) {

winerror(0, L"Checking process type");

}

}

return _nativeMachine;

}

bool

isAMD64Host(void)

{

return _getNativeMachine() == IMAGE_FILE_MACHINE_AMD64;

}

bool

isARM64Host(void)

{

return _getNativeMachine() == IMAGE_FILE_MACHINE_ARM64;

}

bool

isEnvVarSet(const wchar_t *name)

{

/* only looking for non-empty, which means at least one character

and the null terminator */

return GetEnvironmentVariableW(name, NULL, 0) >= 2;

}

bool

join(wchar_t *buffer, size_t bufferLength, const wchar_t *fragment)

{

if (SUCCEEDED(PathCchCombineEx(buffer, bufferLength, buffer, fragment, PATHCCH_ALLOW_LONG_PATHS))) {

return true;

}

return false;

}

bool

split_parent(wchar_t *buffer, size_t bufferLength)

{

return SUCCEEDED(PathCchRemoveFileSpec(buffer, bufferLength));

}

int

_compare(const wchar_t *x, int xLen, const wchar_t *y, int yLen)

{

// Empty strings sort first

if (!x || !xLen) {

return (!y || !yLen) ? 0 : -1;

} else if (!y || !yLen) {

return 1;

}

switch (CompareStringEx(

LOCALE_NAME_INVARIANT, NORM_IGNORECASE | SORT_DIGITSASNUMBERS,

x, xLen, y, yLen,

NULL, NULL, 0

)) {

case CSTR_LESS_THAN:

return -1;

case CSTR_EQUAL:

return 0;

case CSTR_GREATER_THAN:

return 1;

default:

winerror(0, L"Error comparing '%.*s' and '%.*s' (compare)", xLen, x, yLen, y);

return -1;

}

}

int

_compareArgument(const wchar_t *x, int xLen, const wchar_t *y, int yLen)

{

// Empty strings sort first

if (!x || !xLen) {

return (!y || !yLen) ? 0 : -1;

} else if (!y || !yLen) {

return 1;

}

switch (CompareStringEx(

LOCALE_NAME_INVARIANT, 0,

x, xLen, y, yLen,

NULL, NULL, 0

)) {

case CSTR_LESS_THAN:

return -1;

case CSTR_EQUAL:

return 0;

case CSTR_GREATER_THAN:

return 1;

default:

winerror(0, L"Error comparing '%.*s' and '%.*s' (compareArgument)", xLen, x, yLen, y);

return -1;

}

}

int

_comparePath(const wchar_t *x, int xLen, const wchar_t *y, int yLen)

{

// Empty strings sort first

if (!x || !xLen) {

return !y || !yLen ? 0 : -1;

} else if (!y || !yLen) {

return 1;

}

switch (CompareStringOrdinal(x, xLen, y, yLen, TRUE)) {

case CSTR_LESS_THAN:

return -1;

case CSTR_EQUAL:

return 0;

case CSTR_GREATER_THAN:

return 1;

default:

winerror(0, L"Error comparing '%.*s' and '%.*s' (comparePath)", xLen, x, yLen, y);

return -1;

}

}

bool

_startsWith(const wchar_t *x, int xLen, const wchar_t *y, int yLen)

{

if (!x || !y) {

return false;

}

yLen = yLen < 0 ? (int)wcsnlen_s(y, MAXLEN) : yLen;

xLen = xLen < 0 ? (int)wcsnlen_s(x, MAXLEN) : xLen;

return xLen >= yLen && 0 == _compare(x, yLen, y, yLen);

}

bool

_startsWithArgument(const wchar_t *x, int xLen, const wchar_t *y, int yLen)

{

if (!x || !y) {

return false;

}

yLen = yLen < 0 ? (int)wcsnlen_s(y, MAXLEN) : yLen;

xLen = xLen < 0 ? (int)wcsnlen_s(x, MAXLEN) : xLen;

return xLen >= yLen && 0 == _compareArgument(x, yLen, y, yLen);

}

// Unlike regular startsWith, this function requires that the following

// character is either NULL (that is, the entire string matches) or is one of

// the characters in 'separators'.

bool

_startsWithSeparated(const wchar_t *x, int xLen, const wchar_t *y, int yLen, const wchar_t *separators)

{

if (!x || !y) {

return false;

}

yLen = yLen < 0 ? (int)wcsnlen_s(y, MAXLEN) : yLen;

xLen = xLen < 0 ? (int)wcsnlen_s(x, MAXLEN) : xLen;

if (xLen < yLen) {

return false;

}

if (xLen == yLen) {

return 0 == _compare(x, xLen, y, yLen);

}

return separators &&

0 == _compare(x, yLen, y, yLen) &&

wcschr(separators, x[yLen]) != NULL;

}

/******************************************************************************\

*** HELP TEXT ***

\******************************************************************************/

int

showHelpText(wchar_t ** argv)

{

// The help text is stored in launcher-usage.txt, which is compiled into

// the launcher and loaded at runtime if needed.

//

// The file must be UTF-8. There are two substitutions:

// %ls - PY_VERSION (as wchar_t*)

// %ls - argv[0] (as wchar_t*)

HRSRC res = FindResourceExW(NULL, L"USAGE", MAKEINTRESOURCE(1), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));

HGLOBAL resData = res ? LoadResource(NULL, res) : NULL;

const char *usage = resData ? (const char*)LockResource(resData) : NULL;

if (usage == NULL) {

winerror(0, L"Unable to load usage text");

return RC_INTERNAL_ERROR;

}

DWORD cbData = SizeofResource(NULL, res);

DWORD cchUsage = MultiByteToWideChar(CP_UTF8, 0, usage, cbData, NULL, 0);

if (!cchUsage) {

winerror(0, L"Unable to preprocess usage text");

return RC_INTERNAL_ERROR;

}

cchUsage += 1;

wchar_t *wUsage = (wchar_t*)malloc(cchUsage * sizeof(wchar_t));

cchUsage = MultiByteToWideChar(CP_UTF8, 0, usage, cbData, wUsage, cchUsage);

if (!cchUsage) {

winerror(0, L"Unable to preprocess usage text");

free((void *)wUsage);

return RC_INTERNAL_ERROR;

}

// Ensure null termination

wUsage[cchUsage] = L'\0';

fwprintf(stdout, wUsage, (L"" PY_VERSION), argv[0]);

fflush(stdout);

free((void *)wUsage);

return 0;

}

/******************************************************************************\

*** SEARCH INFO ***

\******************************************************************************/

struct _SearchInfoBuffer {

struct _SearchInfoBuffer *next;

wchar_t buffer[0];

};

typedef struct {

// the original string, managed by the OS

const wchar_t *originalCmdLine;

// pointer into the cmdline to mark what we've consumed

const wchar_t *restOfCmdLine;

// if known/discovered, the full executable path of our runtime

const wchar_t *executablePath;

// pointer and length into cmdline for the file to check for a

// shebang line, if any. Length can be -1 if the string is null

// terminated.

const wchar_t *scriptFile;

int scriptFileLength;

// pointer and length into cmdline or a static string with the

// name of the target executable. Length can be -1 if the string

// is null terminated.

const wchar_t *executable;

int executableLength;

// pointer and length into a string with additional interpreter

// arguments to include before restOfCmdLine. Length can be -1 if

// the string is null terminated.

const wchar_t *executableArgs;

int executableArgsLength;

// pointer and length into cmdline or a static string with the

// company name for PEP 514 lookup. Length can be -1 if the string

// is null terminated.

const wchar_t *company;

int companyLength;

// pointer and length into cmdline or a static string with the

// tag for PEP 514 lookup. Length can be -1 if the string is

// null terminated.

const wchar_t *tag;

int tagLength;

// if true, treats 'tag' as a non-PEP 514 filter

bool oldStyleTag;

// if true, ignores 'tag' when a high priority environment is found

// gh-92817: This is currently set when a tag is read from configuration,

// the environment, or a shebang, rather than the command line, and the

// only currently possible high priority environment is an active virtual

// environment

bool lowPriorityTag;

// if true, allow PEP 514 lookup to override 'executable'

bool allowExecutableOverride;

// if true, allow a nearby pyvenv.cfg to locate the executable

bool allowPyvenvCfg;

// if true, allow defaults (env/py.ini) to clarify/override tags

bool allowDefaults;

// if true, prefer windowed (console-less) executable

bool windowed;

// if true, only list detected runtimes without launching

bool list;

// if true, only list detected runtimes with paths without launching

bool listPaths;

// if true, display help message before continuing

bool help;

// if set, limits search to registry keys with the specified Company

// This is intended for debugging and testing only

const wchar_t *limitToCompany;

// dynamically allocated buffers to free later

struct _SearchInfoBuffer *_buffer;

} SearchInfo;

wchar_t *

allocSearchInfoBuffer(SearchInfo *search, int wcharCount)

{

struct _SearchInfoBuffer *buffer = (struct _SearchInfoBuffer*)malloc(

sizeof(struct _SearchInfoBuffer) +

wcharCount * sizeof(wchar_t)

);

if (!buffer) {

return NULL;

}

buffer->next = search->_buffer;

search->_buffer = buffer;

return buffer->buffer;

}

void

freeSearchInfo(SearchInfo *search)

{

struct _SearchInfoBuffer *b = search->_buffer;

search->_buffer = NULL;

while (b) {

struct _SearchInfoBuffer *nextB = b->next;

free((void *)b);

b = nextB;

}

}

void

_debugStringAndLength(const wchar_t *s, int len, const wchar_t *name)

{

if (!s) {

debug(L"%s: (null)\n", name);

} else if (len == 0) {

debug(L"%s: (empty)\n", name);

} else if (len < 0) {

debug(L"%s: %s\n", name, s);

} else {

debug(L"%s: %.*ls\n", name, len, s);

}

}

void

dumpSearchInfo(SearchInfo *search)

{

if (!log_fp) {

return;

}

#ifdef __clang__

#define DEBUGNAME(s) L # s

#else

#define DEBUGNAME(s) # s

#endif

#define DEBUG(s) debug(L"SearchInfo." DEBUGNAME(s) L": %s\n", (search->s) ? (search->s) : L"(null)")

#define DEBUG_2(s, sl) _debugStringAndLength((search->s), (search->sl), L"SearchInfo." DEBUGNAME(s))

#define DEBUG_BOOL(s) debug(L"SearchInfo." DEBUGNAME(s) L": %s\n", (search->s) ? L"True" : L"False")

DEBUG(originalCmdLine);

DEBUG(restOfCmdLine);

DEBUG(executablePath);

DEBUG_2(scriptFile, scriptFileLength);

DEBUG_2(executable, executableLength);

DEBUG_2(executableArgs, executableArgsLength);

DEBUG_2(company, companyLength);

DEBUG_2(tag, tagLength);

DEBUG_BOOL(oldStyleTag);

DEBUG_BOOL(lowPriorityTag);

DEBUG_BOOL(allowDefaults);

DEBUG_BOOL(allowExecutableOverride);

DEBUG_BOOL(windowed);

DEBUG_BOOL(list);

DEBUG_BOOL(listPaths);

DEBUG_BOOL(help);

DEBUG(limitToCompany);

#undef DEBUG_BOOL

#undef DEBUG_2

#undef DEBUG

#undef DEBUGNAME

}

int

findArgv0Length(const wchar_t *buffer, int bufferLength)

{

// Note: this implements semantics that are only valid for argv0.

// Specifically, there is no escaping of quotes, and quotes within

// the argument have no effect. A quoted argv0 must start and end

// with a double quote character; otherwise, it ends at the first

// ' ' or '\t'.

int quoted = buffer[0] == L'"';

for (int i = 1; bufferLength < 0 || i < bufferLength; ++i) {

switch (buffer[i]) {

case L'\0':

return i;

case L' ':

case L'\t':

if (!quoted) {

return i;

}

break;

case L'"':

if (quoted) {

return i + 1;

}

break;

}

}

return bufferLength;

}

const wchar_t *

findArgv0End(const wchar_t *buffer, int bufferLength)

{

return &buffer[findArgv0Length(buffer, bufferLength)];

}

/******************************************************************************\

*** COMMAND-LINE PARSING ***

\******************************************************************************/

// Adapted from https://stackoverflow.com/a/65583702

typedef struct AppExecLinkFile { // For tag IO_REPARSE_TAG_APPEXECLINK

DWORD reparseTag;

WORD reparseDataLength;

WORD reserved;

ULONG version;

wchar_t stringList[MAX_PATH * 4]; // Multistring (Consecutive UTF-16 strings each ending with a NUL)

/* There are normally 4 strings here. Ex:

Package ID: L"Microsoft.DesktopAppInstaller_8wekyb3d8bbwe"

Entry Point: L"Microsoft.DesktopAppInstaller_8wekyb3d8bbwe!PythonRedirector"

Executable: L"C:\Program Files\WindowsApps\Microsoft.DesktopAppInstaller_1.17.106910_x64__8wekyb3d8bbwe\AppInstallerPythonRedirector.exe"

Applic. Type: L"0" // Integer as ASCII. "0" = Desktop bridge application; Else sandboxed UWP application

*/

} AppExecLinkFile;

int

parseCommandLine(SearchInfo *search)

{

if (!search || !search->originalCmdLine) {

return RC_NO_COMMANDLINE;

}

const wchar_t *argv0End = findArgv0End(search->originalCmdLine, -1);

const wchar_t *tail = argv0End; // will be start of the executable name

const wchar_t *end = argv0End; // will be end of the executable name

search->restOfCmdLine = argv0End; // will be first space after argv0

while (--tail != search->originalCmdLine) {

if (*tail == L'"' && end == argv0End) {

// Move the "end" up to the quote, so we also allow moving for

// a period later on.

end = argv0End = tail;

} else if (*tail == L'.' && end == argv0End) {

end = tail;

} else if (*tail == L'\\' || *tail == L'/') {

++tail;

break;

}

}

if (tail == search->originalCmdLine && tail[0] == L'"') {

++tail;

}

// Without special cases, we can now fill in the search struct

int tailLen = (int)(end ? (end - tail) : wcsnlen_s(tail, MAXLEN));

search->executableLength = -1;

// Our special cases are as follows

#define MATCHES(s) (0 == _comparePath(tail, tailLen, (s), -1))

#define STARTSWITH(s) _startsWith(tail, tailLen, (s), -1)

if (MATCHES(L"py")) {

search->executable = L"python.exe";

search->allowExecutableOverride = true;

search->allowDefaults = true;

} else if (MATCHES(L"pyw")) {

search->executable = L"pythonw.exe";

search->allowExecutableOverride = true;

search->allowDefaults = true;

search->windowed = true;

} else if (MATCHES(L"py_d")) {

search->executable = L"python_d.exe";

search->allowExecutableOverride = true;

search->allowDefaults = true;

} else if (MATCHES(L"pyw_d")) {

search->executable = L"pythonw_d.exe";

search->allowExecutableOverride = true;

search->allowDefaults = true;

search->windowed = true;

} else if (STARTSWITH(L"python3")) {

search->executable = L"python.exe";

search->tag = &tail[6];

search->tagLength = tailLen - 6;

search->allowExecutableOverride = true;

search->oldStyleTag = true;

search->allowPyvenvCfg = true;

} else if (STARTSWITH(L"pythonw3")) {

search->executable = L"pythonw.exe";

search->tag = &tail[7];

search->tagLength = tailLen - 7;

search->allowExecutableOverride = true;

search->oldStyleTag = true;

search->allowPyvenvCfg = true;

search->windowed = true;

} else {

search->executable = tail;

search->executableLength = tailLen;

search->allowPyvenvCfg = true;

}

#undef STARTSWITH

#undef MATCHES

// First argument might be one of our options. If so, consume it,

// update flags and then set restOfCmdLine.

const wchar_t *arg = search->restOfCmdLine;

while(*arg && isspace(*arg)) { ++arg; }

#define MATCHES(s) (0 == _compareArgument(arg, argLen, (s), -1))

#define STARTSWITH(s) _startsWithArgument(arg, argLen, (s), -1)

if (*arg && *arg == L'-' && *++arg) {

tail = arg;

while (*tail && !isspace(*tail)) { ++tail; }

int argLen = (int)(tail - arg);

if (argLen > 0) {

if (STARTSWITH(L"2") || STARTSWITH(L"3")) {

// All arguments starting with 2 or 3 are assumed to be version tags

search->tag = arg;

search->tagLength = argLen;

search->oldStyleTag = true;

search->restOfCmdLine = tail;

} else if (STARTSWITH(L"V:") || STARTSWITH(L"-version:")) {

// Arguments starting with 'V:' specify company and/or tag

const wchar_t *argStart = wcschr(arg, L':') + 1;

const wchar_t *tagStart = wcschr(argStart, L'/') ;

if (tagStart) {

search->company = argStart;

search->companyLength = (int)(tagStart - argStart);

search->tag = tagStart + 1;

} else {

search->tag = argStart;

}

search->tagLength = (int)(tail - search->tag);

search->allowDefaults = false;

search->restOfCmdLine = tail;

} else if (MATCHES(L"0") || MATCHES(L"-list")) {

search->list = true;

search->restOfCmdLine = tail;

} else if (MATCHES(L"0p") || MATCHES(L"-list-paths")) {

search->listPaths = true;

search->restOfCmdLine = tail;

} else if (MATCHES(L"h") || MATCHES(L"-help")) {

search->help = true;

// Do not update restOfCmdLine so that we trigger the help

// message from whichever interpreter we select

}

}

}

#undef STARTSWITH

#undef MATCHES

// Might have a script filename. If it looks like a filename, add

// it to the SearchInfo struct for later reference.

arg = search->restOfCmdLine;

while(*arg && isspace(*arg)) { ++arg; }

if (*arg && *arg != L'-') {

search->scriptFile = arg;

if (*arg == L'"') {

++search->scriptFile;

while (*++arg && *arg != L'"') { }

} else {

while (*arg && !isspace(*arg)) { ++arg; }

}

search->scriptFileLength = (int)(arg - search->scriptFile);

}

return 0;

}

int

_decodeShebang(SearchInfo *search, const char *buffer, int bufferLength, bool onlyUtf8, wchar_t **decoded, int *decodedLength)

{

DWORD cp = CP_UTF8;

int wideLen = MultiByteToWideChar(cp, MB_ERR_INVALID_CHARS, buffer, bufferLength, NULL, 0);

if (!wideLen) {

cp = CP_ACP;

wideLen = MultiByteToWideChar(cp, MB_ERR_INVALID_CHARS, buffer, bufferLength, NULL, 0);

if (!wideLen) {

debug(L"# Failed to decode shebang line (0x%08X)\n", GetLastError());

return RC_BAD_VIRTUAL_PATH;

}

}

wchar_t *b = allocSearchInfoBuffer(search, wideLen + 1);

if (!b) {

return RC_NO_MEMORY;

}

wideLen = MultiByteToWideChar(cp, 0, buffer, bufferLength, b, wideLen + 1);

if (!wideLen) {

debug(L"# Failed to decode shebang line (0x%08X)\n", GetLastError());

return RC_BAD_VIRTUAL_PATH;

}

b[wideLen] = L'\0';

*decoded = b;

*decodedLength = wideLen;

return 0;

}

bool

_shebangStartsWith(const wchar_t *buffer, int bufferLength, const wchar_t *prefix, const wchar_t **rest, int *firstArgumentLength)

{

int prefixLength = (int)wcsnlen_s(prefix, MAXLEN);

if (bufferLength < prefixLength || !_startsWithArgument(buffer, bufferLength, prefix, prefixLength)) {

return false;

}

if (rest) {

*rest = &buffer[prefixLength];

}

if (firstArgumentLength) {

int i = prefixLength;

while (i < bufferLength && !isspace(buffer[i])) {

i += 1;

}

*firstArgumentLength = i - prefixLength;

}

return true;

}

int

ensure_no_redirector_stub(wchar_t* filename, wchar_t* buffer)

{

// Make sure we didn't find a reparse point that will open the Microsoft Store

// If we did, pretend there was no shebang and let normal handling take over

WIN32_FIND_DATAW findData;

HANDLE hFind = FindFirstFileW(buffer, &findData);

if (!hFind) {

// Let normal handling take over

debug(L"# Did not find %s on PATH\n", filename);

return RC_NO_SHEBANG;

}

FindClose(hFind);

if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT &&

findData.dwReserved0 & IO_REPARSE_TAG_APPEXECLINK)) {

return 0;

}

HANDLE hReparsePoint = CreateFileW(buffer, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL);

if (!hReparsePoint) {

// Let normal handling take over

debug(L"# Did not find %s on PATH\n", filename);

return RC_NO_SHEBANG;

}

AppExecLinkFile appExecLink;

if (!DeviceIoControl(hReparsePoint, FSCTL_GET_REPARSE_POINT, NULL, 0, &appExecLink, sizeof(appExecLink), NULL, NULL)) {

// Let normal handling take over

debug(L"# Did not find %s on PATH\n", filename);

CloseHandle(hReparsePoint);

return RC_NO_SHEBANG;

}

CloseHandle(hReparsePoint);

const wchar_t* redirectorPackageId = L"Microsoft.DesktopAppInstaller_8wekyb3d8bbwe";

if (0 == wcscmp(appExecLink.stringList, redirectorPackageId)) {

debug(L"# ignoring redirector that would launch store\n");

return RC_NO_SHEBANG;

}

return 0;

}

int

searchPath(SearchInfo *search, const wchar_t *shebang, int shebangLength)

{

if (isEnvVarSet(L"PYLAUNCHER_NO_SEARCH_PATH")) {

return RC_NO_SHEBANG;

}

wchar_t *command;

int commandLength;

if (!_shebangStartsWith(shebang, shebangLength, L"/usr/bin/env ", &command, &commandLength)) {

return RC_NO_SHEBANG;

}

if (!commandLength || commandLength == MAXLEN) {

return RC_BAD_VIRTUAL_PATH;

}

int lastDot = commandLength;

while (lastDot > 0 && command[lastDot] != L'.') {

lastDot -= 1;

}

if (!lastDot) {

lastDot = commandLength;

}

wchar_t filename[MAXLEN];

if (wcsncpy_s(filename, MAXLEN, command, commandLength)) {

return RC_BAD_VIRTUAL_PATH;

}

const wchar_t *ext = L".exe";

// If the command already has an extension, we do not want to add it again

if (!lastDot || _comparePath(&filename[lastDot], -1, ext, -1)) {

if (wcscat_s(filename, MAXLEN, L".exe")) {

return RC_BAD_VIRTUAL_PATH;

}

}

debug(L"# Search PATH for %s\n", filename);

wchar_t pathVariable[MAXLEN];

int n = GetEnvironmentVariableW(L"PATH", pathVariable, MAXLEN);

if (!n) {

if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {

return RC_NO_SHEBANG;

}

winerror(0, L"Failed to read PATH\n", filename);

return RC_INTERNAL_ERROR;

}

wchar_t buffer[MAXLEN];

n = SearchPathW(pathVariable, filename, NULL, MAXLEN, buffer, NULL);

if (!n) {

if (GetLastError() == ERROR_FILE_NOT_FOUND) {

debug(L"# Did not find %s on PATH\n", filename);

// If we didn't find it on PATH, let normal handling take over

return RC_NO_SHEBANG;

}

// Other errors should cause us to break

winerror(0, L"Failed to find %s on PATH\n", filename);

return RC_BAD_VIRTUAL_PATH;

}

int result = ensure_no_redirector_stub(filename, buffer);

if (result) {

return result;

}

// Check that we aren't going to call ourselves again

// If we are, pretend there was no shebang and let normal handling take over

if (GetModuleFileNameW(NULL, filename, MAXLEN) &&

0 == _comparePath(filename, -1, buffer, -1)) {

debug(L"# ignoring recursive shebang command\n");

return RC_RECURSIVE_SHEBANG;

}

wchar_t *buf = allocSearchInfoBuffer(search, n + 1);

if (!buf || wcscpy_s(buf, n + 1, buffer)) {

return RC_NO_MEMORY;

}

search->executablePath = buf;

search->executableArgs = &command[commandLength];

search->executableArgsLength = shebangLength - commandLength;

debug(L"# Found %s on PATH\n", buf);

return 0;

}

int

_readIni(const wchar_t *section, const wchar_t *settingName, wchar_t *buffer, int bufferLength)

{

wchar_t iniPath[MAXLEN];

int n;

// Check for _PYLAUNCHER_INIDIR override (used for test isolation)

DWORD len = GetEnvironmentVariableW(L"_PYLAUNCHER_INIDIR", iniPath, MAXLEN);

if (len && len < MAXLEN) {

if (join(iniPath, MAXLEN, L"py.ini")) {

debug(L"# Reading from %s for %s/%s\n", iniPath, section, settingName);

n = GetPrivateProfileStringW(section, settingName, NULL, buffer, bufferLength, iniPath);

if (n) {

debug(L"# Found %s in %s\n", settingName, iniPath);

return n;

}

}

// When _PYLAUNCHER_INIDIR is set, skip the default locations

return 0;

}

if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, iniPath)) &&

join(iniPath, MAXLEN, L"py.ini")) {

debug(L"# Reading from %s for %s/%s\n", iniPath, section, settingName);

n = GetPrivateProfileStringW(section, settingName, NULL, buffer, bufferLength, iniPath);

if (n) {

debug(L"# Found %s in %s\n", settingName, iniPath);

return n;

} else if (GetLastError() == ERROR_FILE_NOT_FOUND) {

debug(L"# Did not find file %s\n", iniPath);

} else {

winerror(0, L"Failed to read from %s\n", iniPath);

}

}

if (GetModuleFileNameW(NULL, iniPath, MAXLEN) &&

SUCCEEDED(PathCchRemoveFileSpec(iniPath, MAXLEN)) &&

join(iniPath, MAXLEN, L"py.ini")) {

debug(L"# Reading from %s for %s/%s\n", iniPath, section, settingName);

n = GetPrivateProfileStringW(section, settingName, NULL, buffer, MAXLEN, iniPath);

if (n) {

debug(L"# Found %s in %s\n", settingName, iniPath);

return n;

} else if (GetLastError() == ERROR_FILE_NOT_FOUND) {

debug(L"# Did not find file %s\n", iniPath);

} else {

winerror(0, L"Failed to read from %s\n", iniPath);

}

}

return 0;

}

bool

_findCommand(SearchInfo *search, const wchar_t *command, int commandLength)

{

wchar_t commandBuffer[MAXLEN];

wchar_t buffer[MAXLEN];

wcsncpy_s(commandBuffer, MAXLEN, command, commandLength);

int n = _readIni(L"commands", commandBuffer, buffer, MAXLEN);

if (!n) {

return false;

}

wchar_t *path = allocSearchInfoBuffer(search, n + 1);

if (!path) {

return false;

}

wcscpy_s(path, n + 1, buffer);

search->executablePath = path;

return true;

}

int

_useShebangAsExecutable(SearchInfo *search, const wchar_t *shebang, int shebangLength)

{

wchar_t buffer[MAXLEN];

wchar_t script[MAXLEN];

wchar_t command[MAXLEN];

int commandLength = 0;

int inQuote = 0;

if (!shebang || !shebangLength) {