/*

* 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>

#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

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()

{

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()

{

return _getNativeMachine() == IMAGE_FILE_MACHINE_AMD64;

}

bool

isARM64Host()

{

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;

}

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);

}

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

*** 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 or

// the environment, rather than the command line or a shebang 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 contiuning

bool help;

// 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;

}

#define DEBUGNAME(s) L"SearchInfo." ## s

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

#define DEBUG_2(s, sl) _debugStringAndLength((search->s), (search->sl), DEBUGNAME(#s))

#define DEBUG_BOOL(s) debug(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);

#undef DEBUG_BOOL

#undef DEBUG_2

#undef DEBUG

#undef DEBUGNAME

}

int

findArgumentLength(const wchar_t *buffer, int bufferLength)

{

if (bufferLength < 0) {

bufferLength = (int)wcsnlen_s(buffer, MAXLEN);

}

if (bufferLength == 0) {

return 0;

}

const wchar_t *end;

int i;

if (buffer[0] != L'"') {

end = wcschr(buffer, L' ');

if (!end) {

return bufferLength;

}

i = (int)(end - buffer);

return i < bufferLength ? i : bufferLength;

}

i = 0;

while (i < bufferLength) {

end = wcschr(&buffer[i + 1], L'"');

if (!end) {

return bufferLength;

}

i = (int)(end - buffer);

if (i >= bufferLength) {

return bufferLength;

}

int j = i;

while (j > 1 && buffer[--j] == L'\\') {

if (j > 0 && buffer[--j] == L'\\') {

// Even number, so back up and keep counting

} else {

// Odd number, so it's escaped and we want to keep searching

continue;

}

}

// Non-escaped quote with space after it - end of the argument!

if (i + 1 >= bufferLength || isspace(buffer[i + 1])) {

return i + 1;

}

}

return bufferLength;

}

const wchar_t *

findArgumentEnd(const wchar_t *buffer, int bufferLength)

{

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

}

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

*** COMMAND-LINE PARSING ***

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

int

parseCommandLine(SearchInfo *search)

{

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

return RC_NO_COMMANDLINE;

}

const wchar_t *tail = findArgumentEnd(search->originalCmdLine, -1);

const wchar_t *end = tail;

search->restOfCmdLine = tail;

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

if (*tail == L'.' && end == search->restOfCmdLine) {

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 prefixLength = (int)wcsnlen_s(prefix, MAXLEN);

if (bufferLength < prefixLength) {

return false;

}

if (rest) {

*rest = &buffer[prefixLength];

}

return _startsWithArgument(buffer, bufferLength, prefix, prefixLength);

}

int

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

{

if (isEnvVarSet(L"PYLAUNCHER_NO_SEARCH_PATH")) {

return RC_NO_SHEBANG;

}

wchar_t *command;

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

return RC_NO_SHEBANG;

}

wchar_t filename[MAXLEN];

int lastDot = 0;

int commandLength = 0;

while (commandLength < MAXLEN && command[commandLength] && !isspace(command[commandLength])) {

if (command[commandLength] == L'.') {

lastDot = commandLength;

}

filename[commandLength] = command[commandLength];

commandLength += 1;

}

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

return RC_BAD_VIRTUAL_PATH;

}

filename[commandLength] = L'\0';

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;

}

}

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;

}

// 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_NO_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;

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) {

return 0;

}

wchar_t *pC = command;

for (int i = 0; i < shebangLength; ++i) {

wchar_t c = shebang[i];

if (isspace(c) && !inQuote) {

commandLength = i;

break;

} else if (c == L'"') {

inQuote = !inQuote;

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

*pC++ = L'\\';

} else {

*pC++ = c;

}

}

*pC = L'\0';

if (!GetCurrentDirectoryW(MAXLEN, buffer) ||

wcsncpy_s(script, MAXLEN, search->scriptFile, search->scriptFileLength) ||

FAILED(PathCchCombineEx(buffer, MAXLEN, buffer, script,

PATHCCH_ALLOW_LONG_PATHS)) ||

FAILED(PathCchRemoveFileSpec(buffer, MAXLEN)) ||

FAILED(PathCchCombineEx(buffer, MAXLEN, buffer, command,

PATHCCH_ALLOW_LONG_PATHS))

) {

return RC_NO_MEMORY;

}

int n = (int)wcsnlen(buffer, MAXLEN);

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

if (!path) {

return RC_NO_MEMORY;

}

wcscpy_s(path, n + 1, buffer);

search->executablePath = path;

if (commandLength) {

search->executableArgs = &shebang[commandLength];

search->executableArgsLength = shebangLength - commandLength;

}

return 0;

}

int

checkShebang(SearchInfo *search)

{

// Do not check shebang if a tag was provided or if no script file

// was found on the command line.

if (search->tag || !search->scriptFile) {

return 0;

}

if (search->scriptFileLength < 0) {

search->scriptFileLength = (int)wcsnlen_s(search->scriptFile, MAXLEN);

}

wchar_t *scriptFile = (wchar_t*)malloc(sizeof(wchar_t) * (search->scriptFileLength + 1));

if (!scriptFile) {

return RC_NO_MEMORY;

}

wcsncpy_s(scriptFile, search->scriptFileLength + 1,

search->scriptFile, search->scriptFileLength);

HANDLE hFile = CreateFileW(scriptFile, GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,

NULL, OPEN_EXISTING, 0, NULL);

if (hFile == INVALID_HANDLE_VALUE) {

debug(L"# Failed to open %s for shebang parsing (0x%08X)\n",

scriptFile, GetLastError());

free(scriptFile);

return 0;

}

DWORD bytesRead = 0;

char buffer[4096];

if (!ReadFile(hFile, buffer, sizeof(buffer), &bytesRead, NULL)) {

debug(L"# Failed to read %s for shebang parsing (0x%08X)\n",

scriptFile, GetLastError());

free(scriptFile);

return 0;

}

CloseHandle(hFile);

debug(L"# Read %d bytes from %s to find shebang line\n", bytesRead, scriptFile);

free(scriptFile);

char *b = buffer;

bool onlyUtf8 = false;

if (bytesRead > 3 && *b == 0xEF) {

if (*++b == 0xBB && *++b == 0xBF) {

// Allow a UTF-8 BOM

++b;

bytesRead -= 3;

onlyUtf8 = true;

} else {

debug(L"# Invalid BOM in shebang line");

return 0;

}

}

if (bytesRead <= 2 || b[0] != '#' || b[1] != '!') {

// No shebang (#!) at start of line

debug(L"# No valid shebang line");

return 0;

}

++b;

--bytesRead;

while (--bytesRead > 0 && isspace(*++b)) { }

char *start = b;

while (--bytesRead > 0 && *++b != '\r' && *b != '\n') { }

wchar_t *shebang;

int shebangLength;